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.h"
  47 #include "tdm_log.h"
  48 #include "tdm_macro.h"
  49 #include "tdm_list.h"
  50 #include "tdm.h"
  51 #include "tdm_private.h"
  52 #include "tdm-client-protocol.h"
  53
  54 typedef struct _tdm_private_client_vblank tdm_private_client_vblank;
  55
  56 typedef struct _tdm_private_client {
  57         struct wl_display *display;
  58         struct wl_registry *registry;
  59         struct wl_tdm *tdm;
  60         struct list_head output_list;
  61
  62         tdm_private_client_vblank *temp_vblank;
  63 } tdm_private_client;
  64
  65 typedef struct _tdm_private_client_output {
  66         tdm_private_client *private_client;
  67
  68         char name[TDM_NAME_LEN];
  69         struct wl_tdm_output *output;
  70         int width;
  71         int height;
  72         int refresh;
  73         tdm_output_conn_status connection;
  74         tdm_output_dpms dpms;
  75         struct list_head vblank_list;
  76         struct list_head change_handler_list;
  77
  78         unsigned int req_id;
  79         unsigned int watch_output_changes;
  80
  81         struct list_head link;
  82 } tdm_private_client_output;
  83
  84 struct _tdm_private_client_vblank {
  85         tdm_private_client_output *private_output;
  86
  87         struct wl_tdm_vblank *vblank;
  88         struct list_head wait_list;
  89
  90         char name[TDM_NAME_LEN];
  91         unsigned int sync;
  92         unsigned int fps;
  93         int offset;
  94         unsigned int enable_fake;
  95
  96         unsigned int started;
  97         unsigned int stamp;
  98
  99         double req_time;
 100         double last_time;
 101
 102         struct list_head link;
 103 };
 104
 105 typedef struct _tdm_client_output_handler_info {
 106         tdm_private_client_output *private_output;
 107
 108         tdm_client_output_change_handler func;
 109         void *user_data;
 110
 111         struct list_head link;
 112 } tdm_client_output_handler_info;
 113
 114 typedef struct _tdm_client_wait_info {
 115         tdm_private_client_vblank *private_vblank;
 116
 117         tdm_client_vblank_handler func;
 118         void *user_data;
 119
 120         unsigned int req_id;
 121         double req_time;
 122         int need_free;
 123
 124         struct list_head link;
 125 } tdm_client_wait_info;
 126
 127 static void
 128 _tdm_client_vblank_cb_stamp(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t stamp)
 129 {
 130         tdm_private_client_vblank *private_vblank = data;
 131
 132         TDM_RETURN_IF_FAIL(private_vblank != NULL);
 133
 134         private_vblank->stamp = stamp;
 135 }
 136
 137 static void
 138 _tdm_client_vblank_cb_done(void *data, struct wl_tdm_vblank *wl_tdm_vblank,
 139                                                    uint32_t req_id, uint32_t sequence, uint32_t tv_sec,
 140                                                    uint32_t tv_usec, uint32_t error)
 141 {
 142         tdm_private_client_vblank *private_vblank = data;
 143         tdm_client_wait_info *w = NULL, *ww = NULL;
 144
 145         TDM_RETURN_IF_FAIL(private_vblank != NULL);
 146
 147         private_vblank->last_time = TDM_TIME(tv_sec, tv_usec);
 148
 149         TDM_DBG("vblank(%p) req_id(%u) sequence(%u) time(%.6f)",
 150                         private_vblank, req_id, sequence, TDM_TIME(tv_sec, tv_usec));
 151
 152         LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->wait_list, link) {
 153                 if (w->req_id != req_id)
 154                         continue;
 155
 156                 TDM_TRACE_ASYNC_END((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
 157
 158                 if (w->req_time >= private_vblank->last_time)
 159                         TDM_WRN("'req(%.6f) < last(%.6f)' failed", w->req_time, private_vblank->last_time);
 160
 161                 if (w->func)
 162                         w->func(private_vblank, error, sequence, tv_sec, tv_usec, w->user_data);
 163
 164                 if (w->need_free) {
 165                         LIST_DEL(&w->link);
 166                         free(w);
 167                 } else
 168                         w->need_free = 1;
 169                 return;
 170         }
 171 }
 172
 173 static const struct wl_tdm_vblank_listener tdm_client_vblank_listener = {
 174         _tdm_client_vblank_cb_stamp,
 175         _tdm_client_vblank_cb_done,
 176 };
 177
 178 static void
 179 _tdm_client_output_destroy(tdm_private_client_output *private_output)
 180 {
 181         tdm_private_client_vblank *v = NULL, *vv = NULL;
 182         tdm_client_output_handler_info *h = NULL, *hh = NULL;
 183
 184         LIST_DEL(&private_output->link);
 185
 186         LIST_FOR_EACH_ENTRY_SAFE(v, vv, &private_output->vblank_list, link) {
 187                 TDM_ERR("vblanks SHOULD be destroyed first!");
 188                 LIST_DEL(&v->link);
 189                 v->private_output = NULL;
 190         }
 191
 192         LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list, link) {
 193                 LIST_DEL(&h->link);
 194                 free(h);
 195         }
 196
 197         wl_tdm_output_destroy(private_output->output);
 198
 199         free(private_output);
 200 }
 201
 202 static void
 203 _tdm_client_output_cb_mode(void *data, struct wl_tdm_output *wl_tdm_output,
 204                                                    uint32_t width, uint32_t height, uint32_t refresh, uint32_t error)
 205 {
 206         tdm_private_client_output *private_output = (tdm_private_client_output*)data;
 207
 208         TDM_RETURN_IF_FAIL(private_output != NULL);
 209
 210         private_output->width = width;
 211         private_output->height = height;
 212         private_output->refresh = refresh;
 213
 214         if (error != TDM_ERROR_NONE)
 215                 TDM_INFO("mode event error: %d", error);
 216
 217         TDM_DBG("private_output(%p) wl_tbm_output@%d width(%d) height(%d) refresh(%d)",
 218                         private_output, wl_proxy_get_id((struct wl_proxy*)private_output->output),
 219                         width, height, refresh);
 220 }
 221
 222 static void
 223 _tdm_client_output_cb_connection(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value, uint32_t error)
 224 {
 225         tdm_private_client_output *private_output = (tdm_private_client_output*)data;
 226         tdm_client_output_handler_info *h = NULL;
 227         tdm_value v;
 228
 229         TDM_RETURN_IF_FAIL(private_output != NULL);
 230
 231         if (private_output->connection == value)
 232                 return;
 233
 234         private_output->connection = value;
 235
 236         if (error != TDM_ERROR_NONE)
 237                 TDM_INFO("connection event error: %d", error);
 238
 239         TDM_DBG("private_output(%p) wl_tbm_output@%d connection(%d)",
 240                         private_output,
 241                         wl_proxy_get_id((struct wl_proxy*)private_output->output),
 242                         value);
 243
 244         v.u32 = value;
 245         LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
 246                 if (h->func)
 247                         h->func(private_output, TDM_OUTPUT_CHANGE_CONNECTION, v, h->user_data);
 248         }
 249 }
 250
 251 static void
 252 _tdm_client_output_cb_dpms(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value, uint32_t error)
 253 {
 254         tdm_private_client_output *private_output = (tdm_private_client_output*)data;
 255         tdm_client_output_handler_info *h = NULL;
 256         tdm_value v;
 257
 258         TDM_RETURN_IF_FAIL(private_output != NULL);
 259
 260         if (private_output->dpms == value)
 261                 return;
 262
 263         private_output->dpms = value;
 264
 265         if (error != TDM_ERROR_NONE)
 266                 TDM_INFO("dpms event error: %d", error);
 267
 268         TDM_DBG("private_output(%p) wl_tbm_output@%d dpms(%d)",
 269                         private_output,
 270                         wl_proxy_get_id((struct wl_proxy*)private_output->output),
 271                         value);
 272
 273         v.u32 = value;
 274         LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
 275                 if (h->func)
 276                         h->func(private_output, TDM_OUTPUT_CHANGE_DPMS, v, h->user_data);
 277         }
 278 }
 279
 280 static const struct wl_tdm_output_listener tdm_client_output_listener = {
 281         _tdm_client_output_cb_mode,
 282         _tdm_client_output_cb_connection,
 283         _tdm_client_output_cb_dpms,
 284 };
 285
 286 static void
 287 _tdm_client_cb_global(void *data, struct wl_registry *registry,
 288                                           uint32_t name, const char *interface,
 289                                           uint32_t version)
 290 {
 291         tdm_private_client *private_client = data;
 292
 293         if (strncmp(interface, "wl_tdm", 6) == 0) {
 294                 private_client->tdm =
 295                         wl_registry_bind(registry, name, &wl_tdm_interface, version);
 296                 TDM_RETURN_IF_FAIL(private_client->tdm != NULL);
 297
 298                 wl_display_flush(private_client->display);
 299         }
 300 }
 301
 302 static void
 303 _tdm_client_cb_global_remove(void *data, struct wl_registry *registry, uint32_t name)
 304 {
 305 }
 306
 307 static const struct wl_registry_listener tdm_client_registry_listener = {
 308         _tdm_client_cb_global,
 309         _tdm_client_cb_global_remove
 310 };
 311
 312 tdm_client*
 313 tdm_client_create(tdm_error *error)
 314 {
 315         tdm_private_client *private_client;
 316
 317         private_client = calloc(1, sizeof *private_client);
 318         if (!private_client) {
 319                 TDM_ERR("alloc failed");
 320                 if (error)
 321                         *error = TDM_ERROR_OUT_OF_MEMORY;
 322                 return NULL;
 323         }
 324
 325         LIST_INITHEAD(&private_client->output_list);
 326
 327         private_client->display = wl_display_connect("tdm-socket");
 328         TDM_GOTO_IF_FAIL(private_client->display != NULL, create_failed);
 329
 330         private_client->registry = wl_display_get_registry(private_client->display);
 331         TDM_GOTO_IF_FAIL(private_client->registry != NULL, create_failed);
 332
 333         wl_registry_add_listener(private_client->registry,
 334                                                          &tdm_client_registry_listener, private_client);
 335         wl_display_roundtrip(private_client->display);
 336
 337         /* check global objects */
 338         TDM_GOTO_IF_FAIL(private_client->tdm != NULL, create_failed);
 339
 340         if (error)
 341                 *error = TDM_ERROR_NONE;
 342
 343         return (tdm_client*)private_client;
 344 create_failed:
 345         tdm_client_destroy((tdm_client*)private_client);
 346         if (error)
 347                 *error = TDM_ERROR_OPERATION_FAILED;
 348         return NULL;
 349 }
 350
 351 void
 352 tdm_client_destroy(tdm_client *client)
 353 {
 354         tdm_private_client *private_client = (tdm_private_client*)client;
 355         tdm_private_client_output *o = NULL, *oo = NULL;
 356
 357         if (!private_client)
 358                 return;
 359
 360         if (private_client->temp_vblank)
 361                 tdm_client_vblank_destroy(private_client->temp_vblank);
 362
 363         LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_client->output_list, link) {
 364                 _tdm_client_output_destroy(o);
 365         }
 366
 367         if (private_client->tdm)
 368                 wl_tdm_destroy(private_client->tdm);
 369         if (private_client->registry)
 370                 wl_registry_destroy(private_client->registry);
 371         if (private_client->display)
 372                 wl_display_disconnect(private_client->display);
 373
 374         free(private_client);
 375 }
 376
 377 tdm_error
 378 tdm_client_get_fd(tdm_client *client, int *fd)
 379 {
 380         tdm_private_client *private_client;
 381
 382         TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
 383         TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
 384
 385         private_client = (tdm_private_client*)client;
 386
 387         *fd = wl_display_get_fd(private_client->display);
 388         if (*fd < 0)
 389                 return TDM_ERROR_OPERATION_FAILED;
 390
 391         return TDM_ERROR_NONE;
 392 }
 393
 394 tdm_error
 395 tdm_client_handle_events(tdm_client *client)
 396 {
 397         tdm_private_client *private_client;
 398
 399         TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
 400
 401         private_client = (tdm_private_client*)client;
 402
 403         wl_display_dispatch(private_client->display);
 404
 405         return TDM_ERROR_NONE;
 406 }
 407
 408 typedef struct _tdm_client_vblank_temp {
 409         tdm_client_vblank_handler2 func;
 410         void *user_data;
 411 } tdm_client_vblank_temp;
 412
 413 static void
 414 _tdm_client_vblank_handler_temp(tdm_client_vblank *vblank, tdm_error error, unsigned int sequence,
 415                                                                 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 416 {
 417         tdm_client_vblank_temp *vblank_temp = user_data;
 418
 419         TDM_RETURN_IF_FAIL(vblank_temp != NULL);
 420
 421         if (vblank_temp->func)
 422                 vblank_temp->func(sequence, tv_sec, tv_usec, vblank_temp->user_data);
 423
 424         free(vblank_temp);
 425 }
 426
 427 tdm_error
 428 tdm_client_wait_vblank(tdm_client *client, char *name,
 429                                            int sw_timer, int interval, int sync,
 430                                            tdm_client_vblank_handler2 func, void *user_data)
 431 {
 432         tdm_private_client *private_client = (tdm_private_client*)client;
 433         tdm_client_output *output;
 434         tdm_client_vblank_temp *vblank_temp;
 435         tdm_error ret;
 436
 437         TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
 438         TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
 439         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 440
 441         if (!private_client->temp_vblank) {
 442                 output = tdm_client_get_output(client, name, &ret);
 443                 TDM_RETURN_VAL_IF_FAIL(output != NULL, ret);
 444
 445                 private_client->temp_vblank = tdm_client_output_create_vblank(output, &ret);
 446                 TDM_RETURN_VAL_IF_FAIL(private_client->temp_vblank != NULL, ret);
 447         }
 448
 449         tdm_client_vblank_set_enable_fake(private_client->temp_vblank, sw_timer);
 450         tdm_client_vblank_set_sync(private_client->temp_vblank, sync);
 451
 452         vblank_temp = calloc(1, sizeof *vblank_temp);
 453         TDM_RETURN_VAL_IF_FAIL(vblank_temp != NULL, TDM_ERROR_OUT_OF_MEMORY);
 454
 455         vblank_temp->func = func;
 456         vblank_temp->user_data = user_data;
 457
 458         return tdm_client_vblank_wait(private_client->temp_vblank, interval, _tdm_client_vblank_handler_temp, vblank_temp);
 459 }
 460
 461 tdm_client_output*
 462 tdm_client_get_output(tdm_client *client, char *name, tdm_error *error)
 463 {
 464         tdm_private_client *private_client;
 465         tdm_private_client_output *private_output = NULL;
 466
 467         if (error)
 468                 *error = TDM_ERROR_NONE;
 469
 470         if (!client) {
 471                 TDM_ERR("'!client' failed");
 472                 if (error)
 473                         *error = TDM_ERROR_INVALID_PARAMETER;
 474                 return NULL;
 475         }
 476
 477         private_client = (tdm_private_client*)client;
 478
 479         if (!name)
 480                 name = "primary";
 481
 482         LIST_FOR_EACH_ENTRY(private_output, &private_client->output_list, link) {
 483                 if (!strncmp(private_output->name, name, TDM_NAME_LEN))
 484                         return (tdm_client_output*)private_output;
 485         }
 486
 487         private_output = calloc(1, sizeof *private_output);
 488         if (!private_output) {
 489                 TDM_ERR("alloc failed");
 490                 if (error)
 491                         *error = TDM_ERROR_OUT_OF_MEMORY;
 492                 return NULL;
 493         }
 494
 495         private_output->private_client = private_client;
 496
 497         snprintf(private_output->name, TDM_NAME_LEN, "%s", name);
 498         private_output->output = wl_tdm_create_output(private_client->tdm, private_output->name);
 499         if (!private_output->output) {
 500                 TDM_ERR("couldn't create output resource");
 501                 free(private_output);
 502                 if (error)
 503                         *error = TDM_ERROR_OUT_OF_MEMORY;
 504                 return NULL;
 505         }
 506
 507         LIST_INITHEAD(&private_output->vblank_list);
 508         LIST_INITHEAD(&private_output->change_handler_list);
 509         LIST_ADDTAIL(&private_output->link, &private_client->output_list);
 510
 511         wl_tdm_output_add_listener(private_output->output,
 512                                                            &tdm_client_output_listener, private_output);
 513         wl_display_roundtrip(private_client->display);
 514
 515         return (tdm_client_output*)private_output;
 516 }
 517
 518 tdm_error
 519 tdm_client_output_add_change_handler(tdm_client_output *output,
 520                                                                          tdm_client_output_change_handler func,
 521                                                                          void *user_data)
 522 {
 523         tdm_private_client_output *private_output;
 524         tdm_client_output_handler_info *h;
 525
 526         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 527         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 528
 529         private_output = (tdm_private_client_output*)output;
 530
 531         h = calloc(1, sizeof *h);
 532         TDM_RETURN_VAL_IF_FAIL(h != NULL, TDM_ERROR_OUT_OF_MEMORY);
 533
 534         if (LIST_IS_EMPTY(&private_output->change_handler_list)) {
 535                 wl_tdm_output_watch_output_changes(private_output->output, 1);
 536
 537                 /* TODO: this is very tricky.
 538                  * If a client adds the change_handler, we might be able to guess that
 539                  * the client will watch the tdm client's fd and handle tdm events in
 540                  * event loop. Otherwise, we CAN'T make sure if a client has event loop
 541                  * which handles tdm events.
 542                  */
 543                 private_output->watch_output_changes = 1;
 544         }
 545
 546         h->private_output = private_output;
 547         h->func = func;
 548         h->user_data = user_data;
 549         LIST_ADDTAIL(&h->link, &private_output->change_handler_list);
 550
 551         return TDM_ERROR_NOT_IMPLEMENTED;
 552 }
 553
 554 void
 555 tdm_client_output_remove_change_handler(tdm_client_output *output,
 556                                                                                 tdm_client_output_change_handler func,
 557                                                                                 void *user_data)
 558 {
 559         tdm_private_client_output *private_output;
 560         tdm_client_output_handler_info *h = NULL;
 561
 562         TDM_RETURN_IF_FAIL(output != NULL);
 563         TDM_RETURN_IF_FAIL(func != NULL);
 564
 565         private_output = (tdm_private_client_output*)output;
 566
 567         LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
 568                 if (h->func != func || h->user_data != user_data)
 569                         continue;
 570
 571                 LIST_DEL(&h->link);
 572                 free(h);
 573
 574                 if (LIST_IS_EMPTY(&private_output->change_handler_list))
 575                         wl_tdm_output_watch_output_changes(private_output->output, 0);
 576
 577                 return;
 578         }
 579 }
 580
 581 tdm_error
 582 tdm_client_output_get_refresh_rate(tdm_client_output *output, unsigned int *refresh)
 583 {
 584         tdm_private_client_output *private_output;
 585         tdm_private_client *private_client;
 586
 587         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 588         TDM_RETURN_VAL_IF_FAIL(refresh != NULL, TDM_ERROR_INVALID_PARAMETER);
 589
 590         private_output = (tdm_private_client_output*)output;
 591
 592         if (private_output->watch_output_changes) {
 593                 *refresh = private_output->refresh;
 594                 return TDM_ERROR_NONE;
 595         }
 596
 597         private_client = private_output->private_client;
 598         TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
 599
 600         wl_tdm_output_get_mode(private_output->output);
 601         wl_display_roundtrip(private_client->display);
 602
 603         *refresh = private_output->refresh;
 604
 605         return TDM_ERROR_NONE;
 606 }
 607
 608 tdm_error
 609 tdm_client_output_get_conn_status(tdm_client_output *output, tdm_output_conn_status *status)
 610 {
 611         tdm_private_client_output *private_output;
 612         tdm_private_client *private_client;
 613
 614         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 615         TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
 616
 617         private_output = (tdm_private_client_output*)output;
 618
 619         if (private_output->watch_output_changes) {
 620                 *status = private_output->connection;
 621                 return TDM_ERROR_NONE;
 622         }
 623
 624         private_client = private_output->private_client;
 625         TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
 626
 627         wl_tdm_output_get_connection(private_output->output);
 628         wl_display_roundtrip(private_client->display);
 629
 630         *status = private_output->connection;
 631
 632         return TDM_ERROR_NONE;
 633 }
 634
 635 tdm_error
 636 tdm_client_output_get_dpms(tdm_client_output *output, tdm_output_dpms *dpms)
 637 {
 638         tdm_private_client_output *private_output;
 639         tdm_private_client *private_client;
 640
 641         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 642         TDM_RETURN_VAL_IF_FAIL(dpms != NULL, TDM_ERROR_INVALID_PARAMETER);
 643
 644         private_output = (tdm_private_client_output*)output;
 645
 646         if (private_output->watch_output_changes) {
 647                 *dpms = private_output->dpms;
 648                 return TDM_ERROR_NONE;
 649         }
 650
 651         private_client = private_output->private_client;
 652         TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
 653
 654         wl_tdm_output_get_dpms(private_output->output);
 655         wl_display_roundtrip(private_client->display);
 656
 657         *dpms = private_output->dpms;
 658
 659         return TDM_ERROR_NONE;
 660 }
 661
 662 tdm_client_vblank*
 663 tdm_client_output_create_vblank(tdm_client_output *output, tdm_error *error)
 664 {
 665         tdm_private_client *private_client;
 666         tdm_private_client_output *private_output;
 667         tdm_private_client_vblank *private_vblank;
 668
 669         if (error)
 670                 *error = TDM_ERROR_NONE;
 671
 672         if (!output) {
 673                 TDM_ERR("'!output' failed");
 674                 if (error)
 675                         *error = TDM_ERROR_INVALID_PARAMETER;
 676                 return NULL;
 677         }
 678
 679         private_output = (tdm_private_client_output*)output;
 680         private_client = private_output->private_client;
 681
 682         if (!private_client) {
 683                 TDM_ERR("'!private_client' failed");
 684                 if (error)
 685                         *error = TDM_ERROR_INVALID_PARAMETER;
 686                 return NULL;
 687         }
 688
 689         private_vblank = calloc(1, sizeof *private_vblank);
 690         if (!private_vblank) {
 691                 TDM_ERR("alloc failed");
 692                 if (error)
 693                         *error = TDM_ERROR_OUT_OF_MEMORY;
 694                 return NULL;
 695         }
 696
 697         private_vblank->private_output = private_output;
 698
 699         private_vblank->vblank = wl_tdm_output_create_vblank(private_output->output);
 700         if (!private_vblank->vblank) {
 701                 TDM_ERR("couldn't create vblank resource");
 702                 free(private_vblank);
 703                 if (error)
 704                         *error = TDM_ERROR_OUT_OF_MEMORY;
 705                 return NULL;
 706         }
 707
 708         /* initial value */
 709         private_vblank->fps = private_output->refresh;
 710         private_vblank->offset = 0;
 711         private_vblank->enable_fake = 0;
 712
 713         LIST_INITHEAD(&private_vblank->wait_list);
 714         LIST_ADDTAIL(&private_vblank->link, &private_output->vblank_list);
 715
 716         wl_tdm_vblank_add_listener(private_vblank->vblank,
 717                                                            &tdm_client_vblank_listener, private_vblank);
 718         wl_display_roundtrip(private_client->display);
 719
 720         return (tdm_client_vblank*)private_vblank;
 721 }
 722
 723 void
 724 tdm_client_vblank_destroy(tdm_client_vblank *vblank)
 725 {
 726         tdm_private_client_vblank *private_vblank;
 727         tdm_client_wait_info *w = NULL, *ww = NULL;
 728
 729         TDM_RETURN_IF_FAIL(vblank != NULL);
 730
 731         private_vblank = vblank;
 732         LIST_DEL(&private_vblank->link);
 733
 734         LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->wait_list, link) {
 735                 LIST_DEL(&w->link);
 736                 free(w);
 737         }
 738
 739         wl_tdm_vblank_destroy(private_vblank->vblank);
 740
 741         free(private_vblank);
 742 }
 743
 744 tdm_error
 745 tdm_client_vblank_set_name(tdm_client_vblank *vblank, const char *name)
 746 {
 747         tdm_private_client_vblank *private_vblank;
 748
 749         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 750
 751         private_vblank = vblank;
 752
 753         if (!name)
 754                 name = TDM_VBLANK_DEFAULT_NAME;
 755
 756         strncpy(private_vblank->name, name, TDM_NAME_LEN - 1);
 757         private_vblank->name[TDM_NAME_LEN - 1] = '\0';
 758
 759         wl_tdm_vblank_set_name(private_vblank->vblank, private_vblank->name);
 760
 761         return TDM_ERROR_NONE;
 762 }
 763
 764 tdm_error
 765 tdm_client_vblank_set_sync(tdm_client_vblank *vblank, unsigned int sync)
 766 {
 767         tdm_private_client_vblank *private_vblank;
 768
 769         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 770
 771         private_vblank = vblank;
 772         private_vblank->sync = sync;
 773
 774         return TDM_ERROR_NONE;
 775 }
 776
 777 tdm_error
 778 tdm_client_vblank_set_fps(tdm_client_vblank *vblank, unsigned int fps)
 779 {
 780         tdm_private_client_vblank *private_vblank;
 781
 782         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 783         TDM_RETURN_VAL_IF_FAIL(fps > 0, TDM_ERROR_INVALID_PARAMETER);
 784
 785         private_vblank = vblank;
 786
 787         if (private_vblank->fps == fps)
 788                 return TDM_ERROR_NONE;
 789         private_vblank->fps = fps;
 790
 791         wl_tdm_vblank_set_fps(private_vblank->vblank, fps);
 792
 793         return TDM_ERROR_NONE;
 794 }
 795
 796 tdm_error
 797 tdm_client_vblank_set_offset(tdm_client_vblank *vblank, int offset_ms)
 798 {
 799         tdm_private_client_vblank *private_vblank;
 800
 801         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 802
 803         private_vblank = vblank;
 804         TDM_RETURN_VAL_IF_FAIL(private_vblank->started == 0, TDM_ERROR_BAD_REQUEST);
 805
 806         if (private_vblank->offset == offset_ms)
 807                 return TDM_ERROR_NONE;
 808         private_vblank->offset = offset_ms;
 809
 810         wl_tdm_vblank_set_offset(private_vblank->vblank, offset_ms);
 811
 812         return TDM_ERROR_NONE;
 813 }
 814
 815 tdm_error
 816 tdm_client_vblank_set_enable_fake(tdm_client_vblank *vblank, unsigned int enable_fake)
 817 {
 818         tdm_private_client_vblank *private_vblank;
 819
 820         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 821
 822         private_vblank = vblank;
 823
 824         if (private_vblank->enable_fake == enable_fake)
 825                 return TDM_ERROR_NONE;
 826         private_vblank->enable_fake = enable_fake;
 827
 828         wl_tdm_vblank_set_enable_fake(private_vblank->vblank, enable_fake);
 829
 830         return TDM_ERROR_NONE;
 831 }
 832
 833 tdm_error
 834 tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_client_vblank_handler func, void *user_data)
 835 {
 836         tdm_private_client *private_client;
 837         tdm_private_client_output *private_output;
 838         tdm_private_client_vblank *private_vblank;
 839         tdm_client_wait_info *w;
 840         struct timespec tp;
 841         unsigned int req_sec, req_usec;
 842         int ret = 0;
 843
 844         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 845         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 846         /* can't support "interval 0" and "getting current_msc" things because
 847          * there is a socket communication between TDM client and server. It's impossible
 848          * to return the current msc or sequence immediately.
 849          */
 850         TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
 851
 852         private_vblank = vblank;
 853         private_output = private_vblank->private_output;
 854         private_client = private_output->private_client;
 855
 856         if (!private_vblank->started)
 857                 private_vblank->started = 1;
 858
 859         if (private_output->watch_output_changes && !private_vblank->enable_fake) {
 860                 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
 861                         TDM_ERR("output disconnected");
 862                         return TDM_ERROR_OUTPUT_DISCONNECTED;
 863                 }
 864                 if (private_output->dpms != TDM_OUTPUT_DPMS_ON) {
 865                         TDM_ERR("dpms off");
 866                         return TDM_ERROR_DPMS_OFF;
 867                 }
 868         }
 869
 870         w = calloc(1, sizeof *w);
 871         if (!w) {
 872                 TDM_ERR("alloc failed");
 873                 return TDM_ERROR_OUT_OF_MEMORY;
 874         }
 875
 876         w->private_vblank = private_vblank;
 877         w->func = func;
 878         w->user_data = user_data;
 879
 880         LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
 881
 882         clock_gettime(CLOCK_MONOTONIC, &tp);
 883         req_sec = (unsigned int)tp.tv_sec;
 884         req_usec = (unsigned int)(tp.tv_nsec / 1000);
 885
 886         w->req_id = ++private_output->req_id;
 887         w->req_time = TDM_TIME(req_sec, req_usec);
 888         w->need_free = (private_vblank->sync) ? 0 : 1;
 889
 890         wl_tdm_vblank_wait_vblank(private_vblank->vblank, interval, w->req_id, req_sec, req_usec);
 891
 892         TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
 893
 894         TDM_DBG("vblank(%p) interval(%u) req_id(%d) req(%.6f)",
 895                         vblank, interval, w->req_id, w->req_time);
 896
 897         private_vblank->req_time = w->req_time;
 898
 899         if (private_vblank->last_time >= w->req_time)
 900                 TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time);
 901
 902         if (!private_vblank->sync) {
 903                 wl_display_flush(private_client->display);
 904                 return TDM_ERROR_NONE;
 905         }
 906
 907         while (ret != -1 && !w->need_free)
 908                 ret = wl_display_dispatch(private_client->display);
 909
 910         clock_gettime(CLOCK_MONOTONIC, &tp);
 911         TDM_DBG("block during %d us",
 912                         ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
 913                         - (req_sec * 1000000 + req_usec));
 914
 915         LIST_DEL(&w->link);
 916         free(w);
 917
 918         return TDM_ERROR_NONE;
 919 }
 920
 921 tdm_error
 922 tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence,
 923                                                    tdm_client_vblank_handler func, void *user_data)
 924 {
 925         tdm_private_client *private_client;
 926         tdm_private_client_output *private_output;
 927         tdm_private_client_vblank *private_vblank;
 928         tdm_client_wait_info *w;
 929         struct timespec tp;
 930         unsigned int req_sec, req_usec;
 931         int ret = 0;
 932
 933         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 934         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 935
 936         private_vblank = vblank;
 937         private_output = private_vblank->private_output;
 938         private_client = private_output->private_client;
 939
 940         if (!private_vblank->started)
 941                 private_vblank->started = 1;
 942
 943         if (private_output->watch_output_changes && !private_vblank->enable_fake) {
 944                 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
 945                         TDM_ERR("output disconnected");
 946                         return TDM_ERROR_OUTPUT_DISCONNECTED;
 947                 }
 948                 if (private_output->dpms != TDM_OUTPUT_DPMS_ON) {
 949                         TDM_ERR("dpms off");
 950                         return TDM_ERROR_DPMS_OFF;
 951                 }
 952         }
 953
 954         w = calloc(1, sizeof *w);
 955         if (!w) {
 956                 TDM_ERR("alloc failed");
 957                 return TDM_ERROR_OUT_OF_MEMORY;
 958         }
 959
 960         w->private_vblank = private_vblank;
 961         w->func = func;
 962         w->user_data = user_data;
 963
 964         LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
 965
 966         clock_gettime(CLOCK_MONOTONIC, &tp);
 967         req_sec = (unsigned int)tp.tv_sec;
 968         req_usec = (unsigned int)(tp.tv_nsec / 1000);
 969
 970         w->req_id = ++private_output->req_id;
 971         w->req_time = TDM_TIME(req_sec, req_usec);
 972         w->need_free = (private_vblank->sync) ? 0 : 1;
 973
 974         wl_tdm_vblank_wait_vblank_seq(private_vblank->vblank, sequence, w->req_id, req_sec, req_usec);
 975
 976         TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
 977
 978         TDM_DBG("vblank(%p) sequence(%u) req_id(%d) req(%.6f)",
 979                         vblank, sequence, w->req_id, w->req_time);
 980
 981         private_vblank->req_time = w->req_time;
 982
 983         if (private_vblank->last_time >= w->req_time)
 984                 TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time);
 985
 986         if (!private_vblank->sync) {
 987                 wl_display_flush(private_client->display);
 988                 return TDM_ERROR_NONE;
 989         }
 990
 991         while (ret != -1 && !w->need_free)
 992                 ret = wl_display_dispatch(private_client->display);
 993
 994         clock_gettime(CLOCK_MONOTONIC, &tp);
 995         TDM_DBG("block during %d us",
 996                         ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
 997                         - (req_sec * 1000000 + req_usec));
 998
 999         LIST_DEL(&w->link);
1000         free(w);
1001
1002         return TDM_ERROR_NONE;
1003 }