client/tdm_client.c

   1 /**************************************************************************
   2  *
   3  * libtdm
   4  *
   5  * Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
   6  *
   7  * Contact: Eunchul Kim <chulspro.kim@samsung.com>,
   8  *          JinYoung Jeon <jy0.jeon@samsung.com>,
   9  *          Taeheon Kim <th908.kim@samsung.com>,
  10  *          YoungJun Cho <yj44.cho@samsung.com>,
  11  *          SooChan Lim <sc1.lim@samsung.com>,
  12  *          Boram Park <sc1.lim@samsung.com>
  13  *
  14  * Permission is hereby granted, free of charge, to any person obtaining a
  15  * copy of this software and associated documentation files (the
  16  * "Software"), to deal in the Software without restriction, including
  17  * without limitation the rights to use, copy, modify, merge, publish,
  18  * distribute, sub license, and/or sell copies of the Software, and to
  19  * permit persons to whom the Software is furnished to do so, subject to
  20  * the following conditions:
  21  *
  22  * The above copyright notice and this permission notice (including the
  23  * next paragraph) shall be included in all copies or substantial portions
  24  * of the Software.
  25  *
  26  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  27  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  29  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  30  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  31  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  32  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  33  *
  34 **************************************************************************/
  35
  36 #ifdef HAVE_CONFIG_H
  37 #include "config.h"
  38 #endif
  39
  40 #include <stdio.h>
  41 #include <string.h>
  42 #include <stdlib.h>
  43 #include <time.h>
  44 #include <strings.h>
  45
  46 #include <tdm-client-protocol.h>
  47
  48 #include "tdm_client.h"
  49 #include "tdm_log.h"
  50 #include "tdm_macro.h"
  51 #include "tdm_list.h"
  52 #include "tdm.h"
  53 #include "tdm_private.h"
  54
  55 typedef struct _tdm_private_client_vblank tdm_private_client_vblank;
  56
  57 typedef struct _tdm_private_client {
  58         struct wl_display *display;
  59         struct wl_event_queue *queue;
  60         struct wl_registry *registry;
  61         struct wl_tdm *tdm;
  62         struct list_head output_list;
  63
  64         unsigned int enable_ttrace;
  65         unsigned int stamp;
  66
  67         tdm_private_client_vblank *temp_vblank;
  68 } tdm_private_client;
  69
  70 typedef struct _tdm_private_client_output {
  71         tdm_private_client *private_client;
  72
  73         char name[TDM_NAME_LEN];
  74         struct wl_tdm_output *output;
  75         int width;
  76         int height;
  77         int refresh;
  78         tdm_output_conn_status connection;
  79         tdm_output_dpms dpms;
  80         struct list_head vblank_list;
  81         struct list_head change_handler_list;
  82
  83         unsigned int req_id;
  84         unsigned int watch_output_changes;
  85
  86         struct list_head link;
  87 } tdm_private_client_output;
  88
  89 struct _tdm_private_client_vblank {
  90         tdm_private_client_output *private_output;
  91
  92         struct wl_tdm_vblank *vblank;
  93         struct list_head wait_list;
  94
  95         char name[TDM_NAME_LEN];
  96         unsigned int sync;
  97         unsigned int fps;
  98         int offset;
  99         unsigned int enable_fake;
 100         unsigned int enable_ttrace;
 101
 102         unsigned int started;
 103         unsigned int stamp;
 104
 105         double req_time;
 106         double last_time;
 107
 108         struct list_head link;
 109 };
 110
 111 typedef struct _tdm_client_output_handler_info {
 112         tdm_private_client_output *private_output;
 113
 114         tdm_client_output_change_handler func;
 115         void *user_data;
 116
 117         struct list_head link;
 118 } tdm_client_output_handler_info;
 119
 120 typedef struct _tdm_client_wait_info {
 121         tdm_private_client_vblank *private_vblank;
 122
 123         tdm_client_vblank_handler func;
 124         void *user_data;
 125
 126         unsigned int req_id;
 127         double req_time;
 128         int need_free;
 129
 130         struct list_head link;
 131 } tdm_client_wait_info;
 132
 133 static void
 134 _tdm_client_vblank_cb_stamp(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t stamp)
 135 {
 136         tdm_private_client_vblank *private_vblank = data;
 137         tdm_private_client *private_client;
 138
 139         TDM_RETURN_IF_FAIL(private_vblank != NULL);
 140
 141         private_vblank->stamp = stamp;
 142
 143         TDM_RETURN_IF_FAIL(private_vblank->private_output != NULL);
 144         private_client = private_vblank->private_output->private_client;
 145
 146         private_client->stamp = stamp;
 147 }
 148
 149 /* LCOV_EXCL_START */
 150 static void
 151 _tdm_client_vblank_cb_done(void *data, struct wl_tdm_vblank *wl_tdm_vblank,
 152                                                    uint32_t req_id, uint32_t sequence, uint32_t tv_sec,
 153                                                    uint32_t tv_usec, uint32_t error)
 154 {
 155         tdm_private_client_vblank *private_vblank = data;
 156         tdm_client_wait_info *w = NULL, *ww = NULL;
 157
 158         TDM_RETURN_IF_FAIL(private_vblank != NULL);
 159
 160         private_vblank->last_time = TDM_TIME(tv_sec, tv_usec);
 161
 162         TDM_DBG("vblank(%p) req_id(%u) sequence(%u) time(%.6f)",
 163                         private_vblank, req_id, sequence, TDM_TIME(tv_sec, tv_usec));
 164
 165         LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->wait_list, link) {
 166                 if (w->req_id != req_id)
 167                         continue;
 168
 169                 if (private_vblank->enable_ttrace)
 170                         TDM_TRACE_ASYNC_END((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
 171
 172                 if (w->req_time >= private_vblank->last_time)
 173                         TDM_WRN("'req(%.6f) < last(%.6f)' failed", w->req_time, private_vblank->last_time);
 174
 175                 if (w->func)
 176                         w->func(private_vblank, error, sequence, tv_sec, tv_usec, w->user_data);
 177
 178                 if (w->need_free) {
 179                         LIST_DEL(&w->link);
 180                         free(w);
 181                 } else
 182                         w->need_free = 1;
 183                 return;
 184         }
 185 }
 186 /* LCOV_EXCL_STOP */
 187
 188 /* LCOV_EXCL_START */
 189 static void
 190 _tdm_client_vblank_cb_ttrace(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t enable)
 191 {
 192         tdm_private_client_vblank *private_vblank = data;
 193         tdm_private_client *private_client;
 194
 195         TDM_RETURN_IF_FAIL(private_vblank != NULL);
 196
 197         private_vblank->enable_ttrace = enable;
 198
 199         TDM_RETURN_IF_FAIL(private_vblank->private_output != NULL);
 200         private_client = private_vblank->private_output->private_client;
 201
 202         private_client->enable_ttrace = enable;
 203 }
 204 /* LCOV_EXCL_STOP */
 205
 206 static const struct wl_tdm_vblank_listener tdm_client_vblank_listener = {
 207         _tdm_client_vblank_cb_stamp,
 208         _tdm_client_vblank_cb_done,
 209         _tdm_client_vblank_cb_ttrace,
 210 };
 211
 212 static void
 213 _tdm_client_output_destroy(tdm_private_client_output *private_output)
 214 {
 215         tdm_private_client_vblank *v = NULL, *vv = NULL;
 216         tdm_client_output_handler_info *h = NULL, *hh = NULL;
 217
 218         LIST_DEL(&private_output->link);
 219
 220         LIST_FOR_EACH_ENTRY_SAFE(v, vv, &private_output->vblank_list, link) {
 221                 TDM_ERR("vblanks SHOULD be destroyed first!");
 222                 LIST_DEL(&v->link);
 223                 v->private_output = NULL;
 224         }
 225
 226         LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list, link) {
 227                 LIST_DEL(&h->link);
 228                 free(h);
 229         }
 230
 231         wl_tdm_output_destroy(private_output->output);
 232
 233         free(private_output);
 234 }
 235
 236 static void
 237 _tdm_client_output_cb_mode(void *data, struct wl_tdm_output *wl_tdm_output,
 238                                                    uint32_t width, uint32_t height, uint32_t refresh, uint32_t error)
 239 {
 240         tdm_private_client_output *private_output = (tdm_private_client_output*)data;
 241
 242         TDM_RETURN_IF_FAIL(private_output != NULL);
 243
 244         private_output->width = width;
 245         private_output->height = height;
 246         private_output->refresh = refresh;
 247
 248         if (error != TDM_ERROR_NONE)
 249                 TDM_INFO("mode event error: %d", error);
 250
 251         TDM_DBG("private_output(%p) wl_tbm_output@%d width(%d) height(%d) refresh(%d)",
 252                         private_output, wl_proxy_get_id((struct wl_proxy*)private_output->output),
 253                         width, height, refresh);
 254 }
 255
 256 static void
 257 _tdm_client_output_cb_connection(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value, uint32_t error)
 258 {
 259         tdm_private_client_output *private_output = (tdm_private_client_output*)data;
 260         tdm_client_output_handler_info *h = NULL;
 261         tdm_value v;
 262
 263         TDM_RETURN_IF_FAIL(private_output != NULL);
 264
 265         if (private_output->connection == value)
 266                 return;
 267
 268         private_output->connection = value;
 269
 270         if (error != TDM_ERROR_NONE)
 271                 TDM_INFO("connection event error: %d", error);
 272
 273         TDM_DBG("private_output(%p) wl_tbm_output@%d connection(%d)",
 274                         private_output,
 275                         wl_proxy_get_id((struct wl_proxy*)private_output->output),
 276                         value);
 277
 278         v.u32 = value;
 279         LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
 280                 if (h->func)
 281                         h->func(private_output, TDM_OUTPUT_CHANGE_CONNECTION, v, h->user_data);
 282         }
 283 }
 284
 285 static void
 286 _tdm_client_output_cb_dpms(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value, uint32_t error)
 287 {
 288         tdm_private_client_output *private_output = (tdm_private_client_output*)data;
 289         tdm_client_output_handler_info *h = NULL;
 290         tdm_value v;
 291
 292         TDM_RETURN_IF_FAIL(private_output != NULL);
 293
 294         /* If value is extended value, we handle it as DPMS on in client side
 295          * The extended DPMS value is valid only in server side.
 296          * Or, need to export to client side also?
 297          */
 298         if (value > TDM_OUTPUT_DPMS_OFF)
 299                 value = TDM_OUTPUT_DPMS_ON;
 300
 301         if (private_output->dpms == value)
 302                 return;
 303
 304         private_output->dpms = value;
 305
 306         if (error != TDM_ERROR_NONE)
 307                 TDM_INFO("dpms event error: %d", error);
 308
 309         TDM_DBG("private_output(%p) wl_tbm_output@%d dpms(%d)",
 310                         private_output,
 311                         wl_proxy_get_id((struct wl_proxy*)private_output->output),
 312                         value);
 313
 314         v.u32 = value;
 315         LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
 316                 if (h->func)
 317                         h->func(private_output, TDM_OUTPUT_CHANGE_DPMS, v, h->user_data);
 318         }
 319 }
 320
 321 static const struct wl_tdm_output_listener tdm_client_output_listener = {
 322         _tdm_client_output_cb_mode,
 323         _tdm_client_output_cb_connection,
 324         _tdm_client_output_cb_dpms,
 325 };
 326
 327 static void
 328 _tdm_client_cb_global(void *data, struct wl_registry *registry,
 329                                           uint32_t name, const char *interface,
 330                                           uint32_t version)
 331 {
 332         tdm_private_client *private_client = data;
 333
 334         if (strncmp(interface, "wl_tdm", 6) == 0) {
 335                 private_client->tdm =
 336                         wl_registry_bind(registry, name, &wl_tdm_interface, version);
 337                 TDM_RETURN_IF_FAIL(private_client->tdm != NULL);
 338
 339                 wl_display_flush(private_client->display);
 340         }
 341 }
 342
 343 /* LCOV_EXCL_START */
 344 static void
 345 _tdm_client_cb_global_remove(void *data, struct wl_registry *registry, uint32_t name)
 346 {
 347 }
 348 /* LCOV_EXCL_STOP */
 349
 350 static const struct wl_registry_listener tdm_client_registry_listener = {
 351         _tdm_client_cb_global,
 352         _tdm_client_cb_global_remove
 353 };
 354
 355 tdm_client*
 356 tdm_client_create(tdm_error *error)
 357 {
 358         tdm_private_client *private_client;
 359
 360         private_client = calloc(1, sizeof *private_client);
 361         if (!private_client) {
 362                 /* LCOV_EXCL_START */
 363
 364                 TDM_ERR("alloc failed");
 365                 if (error)
 366                         *error = TDM_ERROR_OUT_OF_MEMORY;
 367                 return NULL;
 368
 369                 /* LCOV_EXCL_STOP */
 370         }
 371
 372         LIST_INITHEAD(&private_client->output_list);
 373
 374         private_client->display = wl_display_connect("tdm-socket");
 375         TDM_GOTO_IF_FAIL(private_client->display != NULL, create_failed);
 376
 377         private_client->queue = wl_display_create_queue(private_client->display);
 378         TDM_GOTO_IF_FAIL(private_client->queue != NULL, create_failed);
 379
 380         private_client->registry = wl_display_get_registry(private_client->display);
 381         TDM_GOTO_IF_FAIL(private_client->registry != NULL, create_failed);
 382
 383         wl_registry_add_listener(private_client->registry,
 384                                                          &tdm_client_registry_listener, private_client);
 385         wl_display_roundtrip(private_client->display);
 386
 387         /* check global objects */
 388         TDM_GOTO_IF_FAIL(private_client->tdm != NULL, create_failed);
 389
 390         if (error)
 391                 *error = TDM_ERROR_NONE;
 392
 393         return (tdm_client*)private_client;
 394 create_failed:
 395         tdm_client_destroy((tdm_client*)private_client);
 396         if (error)
 397                 *error = TDM_ERROR_OPERATION_FAILED;
 398         return NULL;
 399 }
 400
 401 void
 402 tdm_client_destroy(tdm_client *client)
 403 {
 404         tdm_private_client *private_client = (tdm_private_client*)client;
 405         tdm_private_client_output *o = NULL, *oo = NULL;
 406
 407         if (!private_client)
 408                 return;
 409
 410         if (private_client->temp_vblank)
 411                 tdm_client_vblank_destroy(private_client->temp_vblank);
 412
 413         LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_client->output_list, link) {
 414                 _tdm_client_output_destroy(o);
 415         }
 416
 417         if (private_client->tdm)
 418                 wl_tdm_destroy(private_client->tdm);
 419         if (private_client->registry)
 420                 wl_registry_destroy(private_client->registry);
 421         if (private_client->queue)
 422                 wl_event_queue_destroy(private_client->queue);
 423         if (private_client->display)
 424                 wl_display_disconnect(private_client->display);
 425
 426         free(private_client);
 427 }
 428
 429 tdm_error
 430 tdm_client_get_fd(tdm_client *client, int *fd)
 431 {
 432         tdm_private_client *private_client;
 433
 434         TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
 435         TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
 436
 437         private_client = (tdm_private_client*)client;
 438
 439         *fd = wl_display_get_fd(private_client->display);
 440         if (*fd < 0)
 441                 return TDM_ERROR_OPERATION_FAILED;
 442
 443         return TDM_ERROR_NONE;
 444 }
 445
 446 tdm_error
 447 tdm_client_handle_events(tdm_client *client)
 448 {
 449         tdm_private_client *private_client;
 450
 451         TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
 452
 453         /* LCOV_EXCL_START */
 454         private_client = (tdm_private_client*)client;
 455
 456         if (private_client->enable_ttrace)
 457                 TDM_TRACE_ASYNC_BEGIN((int)private_client->stamp, "TDM_Client_Events:%u", (unsigned int)private_client->stamp);
 458
 459         wl_display_dispatch(private_client->display);
 460
 461         if (private_client->enable_ttrace)
 462                 TDM_TRACE_ASYNC_END((int)private_client->stamp, "TDM_Client_Events:%u", (unsigned int)private_client->stamp);
 463
 464         return TDM_ERROR_NONE;
 465         /* LCOV_EXCL_STOP */
 466 }
 467
 468 typedef struct _tdm_client_vblank_temp {
 469         tdm_client_vblank_handler2 func;
 470         void *user_data;
 471 } tdm_client_vblank_temp;
 472
 473 /* LCOV_EXCL_START */
 474 static void
 475 _tdm_client_vblank_handler_temp(tdm_client_vblank *vblank, tdm_error error, unsigned int sequence,
 476                                                                 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 477 {
 478         tdm_client_vblank_temp *vblank_temp = user_data;
 479
 480         TDM_RETURN_IF_FAIL(vblank_temp != NULL);
 481
 482         if (vblank_temp->func)
 483                 vblank_temp->func(sequence, tv_sec, tv_usec, vblank_temp->user_data);
 484
 485         free(vblank_temp);
 486 }
 487 /* LCOV_EXCL_STOP */
 488
 489 /* LCOV_EXCL_START */ /* deprecated */
 490 tdm_error
 491 tdm_client_wait_vblank(tdm_client *client, char *name,
 492                                            int sw_timer, int interval, int sync,
 493                                            tdm_client_vblank_handler2 func, void *user_data)
 494 {
 495         tdm_private_client *private_client = (tdm_private_client*)client;
 496         tdm_client_output *output;
 497         tdm_client_vblank_temp *vblank_temp;
 498         tdm_error ret;
 499
 500         TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
 501         TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
 502         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 503
 504         if (!private_client->temp_vblank) {
 505                 output = tdm_client_get_output(client, name, &ret);
 506                 TDM_RETURN_VAL_IF_FAIL(output != NULL, ret);
 507
 508                 private_client->temp_vblank = tdm_client_output_create_vblank(output, &ret);
 509                 TDM_RETURN_VAL_IF_FAIL(private_client->temp_vblank != NULL, ret);
 510         }
 511
 512         tdm_client_vblank_set_enable_fake(private_client->temp_vblank, sw_timer);
 513         tdm_client_vblank_set_sync(private_client->temp_vblank, sync);
 514
 515         vblank_temp = calloc(1, sizeof *vblank_temp);
 516         TDM_RETURN_VAL_IF_FAIL(vblank_temp != NULL, TDM_ERROR_OUT_OF_MEMORY);
 517
 518         vblank_temp->func = func;
 519         vblank_temp->user_data = user_data;
 520
 521         return tdm_client_vblank_wait(private_client->temp_vblank, interval, _tdm_client_vblank_handler_temp, vblank_temp);
 522 }
 523 /* LCOV_EXCL_STOP */
 524
 525 tdm_client_output*
 526 tdm_client_get_output(tdm_client *client, char *name, tdm_error *error)
 527 {
 528         tdm_private_client *private_client;
 529         tdm_private_client_output *private_output = NULL;
 530         struct wl_proxy *wrapper;
 531
 532         if (error)
 533                 *error = TDM_ERROR_NONE;
 534
 535         if (!client) {
 536                 TDM_ERR("'!client' failed");
 537                 if (error)
 538                         *error = TDM_ERROR_INVALID_PARAMETER;
 539                 return NULL;
 540         }
 541
 542         private_client = (tdm_private_client*)client;
 543
 544         if (!name)
 545                 name = "primary";
 546
 547         LIST_FOR_EACH_ENTRY(private_output, &private_client->output_list, link) {
 548                 if (!strncmp(private_output->name, name, TDM_NAME_LEN))
 549                         return (tdm_client_output*)private_output;
 550         }
 551
 552         wrapper = wl_proxy_create_wrapper(private_client->tdm);
 553         if (!wrapper) {
 554                 TDM_ERR("create output_wrapper failed");
 555                 if (error)
 556                         *error = TDM_ERROR_OUT_OF_MEMORY;
 557                 return NULL;
 558         }
 559
 560         wl_proxy_set_queue(wrapper, private_client->queue);
 561
 562         private_output = calloc(1, sizeof *private_output);
 563         if (!private_output) {
 564                 /* LCOV_EXCL_START */
 565                 wl_proxy_wrapper_destroy(wrapper);
 566                 TDM_ERR("alloc failed");
 567                 if (error)
 568                         *error = TDM_ERROR_OUT_OF_MEMORY;
 569                 return NULL;
 570
 571                 /* LCOV_EXCL_STOP */
 572         }
 573
 574         private_output->private_client = private_client;
 575
 576         snprintf(private_output->name, TDM_NAME_LEN, "%s", name);
 577         private_output->output = wl_tdm_create_output((struct wl_tdm *)wrapper, private_output->name);
 578         wl_proxy_wrapper_destroy(wrapper);
 579         if (!private_output->output) {
 580                 /* LCOV_EXCL_START */
 581
 582                 TDM_ERR("couldn't create output resource");
 583                 free(private_output);
 584                 if (error)
 585                         *error = TDM_ERROR_OUT_OF_MEMORY;
 586                 return NULL;
 587
 588                 /* LCOV_EXCL_STOP */
 589         }
 590
 591         LIST_INITHEAD(&private_output->vblank_list);
 592         LIST_INITHEAD(&private_output->change_handler_list);
 593         LIST_ADDTAIL(&private_output->link, &private_client->output_list);
 594
 595         wl_tdm_output_add_listener(private_output->output,
 596                                                            &tdm_client_output_listener, private_output);
 597         wl_display_roundtrip_queue(private_client->display, private_client->queue);
 598
 599         wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
 600
 601         return (tdm_client_output*)private_output;
 602 }
 603
 604 tdm_error
 605 tdm_client_output_add_change_handler(tdm_client_output *output,
 606                                                                          tdm_client_output_change_handler func,
 607                                                                          void *user_data)
 608 {
 609         tdm_private_client_output *private_output;
 610         tdm_client_output_handler_info *h;
 611
 612         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 613         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 614
 615         private_output = (tdm_private_client_output*)output;
 616
 617         h = calloc(1, sizeof *h);
 618         TDM_RETURN_VAL_IF_FAIL(h != NULL, TDM_ERROR_OUT_OF_MEMORY);
 619
 620         if (LIST_IS_EMPTY(&private_output->change_handler_list)) {
 621                 wl_tdm_output_watch_output_changes(private_output->output, 1);
 622
 623                 /* TODO: this is very tricky.
 624                  * If a client adds the change_handler, we might be able to guess that
 625                  * the client will watch the tdm client's fd and handle tdm events in
 626                  * event loop. Otherwise, we CAN'T make sure if a client has event loop
 627                  * which handles tdm events.
 628                  */
 629                 private_output->watch_output_changes = 1;
 630         }
 631
 632         h->private_output = private_output;
 633         h->func = func;
 634         h->user_data = user_data;
 635         LIST_ADDTAIL(&h->link, &private_output->change_handler_list);
 636
 637         return TDM_ERROR_NOT_IMPLEMENTED;
 638 }
 639
 640 void
 641 tdm_client_output_remove_change_handler(tdm_client_output *output,
 642                                                                                 tdm_client_output_change_handler func,
 643                                                                                 void *user_data)
 644 {
 645         tdm_private_client_output *private_output;
 646         tdm_client_output_handler_info *h = NULL;
 647
 648         TDM_RETURN_IF_FAIL(output != NULL);
 649         TDM_RETURN_IF_FAIL(func != NULL);
 650
 651         private_output = (tdm_private_client_output*)output;
 652
 653         LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
 654                 if (h->func != func || h->user_data != user_data)
 655                         continue;
 656
 657                 LIST_DEL(&h->link);
 658                 free(h);
 659
 660                 if (LIST_IS_EMPTY(&private_output->change_handler_list))
 661                         wl_tdm_output_watch_output_changes(private_output->output, 0);
 662
 663                 return;
 664         }
 665 }
 666
 667 tdm_error
 668 tdm_client_output_get_refresh_rate(tdm_client_output *output, unsigned int *refresh)
 669 {
 670         tdm_private_client_output *private_output;
 671         tdm_private_client *private_client;
 672
 673         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 674         TDM_RETURN_VAL_IF_FAIL(refresh != NULL, TDM_ERROR_INVALID_PARAMETER);
 675
 676         private_output = (tdm_private_client_output*)output;
 677
 678         if (private_output->watch_output_changes) {
 679                 *refresh = private_output->refresh;
 680                 return TDM_ERROR_NONE;
 681         }
 682
 683         private_client = private_output->private_client;
 684         TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
 685
 686         wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
 687         wl_tdm_output_get_mode(private_output->output);
 688         wl_display_roundtrip_queue(private_client->display, private_client->queue);
 689         wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
 690
 691         *refresh = private_output->refresh;
 692
 693         return TDM_ERROR_NONE;
 694 }
 695
 696 tdm_error
 697 tdm_client_output_get_conn_status(tdm_client_output *output, tdm_output_conn_status *status)
 698 {
 699         tdm_private_client_output *private_output;
 700         tdm_private_client *private_client;
 701
 702         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 703         TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
 704
 705         private_output = (tdm_private_client_output*)output;
 706
 707         if (private_output->watch_output_changes) {
 708                 *status = private_output->connection;
 709                 return TDM_ERROR_NONE;
 710         }
 711
 712         private_client = private_output->private_client;
 713         TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
 714
 715         wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
 716         wl_tdm_output_get_connection(private_output->output);
 717         wl_display_roundtrip_queue(private_client->display, private_client->queue);
 718         wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
 719
 720         *status = private_output->connection;
 721
 722         return TDM_ERROR_NONE;
 723 }
 724
 725 tdm_error
 726 tdm_client_output_get_dpms(tdm_client_output *output, tdm_output_dpms *dpms)
 727 {
 728         tdm_private_client_output *private_output;
 729         tdm_private_client *private_client;
 730
 731         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 732         TDM_RETURN_VAL_IF_FAIL(dpms != NULL, TDM_ERROR_INVALID_PARAMETER);
 733
 734         private_output = (tdm_private_client_output*)output;
 735
 736         if (private_output->watch_output_changes) {
 737                 *dpms = private_output->dpms;
 738                 return TDM_ERROR_NONE;
 739         }
 740
 741         private_client = private_output->private_client;
 742         TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
 743
 744         wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
 745         wl_tdm_output_get_dpms(private_output->output);
 746         wl_display_roundtrip_queue(private_client->display, private_client->queue);
 747         wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
 748
 749         *dpms = private_output->dpms;
 750
 751         return TDM_ERROR_NONE;
 752 }
 753
 754 tdm_client_vblank*
 755 tdm_client_output_create_vblank(tdm_client_output *output, tdm_error *error)
 756 {
 757         tdm_private_client *private_client;
 758         tdm_private_client_output *private_output;
 759         tdm_private_client_vblank *private_vblank;
 760         struct wl_proxy *wrapper;
 761
 762         if (error)
 763                 *error = TDM_ERROR_NONE;
 764
 765         if (!output) {
 766                 TDM_ERR("'!output' failed");
 767                 if (error)
 768                         *error = TDM_ERROR_INVALID_PARAMETER;
 769                 return NULL;
 770         }
 771
 772         private_output = (tdm_private_client_output*)output;
 773         private_client = private_output->private_client;
 774
 775         if (!private_client) {
 776                 TDM_ERR("'!private_client' failed");
 777                 if (error)
 778                         *error = TDM_ERROR_INVALID_PARAMETER;
 779                 return NULL;
 780         }
 781
 782         wrapper = wl_proxy_create_wrapper(private_output->output);
 783         if (!wrapper) {
 784                 TDM_ERR("create output_wrapper failed");
 785                 if (error)
 786                         *error = TDM_ERROR_OUT_OF_MEMORY;
 787                 return NULL;
 788         }
 789
 790         wl_proxy_set_queue(wrapper, private_client->queue);
 791
 792         private_vblank = calloc(1, sizeof *private_vblank);
 793         if (!private_vblank) {
 794                 /* LCOV_EXCL_START */
 795
 796                 TDM_ERR("alloc failed");
 797                 wl_proxy_wrapper_destroy(wrapper);
 798                 if (error)
 799                         *error = TDM_ERROR_OUT_OF_MEMORY;
 800                 return NULL;
 801
 802                 /* LCOV_EXCL_STOP */
 803         }
 804
 805         private_vblank->private_output = private_output;
 806
 807         private_vblank->vblank = wl_tdm_output_create_vblank((struct wl_tdm_output*)wrapper);
 808         wl_proxy_wrapper_destroy(wrapper);
 809         if (!private_vblank->vblank) {
 810                 /* LCOV_EXCL_START */
 811
 812                 TDM_ERR("couldn't create vblank resource");
 813                 free(private_vblank);
 814                 if (error)
 815                         *error = TDM_ERROR_OUT_OF_MEMORY;
 816                 return NULL;
 817
 818                 /* LCOV_EXCL_STOP */
 819         }
 820
 821         /* initial value */
 822         private_vblank->fps = private_output->refresh;
 823         private_vblank->offset = 0;
 824         private_vblank->enable_fake = 0;
 825
 826         LIST_INITHEAD(&private_vblank->wait_list);
 827         LIST_ADDTAIL(&private_vblank->link, &private_output->vblank_list);
 828
 829         wl_tdm_vblank_add_listener(private_vblank->vblank,
 830                                                            &tdm_client_vblank_listener, private_vblank);
 831         wl_display_roundtrip_queue(private_client->display, private_client->queue);
 832
 833         wl_proxy_set_queue((struct wl_proxy *)private_vblank->vblank, NULL);
 834
 835         return (tdm_client_vblank*)private_vblank;
 836 }
 837
 838 void
 839 tdm_client_vblank_destroy(tdm_client_vblank *vblank)
 840 {
 841         tdm_private_client_vblank *private_vblank;
 842         tdm_client_wait_info *w = NULL, *ww = NULL;
 843
 844         TDM_RETURN_IF_FAIL(vblank != NULL);
 845
 846         private_vblank = vblank;
 847         LIST_DEL(&private_vblank->link);
 848
 849         LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->wait_list, link) {
 850                 LIST_DEL(&w->link);
 851                 free(w);
 852         }
 853
 854         wl_tdm_vblank_destroy(private_vblank->vblank);
 855
 856         free(private_vblank);
 857 }
 858
 859 tdm_error
 860 tdm_client_vblank_set_name(tdm_client_vblank *vblank, const char *name)
 861 {
 862         tdm_private_client_vblank *private_vblank;
 863
 864         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 865
 866         private_vblank = vblank;
 867
 868         if (!name)
 869                 name = TDM_VBLANK_DEFAULT_NAME;
 870
 871         strncpy(private_vblank->name, name, TDM_NAME_LEN - 1);
 872         private_vblank->name[TDM_NAME_LEN - 1] = '\0';
 873
 874         wl_tdm_vblank_set_name(private_vblank->vblank, private_vblank->name);
 875
 876         return TDM_ERROR_NONE;
 877 }
 878
 879 tdm_error
 880 tdm_client_vblank_set_sync(tdm_client_vblank *vblank, unsigned int sync)
 881 {
 882         tdm_private_client_vblank *private_vblank;
 883
 884         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 885
 886         private_vblank = vblank;
 887         private_vblank->sync = sync;
 888
 889         return TDM_ERROR_NONE;
 890 }
 891
 892 tdm_error
 893 tdm_client_vblank_set_fps(tdm_client_vblank *vblank, unsigned int fps)
 894 {
 895         tdm_private_client_vblank *private_vblank;
 896
 897         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 898         TDM_RETURN_VAL_IF_FAIL(fps > 0, TDM_ERROR_INVALID_PARAMETER);
 899
 900         private_vblank = vblank;
 901
 902         if (private_vblank->fps == fps)
 903                 return TDM_ERROR_NONE;
 904         private_vblank->fps = fps;
 905
 906         wl_tdm_vblank_set_fps(private_vblank->vblank, fps);
 907
 908         return TDM_ERROR_NONE;
 909 }
 910
 911 tdm_error
 912 tdm_client_vblank_set_offset(tdm_client_vblank *vblank, int offset_ms)
 913 {
 914         tdm_private_client_vblank *private_vblank;
 915
 916         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 917
 918         private_vblank = vblank;
 919         TDM_RETURN_VAL_IF_FAIL(private_vblank->started == 0, TDM_ERROR_BAD_REQUEST);
 920
 921         if (private_vblank->offset == offset_ms)
 922                 return TDM_ERROR_NONE;
 923         private_vblank->offset = offset_ms;
 924
 925         wl_tdm_vblank_set_offset(private_vblank->vblank, offset_ms);
 926
 927         return TDM_ERROR_NONE;
 928 }
 929
 930 tdm_error
 931 tdm_client_vblank_set_enable_fake(tdm_client_vblank *vblank, unsigned int enable_fake)
 932 {
 933         tdm_private_client_vblank *private_vblank;
 934
 935         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 936
 937         private_vblank = vblank;
 938
 939         if (private_vblank->enable_fake == enable_fake)
 940                 return TDM_ERROR_NONE;
 941         private_vblank->enable_fake = enable_fake;
 942
 943         wl_tdm_vblank_set_enable_fake(private_vblank->vblank, enable_fake);
 944
 945         return TDM_ERROR_NONE;
 946 }
 947
 948 tdm_error
 949 tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_client_vblank_handler func, void *user_data)
 950 {
 951         tdm_private_client *private_client;
 952         tdm_private_client_output *private_output;
 953         tdm_private_client_vblank *private_vblank;
 954         tdm_client_wait_info *w;
 955         struct timespec tp;
 956         unsigned int req_sec, req_usec;
 957         int ret = 0;
 958
 959         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 960         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 961         /* can't support "interval 0" and "getting current_msc" things because
 962          * there is a socket communication between TDM client and server. It's impossible
 963          * to return the current msc or sequence immediately.
 964          */
 965         TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
 966
 967         private_vblank = vblank;
 968         private_output = private_vblank->private_output;
 969         private_client = private_output->private_client;
 970
 971         if (!private_vblank->started)
 972                 private_vblank->started = 1;
 973
 974         if (private_output->watch_output_changes && !private_vblank->enable_fake) {
 975                 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
 976                         TDM_ERR("output disconnected");
 977                         return TDM_ERROR_OUTPUT_DISCONNECTED;
 978                 }
 979                 if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->dpms)) {
 980                         TDM_ERR("dpms %s", tdm_dpms_str(private_output->dpms));
 981                         return TDM_ERROR_DPMS_OFF;
 982                 }
 983         }
 984
 985         w = calloc(1, sizeof *w);
 986         if (!w) {
 987                 /* LCOV_EXCL_START */
 988
 989                 TDM_ERR("alloc failed");
 990                 return TDM_ERROR_OUT_OF_MEMORY;
 991
 992                 /* LCOV_EXCL_STOP */
 993         }
 994
 995         w->private_vblank = private_vblank;
 996         w->func = func;
 997         w->user_data = user_data;
 998
 999         LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
1000
1001         clock_gettime(CLOCK_MONOTONIC, &tp);
1002         req_sec = (unsigned int)tp.tv_sec;
1003         req_usec = (unsigned int)(tp.tv_nsec / 1000);
1004
1005         w->req_id = ++private_output->req_id;
1006         w->req_time = TDM_TIME(req_sec, req_usec);
1007         w->need_free = (private_vblank->sync) ? 0 : 1;
1008
1009         wl_tdm_vblank_wait_vblank(private_vblank->vblank, interval, w->req_id, req_sec, req_usec);
1010
1011         if (private_vblank->enable_ttrace)
1012                 TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
1013
1014         TDM_DBG("vblank(%p) interval(%u) req_id(%d) req(%.6f)",
1015                         vblank, interval, w->req_id, w->req_time);
1016
1017         private_vblank->req_time = w->req_time;
1018
1019         if (private_vblank->last_time >= w->req_time)
1020                 TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time);
1021
1022         if (!private_vblank->sync) {
1023                 wl_display_flush(private_client->display);
1024                 return TDM_ERROR_NONE;
1025         }
1026
1027         /* LCOV_EXCL_START */
1028
1029         while (ret != -1 && !w->need_free)
1030                 ret = wl_display_dispatch(private_client->display);
1031
1032         clock_gettime(CLOCK_MONOTONIC, &tp);
1033         TDM_DBG("block during %d us",
1034                         ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
1035                         - (req_sec * 1000000 + req_usec));
1036
1037         LIST_DEL(&w->link);
1038         free(w);
1039
1040         return TDM_ERROR_NONE;
1041
1042         /* LCOV_EXCL_STOP */
1043 }
1044
1045 tdm_error
1046 tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence,
1047                                                    tdm_client_vblank_handler func, void *user_data)
1048 {
1049         tdm_private_client *private_client;
1050         tdm_private_client_output *private_output;
1051         tdm_private_client_vblank *private_vblank;
1052         tdm_client_wait_info *w;
1053         struct timespec tp;
1054         unsigned int req_sec, req_usec;
1055         int ret = 0;
1056
1057         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1058         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
1059
1060         private_vblank = vblank;
1061         private_output = private_vblank->private_output;
1062         private_client = private_output->private_client;
1063
1064         if (!private_vblank->started)
1065                 private_vblank->started = 1;
1066
1067         if (private_output->watch_output_changes && !private_vblank->enable_fake) {
1068                 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
1069                         TDM_ERR("output disconnected");
1070                         return TDM_ERROR_OUTPUT_DISCONNECTED;
1071                 }
1072                 if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->dpms)) {
1073                         TDM_ERR("dpms %s", tdm_dpms_str(private_output->dpms));
1074                         return TDM_ERROR_DPMS_OFF;
1075                 }
1076         }
1077
1078         w = calloc(1, sizeof *w);
1079         if (!w) {
1080                 /* LCOV_EXCL_START */
1081
1082                 TDM_ERR("alloc failed");
1083                 return TDM_ERROR_OUT_OF_MEMORY;
1084
1085                 /* LCOV_EXCL_STOP */
1086         }
1087
1088         w->private_vblank = private_vblank;
1089         w->func = func;
1090         w->user_data = user_data;
1091
1092         LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
1093
1094         clock_gettime(CLOCK_MONOTONIC, &tp);
1095         req_sec = (unsigned int)tp.tv_sec;
1096         req_usec = (unsigned int)(tp.tv_nsec / 1000);
1097
1098         w->req_id = ++private_output->req_id;
1099         w->req_time = TDM_TIME(req_sec, req_usec);
1100         w->need_free = (private_vblank->sync) ? 0 : 1;
1101
1102         wl_tdm_vblank_wait_vblank_seq(private_vblank->vblank, sequence, w->req_id, req_sec, req_usec);
1103
1104         if (private_vblank->enable_ttrace)
1105                 TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
1106
1107         TDM_DBG("vblank(%p) sequence(%u) req_id(%d) req(%.6f)",
1108                         vblank, sequence, w->req_id, w->req_time);
1109
1110         private_vblank->req_time = w->req_time;
1111
1112         if (private_vblank->last_time >= w->req_time)
1113                 TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time);
1114
1115         if (!private_vblank->sync) {
1116                 wl_display_flush(private_client->display);
1117                 return TDM_ERROR_NONE;
1118         }
1119
1120         /* LCOV_EXCL_START */
1121
1122         while (ret != -1 && !w->need_free)
1123                 ret = wl_display_dispatch(private_client->display);
1124
1125         clock_gettime(CLOCK_MONOTONIC, &tp);
1126         TDM_DBG("block during %d us",
1127                         ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
1128                         - (req_sec * 1000000 + req_usec));
1129
1130         LIST_DEL(&w->link);
1131         free(w);
1132
1133         return TDM_ERROR_NONE;
1134
1135         /* LCOV_EXCL_STOP */
1136 }