Hello,

This patch reuses the patchset sent by Olivier Blin on 17/07/06. It actually 
would replace the "3-3-rdp-backend.so-OpenGL-hardware-acceleration.patch". It 
adds support of ARGB8888 gbm-format for the output, reads just the damaged 
pixels and y-flips back the image for repaint.

---
 {a => b}/compositor/main.c          |  23 ++-
 {a => b}/configure.ac               |   4 +-
 {a => b}/libweston/compositor-rdp.c | 361 +++++++++++++++++++++++++++++++++++-
 {a => b}/libweston/compositor-rdp.h |  24 +++
 4 files changed, 399 insertions(+), 13 deletions(-)

diff --git a/compositor/main.c b/compositor/main.c
index 1e82788..6a701dc 100644
--- a/compositor/main.c
+++ b/compositor/main.c
@@ -519,6 +519,7 @@ usage(int error_code)
                "  --rdp4-key=FILE\tThe file containing the key for RDP4 
encryption\n"
                "  --rdp-tls-cert=FILE\tThe file containing the certificate for 
TLS encryption\n"
                "  --rdp-tls-key=FILE\tThe file containing the private key for 
TLS encryption\n"
+               "  --use-pixman\t\tUse the pixman (CPU) renderer\n"
                "\n");
 #endif
 
@@ -1217,11 +1218,14 @@ static void
 rdp_backend_output_configure(struct wl_listener *listener, void *data)
 {
        struct weston_output *output = data;
+       struct weston_config *wc = wet_get_config(output->compositor);
        struct wet_compositor *compositor = 
to_wet_compositor(output->compositor);
        struct wet_output_config *parsed_options = compositor->parsed_options;
+       struct weston_config_section *section;
        const struct weston_rdp_output_api *api = 
weston_rdp_output_get_api(output->compositor);
        int width = 640;
        int height = 480;
+       char *gbm_format = NULL;
 
        assert(parsed_options);
 
@@ -1230,6 +1234,8 @@ rdp_backend_output_configure(struct wl_listener 
*listener, void *data)
                return;
        }
 
+       section = weston_config_get_section(wc, "output", "name", output->name);
+
        if (parsed_options->width)
                width = parsed_options->width;
 
@@ -1239,6 +1245,12 @@ rdp_backend_output_configure(struct wl_listener 
*listener, void *data)
        weston_output_set_scale(output, 1);
        weston_output_set_transform(output, WL_OUTPUT_TRANSFORM_NORMAL);
 
+       weston_config_section_get_string(section,
+                                        "gbm-format", &gbm_format, NULL);
+
+       api->set_gbm_format(output, gbm_format);
+       free(gbm_format);
+
        if (api->output_set_size(output, width, height) < 0) {
                weston_log("Cannot configure output \"%s\" using 
weston_rdp_output_api.\n",
                           output->name);
@@ -1261,6 +1273,7 @@ weston_rdp_backend_config_init(struct 
weston_rdp_backend_config *config)
        config->server_key = NULL;
        config->env_socket = 0;
        config->no_clients_resize = 0;
+       config->use_pixman = false;
 }
 
 static int
@@ -1268,6 +1281,7 @@ load_rdp_backend(struct weston_compositor *c,
                int *argc, char *argv[], struct weston_config *wc)
 {
        struct weston_rdp_backend_config config  = {{ 0, }};
+       struct weston_config_section *section;
        int ret = 0;
 
        struct wet_output_config *parsed_options = wet_init_parsed_options(c);
@@ -1285,11 +1299,17 @@ load_rdp_backend(struct weston_compositor *c,
                { WESTON_OPTION_BOOLEAN, "no-clients-resize", 0, 
&config.no_clients_resize },
                { WESTON_OPTION_STRING,  "rdp4-key", 0, &config.rdp_key },
                { WESTON_OPTION_STRING,  "rdp-tls-cert", 0, &config.server_cert 
},
-               { WESTON_OPTION_STRING,  "rdp-tls-key", 0, &config.server_key }
+               { WESTON_OPTION_STRING,  "rdp-tls-key", 0, &config.server_key },
+               { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &config.use_pixman }
        };
 
        parse_options(rdp_options, ARRAY_LENGTH(rdp_options), argc, argv);
 
+       section = weston_config_get_section(wc, "core", NULL, NULL);
+       weston_config_section_get_string(section,
+                                        "gbm-format", &config.gbm_format,
+                                        NULL);
+
        ret = weston_compositor_load_backend(c, WESTON_BACKEND_RDP,
                                             &config.base);
 
@@ -1303,6 +1323,7 @@ out:
        free(config.rdp_key);
        free(config.server_cert);
        free(config.server_key);
+       free(config.gbm_format);
 
        return ret;
 }
diff --git a/configure.ac b/configure.ac
index ff39469..2255d9e 100644
--- a/configure.ac
+++ b/configure.ac
@@ -260,9 +260,9 @@ AM_CONDITIONAL([ENABLE_RDP_COMPOSITOR],
                [test x$enable_rdp_compositor = xyes])
 if test x$enable_rdp_compositor = xyes; then
   AC_DEFINE([BUILD_RDP_COMPOSITOR], [1], [Build the RDP compositor])
-  PKG_CHECK_MODULES(RDP_COMPOSITOR, [freerdp2 >= 2.0.0],
+  PKG_CHECK_MODULES(RDP_COMPOSITOR, [freerdp2 >= 2.0.0 libudev >= 136 gbm],
     [],
-    [PKG_CHECK_MODULES(RDP_COMPOSITOR, [freerdp >= 1.1.0],[])]
+    [PKG_CHECK_MODULES(RDP_COMPOSITOR, [freerdp >= 1.1.0 libudev >= 136 
gbm],[])]
   )
 
   SAVED_CPPFLAGS="$CPPFLAGS"
diff --git a/libweston/compositor-rdp.c b/libweston/compositor-rdp.c
index ee68e96..e584088 100644
--- a/libweston/compositor-rdp.c
+++ b/libweston/compositor-rdp.c
@@ -30,8 +30,14 @@
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
+#include <dlfcn.h>
+#include <fcntl.h>
+#include <unistd.h>
 #include <linux/input.h>
 
+#include <gbm.h>
+#include <libudev.h>
+
 #if HAVE_FREERDP_VERSION_H
 #include <freerdp/version.h>
 #else
@@ -84,6 +90,7 @@
 #include "shared/timespec-util.h"
 #include "compositor.h"
 #include "compositor-rdp.h"
+#include "gl-renderer.h"
 #include "pixman-renderer.h"
 
 #define MAX_FREERDP_FDS 32
@@ -115,6 +122,13 @@ struct rdp_backend {
        char *rdp_key;
        int tls_enabled;
        int no_clients_resize;
+
+       /* For GL rendering */
+       struct udev *udev;
+       int drm_fd;
+       struct gbm_device *gbm;
+       uint32_t gbm_format;
+       int use_pixman;
 };
 
 enum peer_item_flags {
@@ -133,8 +147,16 @@ struct rdp_peers_item {
 struct rdp_output {
        struct weston_output base;
        struct wl_event_source *finish_frame_timer;
+       uint32_t gbm_format;
+       struct gbm_surface *gbm_surface;
        pixman_image_t *shadow_surface;
 
+       int format;
+       int stride;
+       int height;
+       uint32_t *tmpdata, *image;
+       uint32_t tmpdata_size;
+
        struct wl_list peers;
 };
 
@@ -164,6 +186,8 @@ to_rdp_backend(struct weston_compositor *base)
        return container_of(base->backend, struct rdp_backend, base);
 }
 
+static struct gl_renderer_interface *gl_renderer;
+
 static void
 rdp_peer_refresh_rfx(pixman_region32_t *damage, pixman_image_t *image, 
freerdp_peer *peer)
 {
@@ -365,12 +389,31 @@ rdp_output_repaint(struct weston_output *output_base, 
pixman_region32_t *damage,
 {
        struct rdp_output *output = container_of(output_base, struct 
rdp_output, base);
        struct weston_compositor *ec = output->base.compositor;
+       struct rdp_backend *b = to_rdp_backend(ec);
        struct rdp_peers_item *outputPeer;
 
-       pixman_renderer_output_set_buffer(output_base, output->shadow_surface);
+       if (b->use_pixman)
+               pixman_renderer_output_set_buffer(output_base, 
output->shadow_surface);
        ec->renderer->repaint_output(&output->base, damage);
 
        if (pixman_region32_not_empty(damage)) {
+               if (!b->use_pixman) {
+                       /* Performance: Only read pixels that were actually 
repainted by renderer->repaint_output. */
+                       int                             i, nrects;
+                       int                             x, y, width, height;
+                       pixman_box32_t  
*rect=pixman_region32_rectangles(damage, &nrects);
+                       for (i=0; i<nrects; ++i) {
+                               x = rect[i].x1;
+                               y = rect[i].y1;
+                               width = rect[i].x2 - x;
+                               height = rect[i].y2 - y;
+
+                               // It's y-flipped
+                               ec->renderer->read_pixels(output_base, 
output->format, output->tmpdata, x, output->height-rect[i].y2, width, height);
+                               pixman_blt(output->tmpdata, output->image, 
-width, output->stride, 32, 32, 0, 1-height, x, y, width, height);
+                       }
+               }
+
                wl_list_for_each(outputPeer, &output->peers, link) {
                        if ((outputPeer->flags & RDP_PEER_ACTIVATED) &&
                                        (outputPeer->flags & 
RDP_PEER_OUTPUT_ENABLED))
@@ -427,9 +470,229 @@ ensure_matching_mode(struct weston_output *output, struct 
weston_mode *target)
 }
 
 static int
+open_drm_device(struct udev *udev)
+{
+       struct udev_enumerate *e;
+       struct udev_list_entry *entry;
+       struct udev_device *device;
+       const char *path, *filename;
+       int fd;
+
+       e = udev_enumerate_new(udev);
+       udev_enumerate_add_match_subsystem(e, "drm");
+       udev_enumerate_add_match_sysname(e, "renderD[0-9]*");
+
+       udev_enumerate_scan_devices(e);
+       device = NULL;
+       udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) {
+               path = udev_list_entry_get_name(entry);
+               device = udev_device_new_from_syspath(udev, path);
+               if (device) {
+                       filename = udev_device_get_devnode(device);
+                       fd = open(filename, O_RDWR | O_CLOEXEC);
+                       if (fd < 0) {
+                               udev_device_unref(device);
+                               continue;
+                       }
+
+                       weston_log("using %s\n", filename);
+                       udev_device_unref(device);
+                       udev_enumerate_unref(e);
+                       return fd;
+               }
+       }
+
+       udev_enumerate_unref(e);
+       return -1;
+}
+
+static struct gbm_device *
+create_gbm_device(int fd)
+{
+       struct gbm_device *gbm;
+
+       gl_renderer = weston_load_module("gl-renderer.so",
+                                        "gl_renderer_interface");
+       if (!gl_renderer)
+               return NULL;
+
+       /* GBM will load a dri driver, but even though they need symbols from
+        * libglapi, in some version of Mesa they are not linked to it. Since
+        * only the gl-renderer module links to it, the call above won't make
+        * these symbols globally available, and loading the DRI driver fails.
+        * Workaround this by dlopen()'ing libglapi with RTLD_GLOBAL. */
+       dlopen("libglapi.so.0", RTLD_LAZY | RTLD_GLOBAL);
+
+       gbm = gbm_create_device(fd);
+
+       return gbm;
+}
+
+/* When initializing EGL, if the preferred buffer format isn't available
+ * we may be able to substitute an ARGB format for an XRGB one.
+ *
+ * This returns 0 if substitution isn't possible, but 0 might be a
+ * legitimate format for other EGL platforms, so the caller is
+ * responsible for checking for 0 before calling gl_renderer->create().
+ *
+ * This works around https://bugs.freedesktop.org/show_bug.cgi?id=89689
+ * but it's entirely possible we'll see this again on other implementations.
+ */
+static int
+fallback_format_for(uint32_t format)
+{
+       switch (format) {
+       case GBM_FORMAT_XRGB8888:
+               return GBM_FORMAT_ARGB8888;
+       case GBM_FORMAT_XRGB2101010:
+               return GBM_FORMAT_ARGB2101010;
+       default:
+               return 0;
+       }
+}
+
+static int
+rdp_backend_create_gl_renderer(struct rdp_backend *b)
+{
+       EGLint format[3] = {
+               b->gbm_format,
+               fallback_format_for(b->gbm_format),
+               0,
+       };
+       int n_formats = 2;
+
+       if (format[1])
+               n_formats = 3;
+       if (gl_renderer->display_create(b->compositor,
+                                       EGL_PLATFORM_GBM_KHR,
+                                       (void *)b->gbm,
+                                       NULL,
+                                       gl_renderer->opaque_attribs,
+                                       format,
+                                       n_formats) < 0) {
+               return -1;
+       }
+
+       return 0;
+}
+
+static int
+init_egl(struct rdp_backend *b)
+{
+       b->gbm = create_gbm_device(b->drm_fd);
+
+       if (!b->gbm)
+               return -1;
+
+       if (rdp_backend_create_gl_renderer(b) < 0) {
+               gbm_device_destroy(b->gbm);
+               return -1;
+       }
+
+       return 0;
+}
+
+static int
+init_pixman(struct rdp_backend *b)
+{
+       return pixman_renderer_init(b->compositor);
+}
+
+static int
+parse_gbm_format(const char *s, uint32_t default_value, uint32_t *gbm_format)
+{
+       int ret = 0;
+
+       if (s == NULL)
+               *gbm_format = default_value;
+       else if (strcmp(s, "xrgb8888") == 0)
+               *gbm_format = GBM_FORMAT_XRGB8888;
+       else if (strcmp(s, "argb8888") == 0)
+               *gbm_format = GBM_FORMAT_ARGB8888;
+       else if (strcmp(s, "rgb565") == 0)
+               *gbm_format = GBM_FORMAT_RGB565;
+       else if (strcmp(s, "xrgb2101010") == 0)
+               *gbm_format = GBM_FORMAT_XRGB2101010;
+       else {
+               weston_log("fatal: unrecognized pixel format: %s\n", s);
+               ret = -1;
+       }
+
+       return ret;
+}
+/* Init output state that depends on gl or gbm */
+static int
+rdp_output_init_egl(struct rdp_output *output, struct rdp_backend *b)
+{
+       EGLint format[2] = {
+               output->gbm_format,
+               fallback_format_for(output->gbm_format),
+       };
+       int n_formats = 1;
+
+       output->gbm_surface = gbm_surface_create(b->gbm,
+                                            output->base.current_mode->width,
+                                            output->base.current_mode->height,
+                                            format[0],
+                                            GBM_BO_USE_SCANOUT |
+                                            GBM_BO_USE_RENDERING);
+       if (!output->gbm_surface) {
+               weston_log("failed to create gbm surface\n");
+               return -1;
+       }
+
+       if (format[1])
+               n_formats = 2;
+       if (gl_renderer->output_window_create(&output->base,
+                                             
(EGLNativeWindowType)output->gbm_surface,
+                                             output->gbm_surface,
+                                             gl_renderer->opaque_attribs,
+                                             format,
+                                             n_formats) < 0) {
+               weston_log("failed to create gl renderer output state\n");
+               gbm_surface_destroy(output->gbm_surface);
+               return -1;
+       }
+
+       return 0;
+}
+
+static void
+rdp_output_fini_egl(struct rdp_output *output)
+{
+       gl_renderer->output_destroy(&output->base);
+       gbm_surface_destroy(output->gbm_surface);
+}
+
+static int
+rdp_get_image_size(struct rdp_output *output)
+{
+       uint32_t        
image_size=pixman_image_get_width(output->shadow_surface)*pixman_image_get_height(output->shadow_surface)*sizeof(uint32_t);
+    
+       if (output->tmpdata_size < image_size) {
+               free(output->tmpdata);
+               output->tmpdata = malloc(image_size);
+               if (output->tmpdata == NULL) {
+                       output->tmpdata_size = 0;
+                       errno = ENOMEM;
+                       return -1;
+               }
+               
+               output->tmpdata_size = image_size;
+               output->stride = 
pixman_image_get_stride(output->shadow_surface) / sizeof(uint32_t);
+               output->format = 
pixman_image_get_format(output->shadow_surface);
+               output->height = 
pixman_image_get_height(output->shadow_surface);
+               output->image = pixman_image_get_data(output->shadow_surface);
+       }
+       
+       return 0;
+}
+
+static int
 rdp_switch_mode(struct weston_output *output, struct weston_mode *target_mode)
 {
        struct rdp_output *rdpOutput = container_of(output, struct rdp_output, 
base);
+       struct rdp_backend *b = to_rdp_backend(output->compositor);
        struct rdp_peers_item *rdpPeer;
        rdpSettings *settings;
        pixman_image_t *new_shadow_buffer;
@@ -449,8 +712,21 @@ rdp_switch_mode(struct weston_output *output, struct 
weston_mode *target_mode)
        output->current_mode = local_mode;
        output->current_mode->flags |= WL_OUTPUT_MODE_CURRENT;
 
-       pixman_renderer_output_destroy(output);
-       pixman_renderer_output_create(output);
+       if (b->use_pixman) {
+               pixman_renderer_output_destroy(output);
+               if (pixman_renderer_output_create(output) < 0) {
+                       weston_log("failed to init output pixman state with "
+                                  "new mode\n");
+                       return -1;
+               }
+       } else {
+               rdp_output_fini_egl(rdpOutput);
+               if (rdp_output_init_egl(rdpOutput, b) < 0) {
+                       weston_log("failed to init output egl state with "
+                                  "new mode");
+                       return -1;
+               }
+       }
 
        new_shadow_buffer = pixman_image_create_bits(PIXMAN_x8r8g8b8, 
target_mode->width,
                        target_mode->height, 0, target_mode->width * 4);
@@ -459,6 +735,10 @@ rdp_switch_mode(struct weston_output *output, struct 
weston_mode *target_mode)
        pixman_image_unref(rdpOutput->shadow_surface);
        rdpOutput->shadow_surface = new_shadow_buffer;
 
+       if (!b->use_pixman) {
+               if (rdp_get_image_size(rdpOutput) < 0)  return -1;
+       }
+
        wl_list_for_each(rdpPeer, &rdpOutput->peers, link) {
                settings = rdpPeer->peer->settings;
                if (settings->DesktopWidth == (UINT32)target_mode->width &&
@@ -517,6 +797,17 @@ rdp_output_set_size(struct weston_output *base,
        return 0;
 }
 
+static void
+rdp_output_set_gbm_format(struct weston_output *base,
+                         const char *gbm_format)
+{
+       struct rdp_output *output = to_rdp_output(base);
+       struct rdp_backend *b = to_rdp_backend(base->compositor);
+
+       if (parse_gbm_format(gbm_format, b->gbm_format, &output->gbm_format) == 
-1)
+               output->gbm_format = b->gbm_format;
+}
+
 static int
 rdp_output_enable(struct weston_output *base)
 {
@@ -530,15 +821,25 @@ rdp_output_enable(struct weston_output *base)
                                                          NULL,
                                                          
output->base.current_mode->width * 4);
        if (output->shadow_surface == NULL) {
-               weston_log("Failed to create surface for frame buffer.\n");
+               weston_log("Failed to create SW surface for frame buffer.\n");
                return -1;
        }
 
-       if (pixman_renderer_output_create(&output->base) < 0) {
+       if (b->use_pixman) {
+               if (pixman_renderer_output_create(&output->base) < 0) {
+                       pixman_image_unref(output->shadow_surface);
+                       return -1;
+               }
+       } else if (rdp_output_init_egl(output, b) < 0) {
+               weston_log("Failed to init output gl state\n");
                pixman_image_unref(output->shadow_surface);
                return -1;
        }
 
+       if (!b->use_pixman) {
+               if (rdp_get_image_size(output) < 0)  return -1;
+       }
+
        loop = wl_display_get_event_loop(b->compositor->wl_display);
        output->finish_frame_timer = wl_event_loop_add_timer(loop, 
finish_frame_handler, output);
 
@@ -557,7 +858,11 @@ rdp_output_disable(struct weston_output *base)
                return 0;
 
        pixman_image_unref(output->shadow_surface);
-       pixman_renderer_output_destroy(&output->base);
+
+       if (b->use_pixman)
+               pixman_renderer_output_destroy(&output->base);
+       else
+               rdp_output_fini_egl(output);
 
        wl_event_source_remove(output->finish_frame_timer);
        b->output = NULL;
@@ -603,6 +908,13 @@ rdp_destroy(struct weston_compositor *ec)
        int i;
 
        weston_compositor_shutdown(ec);
+
+       if (!b->use_pixman) {
+               gbm_device_destroy(b->gbm);
+               close(b->drm_fd);
+               udev_unref(b->udev);
+       }
+
        for (i = 0; i < MAX_FREERDP_FDS; i++)
                if (b->listener_events[i])
                        wl_event_source_remove(b->listener_events[i]);
@@ -1281,6 +1593,7 @@ rdp_incoming_peer(freerdp_listener *instance, 
freerdp_peer *client)
 
 static const struct weston_rdp_output_api api = {
        rdp_output_set_size,
+       rdp_output_set_gbm_format
 };
 
 static struct rdp_backend *
@@ -1300,6 +1613,22 @@ rdp_backend_create(struct weston_compositor *compositor,
        b->base.destroy = rdp_destroy;
        b->rdp_key = config->rdp_key ? strdup(config->rdp_key) : NULL;
        b->no_clients_resize = config->no_clients_resize;
+       b->use_pixman = config->use_pixman;
+
+       if (parse_gbm_format(config->gbm_format, GBM_FORMAT_XRGB8888, 
&b->gbm_format) < 0)
+               goto err_compositor;
+
+       b->udev = udev_new();
+       if (b->udev == NULL) {
+               weston_log("failed to initialize udev context\n");
+               goto err_compositor;
+       }
+
+       b->drm_fd = open_drm_device(b->udev);
+       if (b->drm_fd < 0) {
+               weston_log("failed to find a suitable drm render node\n");
+               goto err_udev;
+       }
 
        compositor->backend = &b->base;
 
@@ -1314,13 +1643,22 @@ rdp_backend_create(struct weston_compositor *compositor,
        }
 
        if (weston_compositor_set_presentation_clock_software(compositor) < 0)
-               goto err_compositor;
+               goto err_udev;
 
-       if (pixman_renderer_init(compositor) < 0)
-               goto err_compositor;
+       if (b->use_pixman) {
+               if (init_pixman(b) < 0) {
+                       weston_log("failed to initialize pixman renderer\n");
+                       goto err_udev;
+               }
+       } else {
+               if (init_egl(b) < 0) {
+                       weston_log("failed to initialize egl\n");
+                       goto err_udev;
+               }
+       }
 
        if (rdp_backend_create_output(compositor) < 0)
-               goto err_compositor;
+               goto err_udev;
 
        compositor->capabilities |= WESTON_CAP_ARBITRARY_MODES;
 
@@ -1363,6 +1701,8 @@ err_listener:
        freerdp_listener_free(b->listener);
 err_output:
        weston_output_release(&b->output->base);
+err_udev:
+       udev_unref(b->udev);
 err_compositor:
        weston_compositor_shutdown(compositor);
 err_free_strings:
@@ -1383,6 +1723,7 @@ config_init_to_defaults(struct weston_rdp_backend_config 
*config)
        config->server_key = NULL;
        config->env_socket = 0;
        config->no_clients_resize = 0;
+       config->use_pixman = 0;
 }
 
 WL_EXPORT int
diff --git a/libweston/compositor-rdp.h b/libweston/compositor-rdp.h
index bd0a6a9..f3d77c8 100644
--- a/libweston/compositor-rdp.h
+++ b/libweston/compositor-rdp.h
@@ -42,6 +42,15 @@ struct weston_rdp_output_api {
         */
        int (*output_set_size)(struct weston_output *output,
                               int width, int height);
+
+       /** The pixel format to be used by the output. Valid values are:
+        * - NULL - The format set at backend creation time will be used;
+        * - "xrgb8888";
+        * - "rgb565"
+        * - "xrgb2101010"
+        */
+       void (*set_gbm_format)(struct weston_output *output,
+                              const char *gbm_format);
 };
 
 static inline const struct weston_rdp_output_api *
@@ -65,6 +74,21 @@ struct weston_rdp_backend_config {
        char *server_key;
        int env_socket;
        int no_clients_resize;
+
+       /** Whether to use the pixman renderer instead of the OpenGL ES 
renderer. */
+       bool use_pixman;
+
+       /** The pixel format of the framebuffer to be used.
+        *
+        * Valid values are:
+        * - NULL - The default format ("xrgb8888") will be used;
+        * - "xrgb8888";
+        * - "rgb565"
+        * - "xrgb2101010"
+        * The backend will take ownership of the format pointer and will free
+        * it on backend destruction.
+        */
+       char *gbm_format;
 };
 
 #ifdef  __cplusplus
--

  Raimun.




-----Mensaje original-----
De: wayland-devel [mailto:wayland-devel-boun...@lists.freedesktop.org] En 
nombre de Pekka Paalanen
Enviado el: martes, 03 de abril de 2018 15:39
Para: Raimundo Sagarzazu
CC: wayland-devel@lists.freedesktop.org
Asunto: Re: [PATCH 3/3] rdp-backend.so: OpenGL hardware acceleration

On Fri, 23 Feb 2018 16:08:00 +0100
Raimundo Sagarzazu <rsagarz...@ulmapackaging.com> wrote:

> Hi,
>  
> Two patches that improve performance in my case. 
>  
> First, supporting ARGB8888 gbm-format for the output allows a much better 
> performance of the intelReadPixels function of the i965 driver of Mesa, which 
> is my case:
>  
> diff -rup a/libweston/compositor-rdp.c b/libweston/compositor-rdp.c
> --- a/libweston/compositor-rdp.c           2018-02-22 11:35:14.000000000 +0100
> +++ b/libweston/compositor-rdp.c        2018-02-22 11:37:20.312159332 +0100
> @@ -592,6 +592,8 @@ parse_gbm_format(const char *s, uint32_t
>                               *gbm_format = default_value;
>                else if (strcmp(s, "xrgb8888") == 0)
>                               *gbm_format = GBM_FORMAT_XRGB8888;
> +             else if (strcmp(s, "argb8888") == 0)
> +                             *gbm_format = GBM_FORMAT_ARGB8888;
>                else if (strcmp(s, "rgb565") == 0)
>                               *gbm_format = GBM_FORMAT_RGB565;
>                else if (strcmp(s, "xrgb2101010") == 0)
>  
> Second, reading just the damaged pixels and y-flipping back the image:

Hi,

thanks for the patches, the ideas look good to me, but the patches themselves 
are not formatted such that they could be applied. Please see 
https://cgit.freedesktop.org/wayland/wayland/tree/doc/Contributing
for some guidance.

I would expect a re-send of these patches. The OpenGL support in RDP-backend 
has not been merged yet, so it would be good to point to the depended-on 
patches in your cover letter or even offer a branch from which people could 
test.


Thanks,
pq


_______________________________________________
wayland-devel mailing list
wayland-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/wayland-devel

Reply via email to