tdm: tdm-backend use pepper_tdm_renderer_t

The tdm-output change the rendereing interface to use
pepper_tdm_renderer_t.
The tdm-output can get the output-side rendering interface through
pepper_tdm_output_create_renderer function.
Otherwise, it alse uses one of the two built-in rendering interfaces
which are pixman renderer and gl renderer.

Change-Id: I88ab0f0377851999148b696a14827a97cb3e354b

diff --git a/samples/tdm-backend.c b/samples/tdm-backend.c
index 45010f6..796f4da 100644 (file)
--- a/samples/tdm-backend.c
+++ b/samples/tdm-backend.c
@@ -71,6 +71,8 @@ main(int argc, char **argv)
 {
        pepper_compositor_t    *compositor = NULL;
        pepper_tdm_t           *tdm = NULL;
+       pepper_tdm_output_t    *tdm_output = NULL;
+       pepper_tdm_renderer_t  *tdm_renderer[3]; // assume that maximum outputs is 3
        pepper_libinput_t      *input = NULL;
 
        struct udev            *udev = NULL;
@@ -79,6 +81,10 @@ main(int argc, char **argv)
        struct wl_event_loop   *loop = NULL;
        struct wl_event_source *sigint = NULL;
 
+       int i;
+       uint32_t     num_outputs = 0;
+       const char  *render_env = getenv("PEPPER_TDM_RENDERER");
+
        init_signals();
 
        compositor = pepper_compositor_create("wayland-0", NULL);
@@ -97,6 +103,22 @@ main(int argc, char **argv)
        if (!tdm)
                goto cleanup;
 
+       num_outputs = pepper_tdm_count_outputs(tdm);
+       if (!tdm)
+               goto cleanup;
+
+       for (i = 0; i < num_outputs; i++) {
+               tdm_output = pepper_tdm_get_output(tdm, i);
+               /*Setup renderer*/
+               if (render_env && !strcmp(render_env, "gl"))
+                       tdm_renderer[i] = pepper_tdm_output_create_gl_renderer(tdm_output);
+               else
+                       tdm_renderer[i] = pepper_tdm_output_create_pixman_renderer(tdm_output);
+
+               if (!tdm_renderer[i])
+                       goto cleanup;
+       }
+
        if (!pepper_desktop_shell_init(compositor))
                goto cleanup;
 
@@ -116,6 +138,11 @@ cleanup:
        if (sigint)
                wl_event_source_remove(sigint);
 
+       for (i = 0; i < num_outputs; i++) {
+               if (tdm_renderer[i])
+                       pepper_tdm_renderer_destroy(tdm_renderer[i]);
+       }
+
        if (tdm)
                pepper_tdm_destroy(tdm);
 

diff --git a/src/lib/tdm/tdm-internal.h b/src/lib/tdm/tdm-internal.h
index 28ec84a..0b553d4 100644 (file)
--- a/src/lib/tdm/tdm-internal.h
+++ b/src/lib/tdm/tdm-internal.h
@@ -54,6 +54,7 @@ typedef struct pepper_tdm_hwc_commit_data         pepper_tdm_hwc_commit_data_t;
 typedef struct pepper_tdm_hwc_window_commit_data  pepper_tdm_hwc_window_commit_data_t;
 
 typedef enum tdm_render_type {
+       TDM_RENDER_TYPE_CUSTOM,
        TDM_RENDER_TYPE_PIXMAN,
        TDM_RENDER_TYPE_GL,
 } tdm_render_type_t;
@@ -69,29 +70,24 @@ struct pepper_tdm {
 
        struct wayland_tbm_server  *wl_tbm_server;
        struct wl_event_source     *tdm_event_source;
-
-       pepper_renderer_t          *pixman_renderer;
-       pepper_renderer_t          *gl_renderer;
 };
 
 struct pepper_tdm_output {
        pepper_output_t        *base;
-       pepper_tdm_t           *tdm;
        tdm_output             *toutput;
-       pepper_tdm_hwc_t       *hwc;
-       pepper_tdm_plane_t     *primary_plane;
+
+       pepper_tdm_t           *tdm;
 
        tbm_surface_queue_h     tbm_surface_queue;
 
        tdm_render_type_t       render_type;
+       pepper_tdm_renderer_t  *renderer;
 
-       pepper_renderer_t      *renderer;
-       pepper_render_target_t *render_target;
+       pepper_tdm_hwc_t       *hwc;
+       pepper_tdm_plane_t     *primary_plane;
 
        tbm_surface_h           back, front;
        pepper_bool_t           page_flip_pending;
-       /*For pixman*/
-       pepper_region_t       previous_damage;
 
        pepper_list_t          link;
 };

diff --git a/src/lib/tdm/tdm-output.c b/src/lib/tdm/tdm-output.c
index 8011fa3..23f967f 100644 (file)
--- a/src/lib/tdm/tdm-output.c
+++ b/src/lib/tdm/tdm-output.c
@@ -28,66 +28,6 @@
 
 #include "tdm-internal.h"
 
-#include <pepper-pixman-renderer.h>
-#include <pepper-gl-renderer.h>
-
-static int key_render_target;
-
-#define KEY_RENDER_TARGET ((unsigned long)&key_render_target)
-
-static void
-__tdm_renderer_pixman_free_target(void *user_data)
-{
-       PEPPER_INFO("\n");
-
-       pepper_render_target_t *target = user_data;
-
-       if (target)
-               pepper_render_target_destroy(target);
-}
-
-static pepper_render_target_t *
-__tdm_renderer_pixman_get_target(tbm_surface_h surface)
-{
-       PEPPER_INFO("\n");
-
-       tbm_bo bo;
-       pepper_render_target_t *target = NULL;
-
-       bo = tbm_surface_internal_get_bo(surface, 0);
-       if (!tbm_bo_get_user_data(bo, KEY_RENDER_TARGET, (void **)&target)) {
-               tbm_surface_info_s info;
-               pepper_format_t format;
-
-               tbm_bo_add_user_data(bo, KEY_RENDER_TARGET, __tdm_renderer_pixman_free_target);
-
-               tbm_surface_get_info(surface, &info);
-               switch (info.format) {
-               case TBM_FORMAT_XRGB8888:
-                       format = PEPPER_FORMAT_XRGB8888;
-                       break;
-               case TBM_FORMAT_ARGB8888:
-                       format = PEPPER_FORMAT_ARGB8888;
-                       break;
-               default:
-                       tbm_bo_delete_user_data(bo, KEY_RENDER_TARGET);
-                       PEPPER_ERROR("Unknown tbm format\n");
-                       return NULL;
-               }
-               target = pepper_pixman_renderer_create_target(format, info.planes[0].ptr,
-                                info.planes[0].stride,
-                                info.width, info.height);
-               if (!target) {
-                       tbm_bo_delete_user_data(bo, KEY_RENDER_TARGET);
-                       PEPPER_ERROR("pepper_pixman_renderer_create_target() fail\n");
-                       return NULL;
-               }
-               tbm_bo_set_user_data(bo, KEY_RENDER_TARGET, target);
-       }
-
-       return target;
-}
-
 static const pepper_list_t *
 __tdm_output_get_render_list(pepper_tdm_output_t *output)
 {
@@ -124,224 +64,6 @@ __tdm_output_clear_damage_region(pepper_tdm_output_t *output)
 }
 
 static void
-__tdm_renderer_pixman_render(pepper_tdm_output_t *output)
-{
-       PEPPER_INFO("\n");
-
-       const pepper_list_t    *render_list;
-       pepper_region_t        *damage;
-       pepper_region_t         total_damage;
-       tbm_surface_h           back;
-       pepper_render_target_t *target;
-       int ret;
-
-       render_list = __tdm_output_get_render_list(output);
-       damage = __tdm_output_get_damage_region(output);
-
-       /*Set render target*/
-       ret = tbm_surface_queue_dequeue(output->tbm_surface_queue, &back);
-       PEPPER_CHECK(ret == TBM_SURFACE_QUEUE_ERROR_NONE, return,
-                                "tbm_surface_queue_dequeue() failed\n");
-
-       target = __tdm_renderer_pixman_get_target(back);
-       if (PEPPER_FALSE == pepper_renderer_set_target(output->renderer, target)) {
-               PEPPER_ERROR("pepper_renderer_set_target() failed\n");
-               return;
-       }
-
-       pepper_region_init(&total_damage);
-       pepper_region_union(&total_damage, damage, &output->previous_damage);
-       pepper_region_copy(&output->previous_damage, damage);
-
-       pepper_renderer_repaint_output(output->renderer, output->base, render_list,
-                                                                       &total_damage);
-
-       pepper_region_fini(&total_damage);
-
-       __tdm_output_clear_damage_region(output);
-
-#if 0 // for debugging
-       static int dump_cnt = 0;
-       char filename[256];
-       snprintf(filename, sizeof filename, "/tmp/pixman_render_%d.png", dump_cnt++);
-       tdm_helper_dump_buffer(back, (const char*)filename);
-#endif
-
-       output->back = back;
-}
-
-static void
-__tdm_renderer_pixman_fini(pepper_tdm_output_t *output)
-{
-       PEPPER_INFO("\n");
-
-       pepper_region_fini(&output->previous_damage);
-
-       if (output->render_target)
-               pepper_render_target_destroy(output->render_target);
-
-       if (output->tbm_surface_queue) {
-               // DO NOT destroy tbm_surface_queue_h
-               if (output->hwc)
-                       output->tbm_surface_queue = NULL;
-               else
-                       tbm_surface_queue_destroy(output->tbm_surface_queue);
-       }
-
-       output->renderer = NULL;
-       output->render_target = NULL;
-       output->tbm_surface_queue = NULL;
-}
-
-static void
-__tdm_renderer_pixman_init(pepper_tdm_output_t *output)
-{
-       pepper_tdm_t     *tdm = output->tdm;
-       pepper_tdm_hwc_t *hwc = output->hwc;
-
-       const tdm_output_mode *mode;
-       tdm_error err = TDM_ERROR_NONE;
-
-       PEPPER_INFO("\n");
-
-       if (!tdm->pixman_renderer) {
-                 tdm->pixman_renderer = pepper_pixman_renderer_create(tdm->compositor);
-                 PEPPER_CHECK(tdm->pixman_renderer, return,
-                                                       "pepper_pixman_renderer_create() failed.\n");
-       }
-
-       output->renderer = tdm->pixman_renderer;
-
-       err = tdm_output_get_mode(output->toutput, &mode);
-       PEPPER_CHECK(err == TDM_ERROR_NONE, goto error,
-                                        "tdm_output_get_mode() failed.\n");
-
-       if (output->hwc) {
-               output->tbm_surface_queue = tdm_hwc_get_client_target_buffer_queue(hwc->thwc, &err);
-               PEPPER_CHECK(output->tbm_surface_queue, goto error,
-                                       "tdm_hwc_get_client_target_buffer_queue() failed.\n");
-       } else {
-               output->tbm_surface_queue = tbm_surface_queue_create(3,
-                                                                                                               mode->hdisplay, mode->vdisplay,
-                                                                                                               TBM_FORMAT_XBGR8888, TBM_BO_SCANOUT);
-               PEPPER_CHECK(output->tbm_surface_queue, goto error,
-                                               "tbm_surface_queue_create() failed.\n");
-       }
-
-       pepper_region_init(&output->previous_damage);
-       output->render_type = TDM_RENDER_TYPE_PIXMAN;
-
-       return;
-
-error:
-       __tdm_renderer_pixman_fini(output);
-}
-
-static void
-__tdm_renderer_gl_render(pepper_tdm_output_t *output)
-{
-       PEPPER_INFO("\n");
-
-       int ret;
-       const pepper_list_t *render_list;
-       pepper_region_t *damage;
-
-       render_list = __tdm_output_get_render_list(output);
-       damage = __tdm_output_get_damage_region(output);
-
-       pepper_renderer_repaint_output(output->renderer, output->base, render_list,
-                                                                       damage);
-
-       ret = tbm_surface_queue_can_acquire(output->tbm_surface_queue, 1);
-       PEPPER_CHECK(ret > 0, return, "tbm_surface_queue_can_acquire() failed.\n");
-
-       ret = tbm_surface_queue_acquire(output->tbm_surface_queue, &output->back);
-       PEPPER_CHECK(ret == TBM_SURFACE_QUEUE_ERROR_NONE, return,
-                                "tbm_surface_queue_acquire() failed.\n");
-
-       __tdm_output_clear_damage_region(output);
-}
-
-static void
-__tdm_renderer_gl_fini(pepper_tdm_output_t *output)
-{
-       PEPPER_INFO("\n");
-
-       if (output->render_target)
-               pepper_render_target_destroy(output->render_target);
-
-       if (output->tbm_surface_queue) {
-               // DO NOT destroy tbm_surface_queue_h
-               if (output->hwc)
-                       output->tbm_surface_queue = NULL;
-               else
-                       tbm_surface_queue_destroy(output->tbm_surface_queue);
-       }
-
-       output->renderer = NULL;
-       output->render_target = NULL;
-       output->tbm_surface_queue = NULL;
-}
-
-static void
-__tdm_renderer_gl_init(pepper_tdm_output_t *output)
-{
-       PEPPER_INFO("\n");
-
-       pepper_tdm_t          *tdm = output->tdm;
-       pepper_tdm_hwc_t      *hwc = output->hwc;
-       const tdm_output_mode *mode;
-       uint32_t                       native_visual_id = TBM_FORMAT_XRGB8888;
-       tdm_error              err = TDM_ERROR_NONE;
-
-       if (!tdm->gl_renderer) {
-                 tdm->gl_renderer = pepper_gl_renderer_create(tdm->compositor, tdm->bufmgr,
-                                                                                                                                         "tbm");
-                 PEPPER_CHECK(tdm->gl_renderer, return, "pepper_gl_renderer_create() failed.\n");
-       }
-
-       output->renderer = tdm->gl_renderer;
-
-       err = tdm_output_get_mode(output->toutput, &mode);
-       PEPPER_CHECK(err == TDM_ERROR_NONE, goto error,
-                                        "tdm_output_get_mode() failed.\n");
-
-       if (output->hwc) {
-               output->tbm_surface_queue = tdm_hwc_get_client_target_buffer_queue(hwc->thwc, &err);
-               PEPPER_CHECK(err == TDM_ERROR_NONE, goto error,
-                                       "tdm_hwc_get_client_target_buffer_queue() failed.\n");
-               output->render_target = pepper_gl_renderer_create_target(tdm->gl_renderer,
-                                                                                                                               output->tbm_surface_queue,
-                                                                                                                               PEPPER_FORMAT_XRGB8888,
-                                                                                                                               &native_visual_id,
-                                                                                                                               mode->hdisplay, mode->vdisplay);
-       } else {
-               output->tbm_surface_queue = tbm_surface_queue_create(3,
-                                                                                                                       mode->hdisplay, mode->vdisplay,
-                                                                                                                       TBM_FORMAT_XRGB8888,
-                                                                                                                       TBM_BO_SCANOUT);
-               PEPPER_CHECK(output->tbm_surface_queue, goto error,
-                                               "tbm_surface_queue_create() failed.\n");
-
-               output->render_target = pepper_gl_renderer_create_target(tdm->gl_renderer,
-                                                                                                                               output->tbm_surface_queue,
-                                                                                                                               PEPPER_FORMAT_XRGB8888,
-                                                                                                                               &native_visual_id,
-                                                                                                                               mode->hdisplay, mode->vdisplay);
-       }
-       PEPPER_CHECK(output->render_target, goto error,
-                                        "pepper_gl_renderer_create_target() failed.\n");
-       output->render_type = TDM_RENDER_TYPE_GL;
-
-       pepper_renderer_set_target(output->renderer, output->render_target);
-
-       return;
-
-error:
-       __tdm_renderer_gl_fini(output);
-}
-
-static void
 __tdm_hwc_destroy(pepper_event_listener_t *listener, pepper_object_t *object,
                                        uint32_t id, void *info, void *data)
 {
@@ -690,23 +412,40 @@ pepper_tdm_output_repaint(void *o, const pepper_list_t *plane_list)
 
        pepper_tdm_output_t *output = (pepper_tdm_output_t *)o;
        tdm_error terror;
+       const pepper_list_t *render_list;
+       pepper_region_t     *damage;
+       tbm_error_e          tbm_err;
+       int ret;
 
        // render
+       render_list = __tdm_output_get_render_list(output);
+       damage = __tdm_output_get_damage_region(output);
        if (!output->back) {
-               if (output->render_type == TDM_RENDER_TYPE_GL)
-                       __tdm_renderer_gl_render(output);
-               else if (output->render_type == TDM_RENDER_TYPE_PIXMAN)
-                       __tdm_renderer_pixman_render(output);
-               else {
-                       PEPPER_ERROR("Unknown render type\n");
-                       return;
-               }
+               ret = pepper_tdm_renderer_render_once(output->renderer, render_list, damage);
+               PEPPER_CHECK(ret, return, "pepper_tdm_renderer_render_once() failed");
        }
+       __tdm_output_clear_damage_region(output);
+
+       // acquire
+       if (!tbm_surface_queue_can_acquire(output->tbm_surface_queue, 1))
+               return;
+
+       tbm_err = tbm_surface_queue_acquire(output->tbm_surface_queue, &output->back);
+       PEPPER_CHECK(tbm_err == TBM_ERROR_NONE, return, "tbm_surface_queue_acquire() failed");
 
        // TODO: fix this...
        if (!output->back)
                return;
 
+#if DEBUG_DUMP_BACK_BUFFER
+       static int dump_cnt = 0;
+       char filename[256];
+       snprintf(filename, sizeof filename, "/tmp/gl_render_%d.png", dump_cnt++);
+
+       tdm_helper_dump_buffer(output->back, (const char*)filename);
+#endif
+
+       // commit
        if (output->hwc) {
                // set back buffer as a client_target_buffer
                pepper_tdm_hwc_set_client_target_buffer(output->hwc, output->back);
@@ -738,7 +477,7 @@ pepper_tdm_output_attach_surface(void *o, pepper_surface_t *surface, int *w,
        if (output->hwc)
                pepper_tdm_hwc_attach_surface(output->hwc, surface);
 
-       pepper_renderer_attach_surface(output->renderer, surface, w, h);
+       pepper_tdm_renderer_attach_surface(output->renderer, surface, w, h);
 }
 
 static void
@@ -750,7 +489,7 @@ pepper_tdm_output_flush_surface_damage(void *o, pepper_surface_t *surface,
        pepper_tdm_output_t      *output = o;
        pepper_buffer_t *buffer = pepper_surface_get_buffer(surface);
 
-       pepper_renderer_flush_surface_damage(output->renderer, surface);
+       pepper_tdm_renderer_flush_surface_damage(output->renderer, surface);
 
        if (output->render_type == TDM_RENDER_TYPE_GL &&
                (buffer && wl_shm_buffer_get(pepper_buffer_get_resource(buffer)))) {
@@ -762,7 +501,7 @@ pepper_tdm_output_flush_surface_damage(void *o, pepper_surface_t *surface,
        // HWC :
 }
 
-struct pepper_output_backend tdm_output_backend = {
+static const pepper_output_backend_t tdm_output_backend = {
        pepper_tdm_output_destroy,
 
        pepper_tdm_output_get_subpixel_order,
@@ -796,8 +535,6 @@ pepper_tdm_output_init(pepper_tdm_t *tdm)
        const tdm_output_mode *preferred_mode = NULL;
        int num_mode;
 
-       const char        *render_env = getenv("PEPPER_RENDERER");
-
        PEPPER_INFO("\n");
 
        err = tdm_display_get_output_count(tdm->tdisplay, &num_output);
@@ -864,19 +601,6 @@ pepper_tdm_output_init(pepper_tdm_t *tdm)
                        PEPPER_CHECK(PEPPER_TRUE == __tdm_output_plane_init(output), goto error,
                                                 "pepper_tdm_plane_init() failed\n");
 
-               /*Setup renderer*/
-               if (render_env && !strcmp(render_env, "gl")) {
-                       __tdm_renderer_gl_init(output);
-                       PEPPER_CHECK(output->renderer, goto error,
-                                                "Failed to initialize gl_renderer.\n");
-               }
-
-               if (!output->renderer) {
-                       __tdm_renderer_pixman_init(output);
-                       PEPPER_CHECK(output->renderer, goto error,
-                                                "Failed to initialize pixman_renderer.\n");
-               }
-
                // add output to output_list
                pepper_list_insert(&tdm->output_list, &output->link);
                tdm->num_outputs++;