test/tbm-server-remote-test.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <unistd.h>
   4
   5 #include <wayland-server.h>
   6 #include <wayland-tbm-server.h>
   7 #include <tbm_surface.h>
   8
   9 #include "wayland-tbm-test-server-protocol.h"
  10
  11 #define SERVER_LOG(fmt, ...)   fprintf(stderr, "[SERVER(%d):%s] " fmt, getpid(), __func__, ##__VA_ARGS__)
  12
  13 typedef struct {
  14         struct wl_display *dpy;
  15         struct wayland_tbm_server *tbm_server;
  16         struct wl_global *wl_tbm_test;
  17
  18         struct wl_resource *provider;
  19 } Server;
  20
  21 typedef struct {
  22         struct wl_resource *wl_surface;
  23         struct wl_resource *wl_surface_bind;
  24         struct wl_resource *front;
  25
  26         struct wl_list remotes;
  27 } Surface;
  28
  29 typedef struct {
  30         struct wl_resource *wl_remote_surface;
  31         struct wl_resource *wl_tbm;
  32         struct wl_resource *front;
  33         Surface *provider;
  34
  35         struct wl_list link;
  36 } RemoteSurface;
  37
  38 Server gServer;
  39
  40 static void
  41 _wl_test_remote_destroy(struct wl_resource *resource)
  42 {
  43         RemoteSurface *remote = (RemoteSurface*)wl_resource_get_user_data(resource);
  44
  45         if (remote->provider) {
  46                 wl_list_remove(&remote->link);
  47                 SERVER_LOG("%p(%p)\n", resource, remote);
  48         }
  49
  50         free(remote);
  51 }
  52
  53 static void
  54 _wl_test_remote_destroy_cb(struct wl_client *client,
  55                         struct wl_resource *resource)
  56 {
  57         wl_resource_destroy(resource);
  58 }
  59
  60 static void
  61 _wl_test_remote_release_cb(struct wl_client *client,
  62                         struct wl_resource *resource,
  63                         struct wl_resource *buffer)
  64 {
  65 }
  66
  67 static void
  68 _wl_test_remote_redirect_cb(struct wl_client *client,
  69                          struct wl_resource *resource,
  70                          struct wl_resource *wl_tbm)
  71 {
  72         RemoteSurface *remote = wl_resource_get_user_data(resource);
  73         remote->wl_tbm = wl_tbm;
  74         SERVER_LOG("%p, wl_tbm: %p\n", resource, wl_tbm);
  75 }
  76
  77 static void
  78 _wl_test_remote_unredirect_cb(struct wl_client *client,
  79                            struct wl_resource *resource)
  80 {
  81         RemoteSurface *remote = wl_resource_get_user_data(resource);
  82         remote->wl_tbm = NULL;
  83         SERVER_LOG("%p\n", resource);
  84 }
  85
  86 static void
  87 _wl_test_remote_bind_cb(struct wl_client *client,
  88                      struct wl_resource *resource,
  89                      struct wl_resource *surface)
  90 {
  91         RemoteSurface *remote = wl_resource_get_user_data(resource);
  92         SERVER_LOG("%p(%p) to surface:%p\n", resource, remote, surface);
  93 }
  94
  95 static const struct wl_test_remote_interface wl_test_remote_impl = {
  96         _wl_test_remote_destroy_cb,
  97         _wl_test_remote_release_cb,
  98         _wl_test_remote_redirect_cb,
  99         _wl_test_remote_unredirect_cb,
 100         _wl_test_remote_bind_cb
 101 };
 102
 103 static void
 104 _wl_test_surface_destroy(struct wl_resource *resource)
 105 {
 106         Surface *surface = (Surface *)wl_resource_get_user_data(resource);
 107
 108         SERVER_LOG("%p provider:%p\n", resource, gServer.provider);
 109
 110         if (!wl_list_empty(&surface->remotes)) {
 111                 RemoteSurface *pos, *tmp;
 112
 113                 wl_list_for_each_safe(pos, tmp, &surface->remotes, link) {
 114                         pos->provider = NULL;
 115                         wl_list_remove(&pos->link);
 116                 }
 117         }
 118
 119         if (gServer.provider == resource)
 120                 gServer.provider = NULL;
 121
 122         free(surface);
 123 }
 124
 125
 126 static void
 127 _wl_test_surface_destroy_cb(struct wl_client *client,
 128                             struct wl_resource *resource)
 129 {
 130         wl_resource_destroy(resource);
 131 }
 132
 133 static void
 134 _wl_test_surface_attach_cb(struct wl_client *client,
 135                            struct wl_resource *resource,
 136                            struct wl_resource *wl_buffer)
 137 {
 138         Surface *surface = (Surface*)wl_resource_get_user_data(resource);
 139
 140         if (surface->front && (surface->front != wl_buffer))
 141                 wl_buffer_send_release(surface->front);
 142
 143         surface->front = wl_buffer;
 144         if (!wl_list_empty(&surface->remotes)) {
 145                 RemoteSurface *pos;
 146                 struct wl_resource *wl_remote_buffer = NULL;
 147
 148                 wl_list_for_each(pos, &surface->remotes, link) {
 149                         if (pos->wl_tbm) {
 150                                 wl_remote_buffer = wayland_tbm_server_get_remote_buffer(NULL, wl_buffer, pos->wl_tbm);
 151                                 if (!wl_remote_buffer) {
 152                                         tbm_surface_h tbm_surface;
 153
 154                                         tbm_surface = wayland_tbm_server_get_surface(NULL, wl_buffer);
 155                                         wl_remote_buffer = wayland_tbm_server_export_buffer(NULL, pos->wl_tbm, tbm_surface);
 156                                         SERVER_LOG("export: wl_tbm:%p, tbm_surf:%p, wl_buf:%p\n", pos->wl_tbm, tbm_surface, wl_remote_buffer);
 157                                 }
 158
 159                                 if (wl_remote_buffer) {
 160                                         wl_test_remote_send_update(pos->wl_remote_surface, wl_remote_buffer);
 161                                         pos->front = wl_remote_buffer;
 162                                 }
 163                         }
 164                 }
 165         }
 166 }
 167
 168 static void
 169 _wl_test_surface_frame_cb(struct wl_client *client,
 170                           struct wl_resource *resource,
 171                           uint32_t callback)
 172 {
 173 }
 174
 175 static const struct wl_test_surface_interface wl_test_surface_impl = {
 176         _wl_test_surface_destroy_cb,
 177         _wl_test_surface_attach_cb,
 178         _wl_test_surface_frame_cb
 179 };
 180
 181 static void
 182 _wl_tbm_test_create_surface(struct wl_client *client,
 183                                struct wl_resource *resource,
 184                                uint32_t id)
 185 {
 186         Surface *surface;
 187
 188         surface = calloc(1, sizeof(Surface));
 189         wl_list_init(&surface->remotes);
 190         surface->wl_surface = wl_resource_create(client,
 191                                                 &wl_test_surface_interface, 1, id);
 192         wl_resource_set_implementation(surface->wl_surface,
 193                                                 &wl_test_surface_impl, surface,
 194                                                 _wl_test_surface_destroy);
 195 }
 196
 197 static void
 198 _wl_tbm_test_set_active_queue(struct wl_client *client,
 199                                  struct wl_resource *resource,
 200                                  struct wl_resource *surface)
 201 {
 202 }
 203
 204 static void
 205 _wl_tbm_test_set_provider(struct wl_client *client,
 206                              struct wl_resource *resource,
 207                              struct wl_resource *surface,
 208                              const char *name)
 209 {
 210         Server *srv = (Server *)wl_resource_get_user_data(resource);
 211         srv->provider = surface;
 212
 213         SERVER_LOG("Provider:%p\n", resource);
 214 }
 215
 216 static void
 217 _wl_tbm_create_remote_surface(struct wl_client *client,
 218                                       struct wl_resource *resource,
 219                                       uint32_t id,
 220                                       const char *name)
 221 {
 222         Server *srv = (Server *)wl_resource_get_user_data(resource);
 223         Surface *provider;
 224         RemoteSurface *remote;
 225
 226         if (!srv->provider) return;
 227         provider = wl_resource_get_user_data(srv->provider);
 228
 229         remote = calloc(1, sizeof(RemoteSurface));
 230         remote->provider = provider;
 231         remote->wl_remote_surface = wl_resource_create(client,
 232                                                                         &wl_test_remote_interface,
 233                                                                         1,
 234                                                                         id);
 235         wl_resource_set_implementation(remote->wl_remote_surface,
 236                                 &wl_test_remote_impl,
 237                                 remote,
 238                                 _wl_test_remote_destroy);
 239         wl_list_init(&remote->link);
 240         wl_list_insert(&provider->remotes, &remote->link);
 241         SERVER_LOG("Add remote:%p(%p) to provider:%p(%p)\n",
 242                 resource, remote,
 243                 srv->provider, provider);
 244 }
 245
 246 static const struct wl_tbm_test_interface wl_tbm_test_impl = {
 247         _wl_tbm_test_create_surface,
 248         _wl_tbm_test_set_active_queue,
 249         _wl_tbm_test_set_provider,
 250         _wl_tbm_create_remote_surface
 251 };
 252
 253 static void
 254 wl_tbm_test_bind_cb(struct wl_client *client, void *data,
 255                     uint32_t version, uint32_t id)
 256 {
 257         struct wl_resource *resource;
 258
 259         resource = wl_resource_create(client, &wl_tbm_test_interface, version, id);
 260         wl_resource_set_implementation(resource, &wl_tbm_test_impl, data, NULL);
 261
 262         SERVER_LOG("client:%p, wl_tbm_test:%p\n", client, resource);
 263 }
 264
 265 int
 266 main(int argc, char *argv[])
 267 {
 268         struct wl_display *dpy;
 269         struct wayland_tbm_server *tbm_server;
 270
 271         const char *dpy_name = "tbm_remote";
 272
 273         dpy = wl_display_create();
 274         if (!dpy) {
 275                 printf("[SRV] failed to create display\n");
 276                 return -1;
 277         }
 278
 279         wl_display_add_socket(dpy, dpy_name);
 280         printf("[SRV] wl_display : %s\n", dpy_name);
 281
 282         tbm_server = wayland_tbm_server_init(dpy, NULL, -1, 0);
 283         if (!tbm_server) {
 284                 printf("[SRV] failed to tbm_server init\n");
 285                 wl_display_destroy(dpy);
 286                 return -1;
 287         }
 288
 289         gServer.dpy = dpy;
 290         gServer.tbm_server = tbm_server;
 291         gServer.wl_tbm_test = wl_global_create(dpy, &wl_tbm_test_interface, 1, &gServer,
 292                                             wl_tbm_test_bind_cb);
 293
 294         wl_display_run(dpy);
 295
 296         return 0;
 297 }