src/tdm_display.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 "tdm.h"
  41 #include "tdm_backend.h"
  42 #include "tdm_private.h"
  43 #include "tdm_helper.h"
  44
  45 #define COUNT_MAX   10
  46
  47 #define DISPLAY_FUNC_ENTRY() \
  48         tdm_private_display *private_display; \
  49         tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
  50         TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER); \
  51         private_display = (tdm_private_display*)dpy;
  52
  53 #define DISPLAY_FUNC_ENTRY_ERROR() \
  54         tdm_private_display *private_display; \
  55         tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
  56         TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
  57         private_display = (tdm_private_display*)dpy;
  58
  59 #define OUTPUT_FUNC_ENTRY() \
  60         tdm_private_display *private_display; \
  61         tdm_private_output *private_output; \
  62         tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
  63         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER); \
  64         private_output = (tdm_private_output*)output; \
  65         private_display = private_output->private_display
  66
  67 #define OUTPUT_FUNC_ENTRY_ERROR() \
  68         tdm_private_display *private_display; \
  69         tdm_private_output *private_output; \
  70         tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
  71         TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(output != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
  72         private_output = (tdm_private_output*)output; \
  73         private_display = private_output->private_display
  74
  75 #define LAYER_FUNC_ENTRY() \
  76         tdm_private_display *private_display; \
  77         tdm_private_output *private_output; \
  78         tdm_private_layer *private_layer; \
  79         tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
  80         TDM_RETURN_VAL_IF_FAIL(layer != NULL, TDM_ERROR_INVALID_PARAMETER); \
  81         private_layer = (tdm_private_layer*)layer; \
  82         private_output = private_layer->private_output; \
  83         private_display = private_output->private_display
  84
  85 #define LAYER_FUNC_ENTRY_ERROR() \
  86         tdm_private_display *private_display; \
  87         tdm_private_output *private_output; \
  88         tdm_private_layer *private_layer; \
  89         tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
  90         TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(layer != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
  91         private_layer = (tdm_private_layer*)layer; \
  92         private_output = private_layer->private_output; \
  93         private_display = private_output->private_display
  94
  95 #define LAYER_FUNC_ENTRY_VOID_RETURN() \
  96         tdm_private_display *private_display; \
  97         tdm_private_output *private_output; \
  98         tdm_private_layer *private_layer; \
  99         tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
 100         TDM_RETURN_IF_FAIL(layer != NULL); \
 101         private_layer = (tdm_private_layer*)layer; \
 102         private_output = private_layer->private_output; \
 103         private_display = private_output->private_display
 104
 105 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
 106
 107 struct type_name {
 108         int type;
 109         const char *name;
 110 };
 111
 112 #define type_name_fn(res) \
 113 const char * res##_str(int type)        \
 114 {                       \
 115         unsigned int i;                                 \
 116         for (i = 0; i < ARRAY_SIZE(res##_names); i++) { \
 117                 if (res##_names[i].type == type)        \
 118                         return res##_names[i].name;     \
 119         }                                               \
 120         return "(invalid)";                             \
 121 }
 122
 123 struct type_name dpms_names[] = {
 124         { TDM_OUTPUT_DPMS_ON, "on" },
 125         { TDM_OUTPUT_DPMS_STANDBY, "standby" },
 126         { TDM_OUTPUT_DPMS_SUSPEND, "suspend" },
 127         { TDM_OUTPUT_DPMS_OFF, "off" },
 128 };
 129
 130 INTERN type_name_fn(dpms)
 131
 132 struct type_name status_names[] = {
 133         { TDM_OUTPUT_CONN_STATUS_DISCONNECTED, "disconnected" },
 134         { TDM_OUTPUT_CONN_STATUS_CONNECTED, "connected" },
 135         { TDM_OUTPUT_CONN_STATUS_MODE_SETTED, "mode_setted" },
 136 };
 137
 138 INTERN type_name_fn(status)
 139
 140 INTERN const char*
 141 tdm_get_dpms_str(tdm_output_dpms dpms_value)
 142 {
 143         return dpms_str(dpms_value);
 144 }
 145
 146 INTERN tdm_error
 147 _tdm_display_lock(tdm_display *dpy, const char *func)
 148 {
 149         tdm_private_display *private_display = (tdm_private_display*)dpy;
 150         int ret;
 151
 152         if (tdm_debug_mutex)
 153                 TDM_INFO("mutex lock: %s", func);
 154
 155         ret = pthread_mutex_trylock(&private_display->lock);
 156         if (ret < 0) {
 157                 if (ret == EBUSY) {
 158                         TDM_ERR("mutex lock busy: %s", func);
 159                 } else {
 160                         TDM_ERR("mutex lock failed: %s(%m)", func);
 161                 }
 162                 return TDM_ERROR_OPERATION_FAILED;
 163         }
 164
 165         pthread_mutex_lock(&tdm_mutex_check_lock);
 166         tdm_mutex_locked = 1;
 167         pthread_mutex_unlock(&tdm_mutex_check_lock);
 168
 169         return TDM_ERROR_NONE;
 170 }
 171
 172 INTERN void
 173 _tdm_display_unlock(tdm_display *dpy, const char *func)
 174 {
 175         tdm_private_display *private_display = (tdm_private_display*)dpy;
 176
 177         if (tdm_debug_mutex)
 178                 TDM_INFO("mutex unlock: %s", func);
 179
 180         pthread_mutex_lock(&tdm_mutex_check_lock);
 181         tdm_mutex_locked = 0;
 182         pthread_mutex_unlock(&tdm_mutex_check_lock);
 183
 184         pthread_mutex_unlock(&private_display->lock);
 185 }
 186
 187 EXTERN tdm_error
 188 tdm_display_get_capabilities(tdm_display *dpy,
 189                                                          tdm_display_capability *capabilities)
 190 {
 191         DISPLAY_FUNC_ENTRY();
 192
 193         TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 194
 195         _pthread_mutex_lock(&private_display->lock);
 196
 197         *capabilities = private_display->capabilities;
 198
 199         _pthread_mutex_unlock(&private_display->lock);
 200
 201         return ret;
 202 }
 203
 204 EXTERN tdm_error
 205 tdm_display_get_pp_capabilities(tdm_display *dpy,
 206                                                                 tdm_pp_capability *capabilities)
 207 {
 208         DISPLAY_FUNC_ENTRY();
 209
 210         TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 211
 212         _pthread_mutex_lock(&private_display->lock);
 213
 214         if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) {
 215                 TDM_ERR("no pp capability");
 216                 _pthread_mutex_unlock(&private_display->lock);
 217                 return TDM_ERROR_NO_CAPABILITY;
 218         }
 219
 220         *capabilities = private_display->caps_pp.capabilities;
 221
 222         _pthread_mutex_unlock(&private_display->lock);
 223
 224         return ret;
 225 }
 226
 227 EXTERN tdm_error
 228 tdm_display_get_pp_available_formats(tdm_display *dpy,
 229                                                                          const tbm_format **formats, int *count)
 230 {
 231         DISPLAY_FUNC_ENTRY();
 232
 233         TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
 234         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 235
 236         _pthread_mutex_lock(&private_display->lock);
 237
 238         if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) {
 239                 TDM_ERR("no pp capability");
 240                 _pthread_mutex_unlock(&private_display->lock);
 241                 return TDM_ERROR_NO_CAPABILITY;
 242         }
 243
 244         *formats = (const tbm_format *)private_display->caps_pp.formats;
 245         *count = private_display->caps_pp.format_count;
 246
 247         _pthread_mutex_unlock(&private_display->lock);
 248
 249         return ret;
 250 }
 251
 252 EXTERN tdm_error
 253 tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h,
 254                                                                   int *max_w, int *max_h, int *preferred_align)
 255 {
 256         DISPLAY_FUNC_ENTRY();
 257
 258         _pthread_mutex_lock(&private_display->lock);
 259
 260         if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) {
 261                 TDM_ERR("no pp capability");
 262                 _pthread_mutex_unlock(&private_display->lock);
 263                 return TDM_ERROR_NO_CAPABILITY;
 264         }
 265
 266         if (min_w)
 267                 *min_w = private_display->caps_pp.min_w;
 268         if (min_h)
 269                 *min_h = private_display->caps_pp.min_h;
 270         if (max_w)
 271                 *max_w = private_display->caps_pp.max_w;
 272         if (max_h)
 273                 *max_h = private_display->caps_pp.max_h;
 274         if (preferred_align)
 275                 *preferred_align = private_display->caps_pp.preferred_align;
 276
 277         _pthread_mutex_unlock(&private_display->lock);
 278
 279         return ret;
 280 }
 281
 282 EXTERN tdm_error
 283 tdm_display_get_capture_capabilities(tdm_display *dpy,
 284                                                                          tdm_capture_capability *capabilities)
 285 {
 286         DISPLAY_FUNC_ENTRY();
 287
 288         TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 289
 290         _pthread_mutex_lock(&private_display->lock);
 291
 292         if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
 293                 TDM_ERR("no capture capability");
 294                 _pthread_mutex_unlock(&private_display->lock);
 295                 return TDM_ERROR_NO_CAPABILITY;
 296         }
 297
 298         *capabilities = private_display->caps_capture.capabilities;
 299
 300         _pthread_mutex_unlock(&private_display->lock);
 301
 302         return ret;
 303 }
 304
 305 EXTERN tdm_error
 306 tdm_display_get_catpure_available_formats(tdm_display *dpy,
 307                 const tbm_format **formats, int *count)
 308 {
 309         DISPLAY_FUNC_ENTRY();
 310
 311         TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
 312         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 313
 314         _pthread_mutex_lock(&private_display->lock);
 315
 316         if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
 317                 TDM_ERR("no capture capability");
 318                 _pthread_mutex_unlock(&private_display->lock);
 319                 return TDM_ERROR_NO_CAPABILITY;
 320         }
 321
 322         *formats = (const tbm_format *)private_display->caps_capture.formats;
 323         *count = private_display->caps_capture.format_count;
 324
 325         _pthread_mutex_unlock(&private_display->lock);
 326
 327         return ret;
 328 }
 329
 330 EXTERN tdm_error
 331 tdm_display_get_output_count(tdm_display *dpy, int *count)
 332 {
 333         tdm_private_output *private_output = NULL;
 334
 335         DISPLAY_FUNC_ENTRY();
 336
 337         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 338
 339         _pthread_mutex_lock(&private_display->lock);
 340
 341         *count = 0;
 342         LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link)
 343         (*count)++;
 344
 345         if (*count == 0) {
 346                 _pthread_mutex_unlock(&private_display->lock);
 347                 return TDM_ERROR_NONE;
 348         }
 349
 350         _pthread_mutex_unlock(&private_display->lock);
 351
 352         return ret;
 353 }
 354
 355
 356 EXTERN tdm_output *
 357 tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error)
 358 {
 359         tdm_private_output *private_output = NULL;
 360         int i = 0;
 361
 362         DISPLAY_FUNC_ENTRY_ERROR();
 363
 364         _pthread_mutex_lock(&private_display->lock);
 365
 366         if (error)
 367                 *error = TDM_ERROR_NONE;
 368
 369         i = 0;
 370         LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link) {
 371                 if (i == index) {
 372                         _pthread_mutex_unlock(&private_display->lock);
 373                         return private_output;
 374                 }
 375                 i++;
 376         }
 377
 378         _pthread_mutex_unlock(&private_display->lock);
 379
 380         return NULL;
 381 }
 382
 383 EXTERN tdm_error
 384 tdm_display_get_fd(tdm_display *dpy, int *fd)
 385 {
 386         DISPLAY_FUNC_ENTRY();
 387
 388         TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
 389
 390         _pthread_mutex_lock(&private_display->lock);
 391
 392         if (tdm_thread_is_running())
 393                 *fd = tdm_thread_get_fd(private_display->private_loop);
 394         else
 395                 *fd = tdm_event_loop_get_fd(private_display);
 396
 397         _pthread_mutex_unlock(&private_display->lock);
 398
 399         return ret;
 400 }
 401
 402 EXTERN tdm_error
 403 tdm_display_handle_events(tdm_display *dpy)
 404 {
 405         struct pollfd fds;
 406         int fd = -1;
 407
 408         DISPLAY_FUNC_ENTRY();
 409
 410         ret = tdm_display_get_fd(dpy, &fd);
 411         TDM_RETURN_VAL_IF_FAIL(fd >= 0, ret);
 412
 413         fds.events = POLLIN;
 414         fds.fd = fd;
 415         fds.revents = 0;
 416
 417         if (tdm_debug_thread)
 418                 TDM_INFO("fd(%d) polling in", fd);
 419
 420         while (poll(&fds, 1, -1) < 0) {
 421                 if (errno == EBUSY)  /* normal case */
 422                         continue;
 423                 else {
 424                         TDM_ERR("poll failed: %m");
 425                         return TDM_ERROR_OPERATION_FAILED;
 426                 }
 427         }
 428
 429         if (tdm_debug_thread)
 430                 TDM_INFO("fd(%d) polling out", fd);
 431
 432         if (tdm_thread_is_running())
 433                 ret = tdm_thread_handle_cb(private_display->private_loop);
 434         else
 435                 ret = tdm_event_loop_dispatch(private_display);
 436
 437         return ret;
 438 }
 439
 440 EXTERN tdm_pp *
 441 tdm_display_create_pp(tdm_display *dpy, tdm_error *error)
 442 {
 443         tdm_pp *pp;
 444
 445         DISPLAY_FUNC_ENTRY_ERROR();
 446
 447         _pthread_mutex_lock(&private_display->lock);
 448
 449         pp = (tdm_pp *)tdm_pp_create_internal(private_display, error);
 450
 451         _pthread_mutex_unlock(&private_display->lock);
 452
 453         return pp;
 454 }
 455
 456 EXTERN tdm_error
 457 tdm_output_get_model_info(tdm_output *output, const char **maker,
 458                                                   const char **model, const char **name)
 459 {
 460         OUTPUT_FUNC_ENTRY();
 461
 462         _pthread_mutex_lock(&private_display->lock);
 463
 464         if (maker)
 465                 *maker = private_output->caps.maker;
 466         if (model)
 467                 *model = private_output->caps.model;
 468         if (name)
 469                 *name = private_output->caps.name;
 470
 471         _pthread_mutex_unlock(&private_display->lock);
 472
 473         return ret;
 474 }
 475
 476 EXTERN tdm_error
 477 tdm_output_get_conn_status(tdm_output *output, tdm_output_conn_status *status)
 478 {
 479         OUTPUT_FUNC_ENTRY();
 480
 481         TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
 482
 483         _pthread_mutex_lock(&private_display->lock);
 484
 485         *status = private_output->caps.status;
 486
 487         _pthread_mutex_unlock(&private_display->lock);
 488
 489         return ret;
 490 }
 491
 492 static void
 493 _tdm_output_update(tdm_output *output_backend, void *user_data)
 494 {
 495         tdm_private_display *private_display;
 496         tdm_private_output *private_output = user_data;
 497         tdm_error ret;
 498
 499         TDM_RETURN_IF_FAIL(private_output);
 500
 501         private_display = private_output->private_display;
 502
 503         ret = tdm_display_update_output(private_display, output_backend, private_output->pipe);
 504         TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
 505 }
 506
 507 INTERN void
 508 tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status,
 509                                          void *user_data)
 510 {
 511         tdm_private_display *private_display;
 512         tdm_private_output *private_output = user_data;
 513         tdm_value value;
 514
 515         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 516         TDM_RETURN_IF_FAIL(private_output);
 517
 518         private_display = private_output->private_display;
 519
 520         if (!tdm_thread_in_display_thread(syscall(SYS_gettid))) {
 521                 tdm_thread_cb_output_status output_status;
 522                 tdm_error ret;
 523
 524                 _tdm_output_update(output_backend, user_data);
 525
 526                 output_status.base.type = TDM_THREAD_CB_OUTPUT_STATUS;
 527                 output_status.base.length = sizeof output_status;
 528                 output_status.output_stamp = private_output->stamp;
 529                 output_status.status = status;
 530                 output_status.user_data = user_data;
 531
 532                 value.u32 = status;
 533                 tdm_output_call_change_handler_internal(private_output,
 534                                                                                                 &private_output->change_handler_list_sub,
 535                                                                                                 TDM_OUTPUT_CHANGE_CONNECTION,
 536                                                                                                 value);
 537
 538                 ret = tdm_thread_send_cb(private_display->private_loop, &output_status.base);
 539                 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 540
 541                 return;
 542         }
 543
 544         if (!tdm_thread_is_running())
 545                 _tdm_output_update(output_backend, user_data);
 546
 547         value.u32 = status;
 548         tdm_output_call_change_handler_internal(private_output,
 549                                                                                         &private_output->change_handler_list_main,
 550                                                                                         TDM_OUTPUT_CHANGE_CONNECTION,
 551                                                                                         value);
 552 }
 553
 554 EXTERN tdm_error
 555 tdm_output_add_change_handler(tdm_output *output,
 556                                                           tdm_output_change_handler func,
 557                                                           void *user_data)
 558 {
 559         tdm_private_change_handler *change_handler;
 560         OUTPUT_FUNC_ENTRY();
 561
 562         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 563
 564         pthread_mutex_lock(&private_display->lock);
 565
 566         if (!private_output->regist_change_cb) {
 567                 _pthread_mutex_unlock(&private_display->lock);
 568                 TDM_ERR("not implemented!!");
 569                 return TDM_ERROR_NOT_IMPLEMENTED;
 570         }
 571
 572         change_handler = calloc(1, sizeof(tdm_private_change_handler));
 573         if (!change_handler) {
 574                 TDM_ERR("failed: alloc memory");
 575                 _pthread_mutex_unlock(&private_display->lock);
 576                 return TDM_ERROR_OUT_OF_MEMORY;
 577         }
 578
 579         change_handler->private_output = private_output;
 580         change_handler->func = func;
 581         change_handler->user_data = user_data;
 582         change_handler->owner_tid = syscall(SYS_gettid);
 583
 584         if (!tdm_thread_in_display_thread(change_handler->owner_tid))
 585                 LIST_ADD(&change_handler->link, &private_output->change_handler_list_sub);
 586         else
 587                 LIST_ADD(&change_handler->link, &private_output->change_handler_list_main);
 588
 589         _pthread_mutex_unlock(&private_display->lock);
 590
 591         return ret;
 592 }
 593
 594 EXTERN void
 595 tdm_output_remove_change_handler(tdm_output *output,
 596                                                                  tdm_output_change_handler func,
 597                                                                  void *user_data)
 598 {
 599         tdm_private_display *private_display;
 600         tdm_private_output *private_output;
 601         tdm_private_change_handler *h = NULL, *hh = NULL;
 602
 603         TDM_RETURN_IF_FAIL(output != NULL);
 604         TDM_RETURN_IF_FAIL(func != NULL);
 605
 606         private_output = (tdm_private_output*)output;
 607         private_display = private_output->private_display;
 608
 609         _pthread_mutex_lock(&private_display->lock);
 610
 611         LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list_main, link) {
 612                 if (h->func != func || h->user_data != user_data)
 613                         continue;
 614
 615                 LIST_DEL(&h->link);
 616                 free(h);
 617
 618                 _pthread_mutex_unlock(&private_display->lock);
 619
 620                 return;
 621         }
 622
 623         LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list_sub, link) {
 624                 if (h->func != func || h->user_data != user_data)
 625                         continue;
 626
 627                 LIST_DEL(&h->link);
 628                 free(h);
 629
 630                 _pthread_mutex_unlock(&private_display->lock);
 631
 632                 return;
 633         }
 634
 635         _pthread_mutex_unlock(&private_display->lock);
 636 }
 637
 638 EXTERN tdm_error
 639 tdm_output_get_output_type(tdm_output *output, tdm_output_type *type)
 640 {
 641         OUTPUT_FUNC_ENTRY();
 642
 643         TDM_RETURN_VAL_IF_FAIL(type != NULL, TDM_ERROR_INVALID_PARAMETER);
 644
 645         _pthread_mutex_lock(&private_display->lock);
 646
 647         *type = private_output->caps.type;
 648
 649         _pthread_mutex_unlock(&private_display->lock);
 650
 651         return ret;
 652 }
 653
 654 EXTERN tdm_error
 655 tdm_output_get_layer_count(tdm_output *output, int *count)
 656 {
 657         tdm_private_layer *private_layer = NULL;
 658
 659         OUTPUT_FUNC_ENTRY();
 660
 661         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 662
 663         _pthread_mutex_lock(&private_display->lock);
 664
 665         *count = 0;
 666         LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link)
 667         (*count)++;
 668         if (*count == 0) {
 669                 _pthread_mutex_unlock(&private_display->lock);
 670                 return TDM_ERROR_NONE;
 671         }
 672
 673         _pthread_mutex_unlock(&private_display->lock);
 674
 675         return ret;
 676 }
 677
 678
 679 EXTERN tdm_layer *
 680 tdm_output_get_layer(tdm_output *output, int index, tdm_error *error)
 681 {
 682         tdm_private_layer *private_layer = NULL;
 683         int i = 0;
 684
 685         OUTPUT_FUNC_ENTRY_ERROR();
 686
 687         _pthread_mutex_lock(&private_display->lock);
 688
 689         if (error)
 690                 *error = TDM_ERROR_NONE;
 691
 692         LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
 693                 if (i == index) {
 694                         _pthread_mutex_unlock(&private_display->lock);
 695                         return private_layer;
 696                 }
 697                 i++;
 698         }
 699
 700         _pthread_mutex_unlock(&private_display->lock);
 701
 702         return NULL;
 703 }
 704
 705 EXTERN tdm_error
 706 tdm_output_get_available_properties(tdm_output *output, const tdm_prop **props,
 707                                                                         int *count)
 708 {
 709         OUTPUT_FUNC_ENTRY();
 710
 711         TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
 712         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 713
 714         _pthread_mutex_lock(&private_display->lock);
 715
 716         *props = (const tdm_prop *)private_output->caps.props;
 717         *count = private_output->caps.prop_count;
 718
 719         _pthread_mutex_unlock(&private_display->lock);
 720
 721         return ret;
 722 }
 723
 724 EXTERN tdm_error
 725 tdm_output_get_available_modes(tdm_output *output,
 726                                                            const tdm_output_mode **modes, int *count)
 727 {
 728         OUTPUT_FUNC_ENTRY();
 729
 730         TDM_RETURN_VAL_IF_FAIL(modes != NULL, TDM_ERROR_INVALID_PARAMETER);
 731         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 732
 733         _pthread_mutex_lock(&private_display->lock);
 734
 735         *modes = (const tdm_output_mode *)private_output->caps.modes;
 736         *count = private_output->caps.mode_count;
 737
 738         _pthread_mutex_unlock(&private_display->lock);
 739
 740         return ret;
 741 }
 742
 743 EXTERN tdm_error
 744 tdm_output_get_available_size(tdm_output *output, int *min_w, int *min_h,
 745                                                           int *max_w, int *max_h, int *preferred_align)
 746 {
 747         OUTPUT_FUNC_ENTRY();
 748
 749         _pthread_mutex_lock(&private_display->lock);
 750
 751         if (min_w)
 752                 *min_w = private_output->caps.min_w;
 753         if (min_h)
 754                 *min_h = private_output->caps.min_h;
 755         if (max_w)
 756                 *max_w = private_output->caps.max_w;
 757         if (max_h)
 758                 *max_h = private_output->caps.max_h;
 759         if (preferred_align)
 760                 *preferred_align = private_output->caps.preferred_align;
 761
 762         _pthread_mutex_unlock(&private_display->lock);
 763
 764         return ret;
 765 }
 766
 767 EXTERN tdm_error
 768 tdm_output_get_physical_size(tdm_output *output, unsigned int *mmWidth,
 769                                                          unsigned int *mmHeight)
 770 {
 771         OUTPUT_FUNC_ENTRY();
 772
 773         _pthread_mutex_lock(&private_display->lock);
 774
 775         if (mmWidth)
 776                 *mmWidth = private_output->caps.mmWidth;
 777         if (mmHeight)
 778                 *mmHeight = private_output->caps.mmHeight;
 779
 780         _pthread_mutex_unlock(&private_display->lock);
 781
 782         return ret;
 783 }
 784
 785 EXTERN tdm_error
 786 tdm_output_get_subpixel(tdm_output *output, unsigned int *subpixel)
 787 {
 788         OUTPUT_FUNC_ENTRY();
 789         TDM_RETURN_VAL_IF_FAIL(subpixel != NULL, TDM_ERROR_INVALID_PARAMETER);
 790
 791         _pthread_mutex_lock(&private_display->lock);
 792
 793         *subpixel = private_output->caps.subpixel;
 794
 795         _pthread_mutex_unlock(&private_display->lock);
 796
 797         return ret;
 798 }
 799
 800 EXTERN tdm_error
 801 tdm_output_get_pipe(tdm_output *output, unsigned int *pipe)
 802 {
 803         OUTPUT_FUNC_ENTRY();
 804         TDM_RETURN_VAL_IF_FAIL(pipe != NULL, TDM_ERROR_INVALID_PARAMETER);
 805
 806         _pthread_mutex_lock(&private_display->lock);
 807
 808         *pipe = private_output->pipe;
 809
 810         _pthread_mutex_unlock(&private_display->lock);
 811
 812         return ret;
 813 }
 814
 815
 816 EXTERN tdm_error
 817 tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value)
 818 {
 819         tdm_func_output *func_output;
 820         OUTPUT_FUNC_ENTRY();
 821
 822         _pthread_mutex_lock(&private_display->lock);
 823
 824         func_output = &private_display->func_output;
 825
 826         if (!func_output->output_set_property) {
 827                 _pthread_mutex_unlock(&private_display->lock);
 828                 TDM_ERR("not implemented!!");
 829                 return TDM_ERROR_NOT_IMPLEMENTED;
 830         }
 831
 832         ret = func_output->output_set_property(private_output->output_backend, id,
 833                                                                                    value);
 834
 835         _pthread_mutex_unlock(&private_display->lock);
 836
 837         return ret;
 838 }
 839
 840 EXTERN tdm_error
 841 tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value)
 842 {
 843         tdm_func_output *func_output;
 844         OUTPUT_FUNC_ENTRY();
 845
 846         TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
 847
 848         _pthread_mutex_lock(&private_display->lock);
 849
 850         func_output = &private_display->func_output;
 851
 852         if (!func_output->output_get_property) {
 853                 _pthread_mutex_unlock(&private_display->lock);
 854                 TDM_ERR("not implemented!!");
 855                 return TDM_ERROR_NOT_IMPLEMENTED;
 856         }
 857
 858         ret = func_output->output_get_property(private_output->output_backend, id,
 859                                                                                    value);
 860
 861         _pthread_mutex_unlock(&private_display->lock);
 862
 863         return ret;
 864 }
 865
 866 INTERN void
 867 tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence,
 868                                          unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 869 {
 870         tdm_private_vblank_handler *vblank_handler = user_data;
 871         tdm_private_display *private_display;
 872
 873         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 874         TDM_RETURN_IF_FAIL(vblank_handler);
 875
 876         private_display = vblank_handler->private_output->private_display;
 877
 878         if (vblank_handler->owner_tid != syscall(SYS_gettid)) {
 879                 tdm_thread_cb_output_vblank output_vblank;
 880                 tdm_error ret;
 881
 882                 output_vblank.base.type = TDM_THREAD_CB_OUTPUT_VBLANK;
 883                 output_vblank.base.length = sizeof output_vblank;
 884                 output_vblank.output_stamp = vblank_handler->private_output->stamp;
 885                 output_vblank.sequence = sequence;
 886                 output_vblank.tv_sec = tv_sec;
 887                 output_vblank.tv_usec = tv_usec;
 888                 output_vblank.user_data = user_data;
 889
 890                 ret = tdm_thread_send_cb(private_display->private_loop, &output_vblank.base);
 891                 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 892
 893                 return;
 894         }
 895
 896         if (vblank_handler->owner_tid != syscall(SYS_gettid))
 897                 TDM_NEVER_GET_HERE();
 898
 899         if (vblank_handler->func) {
 900                 _pthread_mutex_unlock(&private_display->lock);
 901                 vblank_handler->func(vblank_handler->private_output, sequence,
 902                                                          tv_sec, tv_usec, vblank_handler->user_data);
 903                 _pthread_mutex_lock(&private_display->lock);
 904         }
 905
 906         LIST_DEL(&vblank_handler->link);
 907         free(vblank_handler);
 908 }
 909
 910 INTERN void
 911 tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
 912                                          unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 913 {
 914         tdm_private_commit_handler *commit_handler = user_data;
 915         tdm_private_display *private_display;
 916         tdm_private_output *private_output;
 917         tdm_private_layer *private_layer = NULL;
 918
 919         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 920         TDM_RETURN_IF_FAIL(commit_handler);
 921
 922         private_output = commit_handler->private_output;
 923         private_display = private_output->private_display;
 924
 925         if (commit_handler->owner_tid != syscall(SYS_gettid)) {
 926                 tdm_thread_cb_output_commit output_commit;
 927                 tdm_error ret;
 928
 929                 output_commit.base.type = TDM_THREAD_CB_OUTPUT_COMMIT;
 930                 output_commit.base.length = sizeof output_commit;
 931                 output_commit.output_stamp = private_output->stamp;
 932                 output_commit.sequence = sequence;
 933                 output_commit.tv_sec = tv_sec;
 934                 output_commit.tv_usec = tv_usec;
 935                 output_commit.user_data = user_data;
 936
 937                 ret = tdm_thread_send_cb(private_display->private_loop, &output_commit.base);
 938                 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 939
 940                 return;
 941         }
 942
 943         LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
 944                 if (!private_layer->waiting_buffer)
 945                         continue;
 946
 947                 if (private_layer->showing_buffer) {
 948                         _pthread_mutex_unlock(&private_display->lock);
 949                         tdm_buffer_unref_backend(private_layer->showing_buffer);
 950                         _pthread_mutex_lock(&private_display->lock);
 951
 952                         if (private_layer->buffer_queue) {
 953                                 tbm_surface_queue_release(private_layer->buffer_queue,
 954                                                                                   private_layer->showing_buffer);
 955                         }
 956                 }
 957
 958                 private_layer->showing_buffer = private_layer->waiting_buffer;
 959                 private_layer->waiting_buffer = NULL;
 960
 961                 if (tdm_debug_buffer)
 962                         TDM_INFO("layer(%p) waiting_buffer(%p) showing_buffer(%p)",
 963                                          private_layer, private_layer->waiting_buffer,
 964                                          private_layer->showing_buffer);
 965         }
 966
 967         if (commit_handler->func) {
 968                 _pthread_mutex_unlock(&private_display->lock);
 969                 commit_handler->func(private_output, sequence,
 970                                                          tv_sec, tv_usec, commit_handler->user_data);
 971                 _pthread_mutex_lock(&private_display->lock);
 972         }
 973
 974         LIST_DEL(&commit_handler->link);
 975         free(commit_handler);
 976 }
 977
 978 EXTERN tdm_error
 979 tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
 980                                            tdm_output_vblank_handler func, void *user_data)
 981 {
 982         tdm_func_output *func_output;
 983         tdm_private_vblank_handler *vblank_handler;
 984         OUTPUT_FUNC_ENTRY();
 985
 986         _pthread_mutex_lock(&private_display->lock);
 987
 988         if (private_output->current_dpms_value > TDM_OUTPUT_DPMS_ON) {
 989                 TDM_ERR("output(%d) dpms: %s", private_output->pipe,
 990                                 dpms_str(private_output->current_dpms_value));
 991                 _pthread_mutex_unlock(&private_display->lock);
 992                 return TDM_ERROR_BAD_REQUEST;
 993         }
 994
 995         func_output = &private_display->func_output;
 996
 997         if (!func_output->output_wait_vblank) {
 998                 _pthread_mutex_unlock(&private_display->lock);
 999                 TDM_ERR("not implemented!!");
1000                 return TDM_ERROR_NOT_IMPLEMENTED;
1001         }
1002
1003         vblank_handler = calloc(1, sizeof(tdm_private_vblank_handler));
1004         if (!vblank_handler) {
1005                 TDM_ERR("failed: alloc memory");
1006                 _pthread_mutex_unlock(&private_display->lock);
1007                 return TDM_ERROR_OUT_OF_MEMORY;
1008         }
1009
1010         LIST_ADD(&vblank_handler->link, &private_output->vblank_handler_list);
1011         vblank_handler->private_output = private_output;
1012         vblank_handler->func = func;
1013         vblank_handler->user_data = user_data;
1014         vblank_handler->owner_tid = syscall(SYS_gettid);
1015
1016         ret = func_output->output_wait_vblank(private_output->output_backend, interval,
1017                                                                                   sync, vblank_handler);
1018         if (ret != TDM_ERROR_NONE) {
1019                 _pthread_mutex_unlock(&private_display->lock);
1020                 return ret;
1021         }
1022
1023         if (!private_output->regist_vblank_cb) {
1024                 private_output->regist_vblank_cb = 1;
1025                 ret = func_output->output_set_vblank_handler(private_output->output_backend,
1026                                 tdm_output_cb_vblank);
1027         }
1028
1029         _pthread_mutex_unlock(&private_display->lock);
1030
1031         return ret;
1032 }
1033
1034 static tdm_error
1035 _tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func,
1036                                    void *user_data)
1037 {
1038         tdm_func_output *func_output;
1039         tdm_private_commit_handler *commit_handler;
1040         OUTPUT_FUNC_ENTRY();
1041
1042         func_output = &private_display->func_output;
1043
1044         if (!func_output->output_commit) {
1045                 TDM_ERR("not implemented!!");
1046                 return TDM_ERROR_NOT_IMPLEMENTED;
1047         }
1048
1049         commit_handler = calloc(1, sizeof(tdm_private_commit_handler));
1050         if (!commit_handler) {
1051                 TDM_ERR("failed: alloc memory");
1052                 return TDM_ERROR_OUT_OF_MEMORY;
1053         }
1054
1055         LIST_ADD(&commit_handler->link, &private_output->commit_handler_list);
1056         commit_handler->private_output = private_output;
1057         commit_handler->func = func;
1058         commit_handler->user_data = user_data;
1059         commit_handler->owner_tid = syscall(SYS_gettid);
1060
1061         if (!private_output->regist_commit_cb) {
1062                 private_output->regist_commit_cb = 1;
1063                 ret = func_output->output_set_commit_handler(private_output->output_backend,
1064                                 tdm_output_cb_commit);
1065         }
1066
1067         ret = func_output->output_commit(private_output->output_backend, sync,
1068                                                                          commit_handler);
1069         TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, ret);
1070
1071         return ret;
1072 }
1073
1074 EXTERN tdm_error
1075 tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func,
1076                                   void *user_data)
1077 {
1078         OUTPUT_FUNC_ENTRY();
1079
1080         _pthread_mutex_lock(&private_display->lock);
1081
1082         if (private_output->current_dpms_value > TDM_OUTPUT_DPMS_ON) {
1083                 TDM_ERR("output(%d) dpms: %s", private_output->pipe,
1084                                 dpms_str(private_output->current_dpms_value));
1085                 _pthread_mutex_unlock(&private_display->lock);
1086                 return TDM_ERROR_BAD_REQUEST;
1087         }
1088
1089         ret = _tdm_output_commit(output, sync, func, user_data);
1090
1091         _pthread_mutex_unlock(&private_display->lock);
1092
1093         return ret;
1094 }
1095
1096 EXTERN tdm_error
1097 tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode)
1098 {
1099         tdm_func_output *func_output;
1100         OUTPUT_FUNC_ENTRY();
1101
1102         TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
1103
1104         _pthread_mutex_lock(&private_display->lock);
1105
1106         func_output = &private_display->func_output;
1107
1108         if (!func_output->output_set_mode) {
1109                 _pthread_mutex_unlock(&private_display->lock);
1110                 TDM_ERR("not implemented!!");
1111                 return TDM_ERROR_NOT_IMPLEMENTED;
1112         }
1113
1114         ret = func_output->output_set_mode(private_output->output_backend, mode);
1115
1116         _pthread_mutex_unlock(&private_display->lock);
1117
1118         return ret;
1119 }
1120
1121 EXTERN tdm_error
1122 tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode)
1123 {
1124         tdm_func_output *func_output;
1125         OUTPUT_FUNC_ENTRY();
1126
1127         TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
1128
1129         _pthread_mutex_lock(&private_display->lock);
1130
1131         func_output = &private_display->func_output;
1132
1133         if (!func_output->output_get_mode) {
1134                 _pthread_mutex_unlock(&private_display->lock);
1135                 TDM_ERR("not implemented!!");
1136                 return TDM_ERROR_NOT_IMPLEMENTED;
1137         }
1138
1139         ret = func_output->output_get_mode(private_output->output_backend, mode);
1140
1141         _pthread_mutex_unlock(&private_display->lock);
1142
1143         return ret;
1144 }
1145
1146 EXTERN tdm_error
1147 tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
1148 {
1149         tdm_func_output *func_output;
1150         OUTPUT_FUNC_ENTRY();
1151
1152         if (dpms_value < TDM_OUTPUT_DPMS_ON)
1153                 dpms_value = TDM_OUTPUT_DPMS_ON;
1154         else if (dpms_value > TDM_OUTPUT_DPMS_OFF)
1155                 dpms_value = TDM_OUTPUT_DPMS_OFF;
1156
1157         _pthread_mutex_lock(&private_display->lock);
1158
1159         if (private_output->current_dpms_value == dpms_value) {
1160                 _pthread_mutex_unlock(&private_display->lock);
1161                 return TDM_ERROR_NONE;
1162         }
1163
1164         func_output = &private_display->func_output;
1165
1166         if (!func_output->output_set_dpms) {
1167                 _pthread_mutex_unlock(&private_display->lock);
1168                 private_output->current_dpms_value = dpms_value;
1169                 TDM_WRN("not implemented!!");
1170                 return TDM_ERROR_NONE;
1171         }
1172
1173         ret = func_output->output_set_dpms(private_output->output_backend, dpms_value);
1174         if (ret == TDM_ERROR_NONE) {
1175                 tdm_value value;
1176
1177                 private_output->current_dpms_value = dpms_value;
1178
1179                 value.u32 = dpms_value;
1180                 tdm_output_call_change_handler_internal(private_output,
1181                                                                                                 &private_output->change_handler_list_main,
1182                                                                                                 TDM_OUTPUT_CHANGE_DPMS,
1183                                                                                                 value);
1184         }
1185
1186         _pthread_mutex_unlock(&private_display->lock);
1187
1188         return ret;
1189 }
1190
1191 EXTERN tdm_error
1192 tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value)
1193 {
1194         tdm_func_output *func_output;
1195         OUTPUT_FUNC_ENTRY();
1196
1197         TDM_RETURN_VAL_IF_FAIL(dpms_value != NULL, TDM_ERROR_INVALID_PARAMETER);
1198
1199         _pthread_mutex_lock(&private_display->lock);
1200
1201         func_output = &private_display->func_output;
1202
1203         if (!func_output->output_get_dpms) {
1204                 *dpms_value = private_output->current_dpms_value;
1205                 _pthread_mutex_unlock(&private_display->lock);
1206                 TDM_WRN("not implemented!!");
1207                 return TDM_ERROR_NONE;
1208         }
1209
1210         ret = func_output->output_get_dpms(private_output->output_backend, dpms_value);
1211
1212         _pthread_mutex_unlock(&private_display->lock);
1213
1214         return ret;
1215 }
1216
1217 EXTERN tdm_capture *
1218 tdm_output_create_capture(tdm_output *output, tdm_error *error)
1219 {
1220         tdm_capture *capture = NULL;
1221
1222         OUTPUT_FUNC_ENTRY_ERROR();
1223
1224         _pthread_mutex_lock(&private_display->lock);
1225
1226         capture = (tdm_capture *)tdm_capture_create_output_internal(private_output, error);
1227
1228         _pthread_mutex_unlock(&private_display->lock);
1229
1230         return capture;
1231 }
1232
1233 INTERN void
1234 tdm_output_call_change_handler_internal(tdm_private_output *private_output,
1235                                                                                 struct list_head *change_handler_list,
1236                                                                                 tdm_output_change_type type,
1237                                                                                 tdm_value value)
1238 {
1239         tdm_private_display *private_display;
1240         tdm_private_change_handler *change_handler;
1241
1242         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
1243         TDM_RETURN_IF_FAIL(private_output);
1244
1245         private_display = private_output->private_display;
1246         if (!tdm_thread_in_display_thread(syscall(SYS_gettid))) {
1247                 if (type & TDM_OUTPUT_CHANGE_CONNECTION)
1248                         TDM_INFO("output(%d) changed: %s (%d)",
1249                                          private_output->pipe, status_str(value.u32), value.u32);
1250                 if (type & TDM_OUTPUT_CHANGE_DPMS)
1251                         TDM_INFO("output(%d) changed: dpms %s (%d)",
1252                                          private_output->pipe, dpms_str(value.u32), value.u32);
1253         }
1254
1255         if (LIST_IS_EMPTY(change_handler_list))
1256                 return;
1257
1258         LIST_FOR_EACH_ENTRY(change_handler, change_handler_list, link) {
1259                 if (change_handler->owner_tid != syscall(SYS_gettid))
1260                         TDM_NEVER_GET_HERE();
1261
1262                 _pthread_mutex_unlock(&private_display->lock);
1263                 change_handler->func(private_output, type,
1264                                                          value, change_handler->user_data);
1265                 _pthread_mutex_lock(&private_display->lock);
1266         }
1267 }
1268
1269 EXTERN tdm_error
1270 tdm_layer_get_capabilities(tdm_layer *layer, tdm_layer_capability *capabilities)
1271 {
1272         LAYER_FUNC_ENTRY();
1273
1274         TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
1275
1276         _pthread_mutex_lock(&private_display->lock);
1277
1278         *capabilities = private_layer->caps.capabilities;
1279
1280         _pthread_mutex_unlock(&private_display->lock);
1281
1282         return ret;
1283 }
1284
1285 EXTERN tdm_error
1286 tdm_layer_get_available_formats(tdm_layer *layer, const tbm_format **formats, int *count)
1287 {
1288         LAYER_FUNC_ENTRY();
1289
1290         TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
1291         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
1292
1293         _pthread_mutex_lock(&private_display->lock);
1294
1295         *formats = (const tbm_format *)private_layer->caps.formats;
1296         *count = private_layer->caps.format_count;
1297
1298         _pthread_mutex_unlock(&private_display->lock);
1299
1300         return ret;
1301 }
1302
1303 EXTERN tdm_error
1304 tdm_layer_get_available_properties(tdm_layer *layer, const tdm_prop **props, int *count)
1305 {
1306         LAYER_FUNC_ENTRY();
1307
1308         TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
1309         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
1310
1311         _pthread_mutex_lock(&private_display->lock);
1312
1313         *props = (const tdm_prop *)private_layer->caps.props;
1314         *count = private_layer->caps.prop_count;
1315
1316         _pthread_mutex_unlock(&private_display->lock);
1317
1318         return ret;
1319 }
1320
1321 EXTERN tdm_error
1322 tdm_layer_get_zpos(tdm_layer *layer, unsigned int *zpos)
1323 {
1324         LAYER_FUNC_ENTRY();
1325
1326         TDM_RETURN_VAL_IF_FAIL(zpos != NULL, TDM_ERROR_INVALID_PARAMETER);
1327
1328         _pthread_mutex_lock(&private_display->lock);
1329
1330         *zpos = private_layer->caps.zpos;
1331
1332         _pthread_mutex_unlock(&private_display->lock);
1333
1334         return ret;
1335 }
1336
1337 EXTERN tdm_error
1338 tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
1339 {
1340         tdm_func_layer *func_layer;
1341         LAYER_FUNC_ENTRY();
1342
1343         _pthread_mutex_lock(&private_display->lock);
1344
1345         func_layer = &private_display->func_layer;
1346
1347         if (!func_layer->layer_set_property) {
1348                 _pthread_mutex_unlock(&private_display->lock);
1349                 TDM_ERR("not implemented!!");
1350                 return TDM_ERROR_NOT_IMPLEMENTED;
1351         }
1352
1353         ret = func_layer->layer_set_property(private_layer->layer_backend, id, value);
1354
1355         _pthread_mutex_unlock(&private_display->lock);
1356
1357         return ret;
1358 }
1359
1360 EXTERN tdm_error
1361 tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
1362 {
1363         tdm_func_layer *func_layer;
1364         LAYER_FUNC_ENTRY();
1365
1366         TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
1367
1368         _pthread_mutex_lock(&private_display->lock);
1369
1370         func_layer = &private_display->func_layer;
1371
1372         if (!func_layer->layer_get_property) {
1373                 _pthread_mutex_unlock(&private_display->lock);
1374                 TDM_ERR("not implemented!!");
1375                 return TDM_ERROR_NOT_IMPLEMENTED;
1376         }
1377
1378         ret = func_layer->layer_get_property(private_layer->layer_backend, id, value);
1379
1380         _pthread_mutex_unlock(&private_display->lock);
1381
1382         return ret;
1383 }
1384
1385 EXTERN tdm_error
1386 tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
1387 {
1388         tdm_func_layer *func_layer;
1389         LAYER_FUNC_ENTRY();
1390
1391         TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
1392
1393         _pthread_mutex_lock(&private_display->lock);
1394
1395         func_layer = &private_display->func_layer;
1396
1397         private_layer->usable = 0;
1398
1399         if (!func_layer->layer_set_info) {
1400                 _pthread_mutex_unlock(&private_display->lock);
1401                 TDM_ERR("not implemented!!");
1402                 return TDM_ERROR_NOT_IMPLEMENTED;
1403         }
1404
1405         TDM_INFO("layer(%p) info: src(%dx%d %d,%d %dx%d %c%c%c%c) dst(%d,%d %dx%d) trans(%d)",
1406                          private_layer, info->src_config.size.h, info->src_config.size.v,
1407                          info->src_config.pos.x, info->src_config.pos.y,
1408                          info->src_config.pos.w, info->src_config.pos.h,
1409                          FOURCC_STR(info->src_config.format),
1410                          info->dst_pos.x, info->dst_pos.y,
1411                          info->dst_pos.w, info->dst_pos.h,
1412                          info->transform);
1413
1414         ret = func_layer->layer_set_info(private_layer->layer_backend, info);
1415         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
1416
1417         _pthread_mutex_unlock(&private_display->lock);
1418
1419         return ret;
1420 }
1421
1422 EXTERN tdm_error
1423 tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
1424 {
1425         tdm_func_layer *func_layer;
1426         LAYER_FUNC_ENTRY();
1427
1428         TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
1429
1430         _pthread_mutex_lock(&private_display->lock);
1431
1432         func_layer = &private_display->func_layer;
1433
1434         if (!func_layer->layer_get_info) {
1435                 _pthread_mutex_unlock(&private_display->lock);
1436                 TDM_ERR("not implemented!!");
1437                 return TDM_ERROR_NOT_IMPLEMENTED;
1438         }
1439
1440         ret = func_layer->layer_get_info(private_layer->layer_backend, info);
1441
1442         _pthread_mutex_unlock(&private_display->lock);
1443
1444         return ret;
1445 }
1446
1447 static void
1448 _tdm_layer_dump_buffer(tdm_layer *layer, tbm_surface_h buffer)
1449 {
1450         tdm_private_layer *private_layer = (tdm_private_layer*)layer;
1451         tdm_private_output *private_output = private_layer->private_output;
1452         unsigned int pipe;
1453         int zpos;
1454         char fname[PATH_MAX];
1455
1456         pipe = private_output->pipe;
1457         zpos = private_layer->caps.zpos;
1458
1459         snprintf(fname, sizeof(fname), "tdm_%d_lyr_%d", pipe, zpos);
1460
1461         tbm_surface_internal_dump_buffer(buffer, fname);
1462         TDM_DBG("%s dump excute", fname);
1463
1464         return;
1465 }
1466
1467 EXTERN tdm_error
1468 tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
1469 {
1470         tdm_func_layer *func_layer;
1471
1472         LAYER_FUNC_ENTRY();
1473
1474         TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER);
1475
1476         _pthread_mutex_lock(&private_display->lock);
1477
1478         func_layer = &private_display->func_layer;
1479
1480         private_layer->usable = 0;
1481
1482         if (!func_layer->layer_set_buffer) {
1483                 _pthread_mutex_unlock(&private_display->lock);
1484                 TDM_ERR("not implemented!!");
1485                 return TDM_ERROR_NOT_IMPLEMENTED;
1486         }
1487
1488         ret = func_layer->layer_set_buffer(private_layer->layer_backend, buffer);
1489         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
1490
1491         /* dump buffer */
1492         if (tdm_dump_enable)
1493                 _tdm_layer_dump_buffer(layer, buffer);
1494
1495         if (ret == TDM_ERROR_NONE) {
1496                 /* FIXME: should save to pending_buffer first. And after committing
1497                  * successfully, need to move to waiting_buffer.
1498                  */
1499                 if (private_layer->waiting_buffer) {
1500                         _pthread_mutex_unlock(&private_display->lock);
1501                         tdm_buffer_unref_backend(private_layer->waiting_buffer);
1502                         _pthread_mutex_lock(&private_display->lock);
1503                 }
1504
1505                 private_layer->waiting_buffer = tdm_buffer_ref_backend(buffer);
1506                 if (tdm_debug_buffer)
1507                         TDM_INFO("layer(%p) waiting_buffer(%p)",
1508                                          private_layer, private_layer->waiting_buffer);
1509         }
1510
1511         _pthread_mutex_unlock(&private_display->lock);
1512
1513         return ret;
1514 }
1515
1516 EXTERN tdm_error
1517 tdm_layer_unset_buffer(tdm_layer *layer)
1518 {
1519         tdm_func_layer *func_layer;
1520         LAYER_FUNC_ENTRY();
1521
1522         _pthread_mutex_lock(&private_display->lock);
1523
1524         func_layer = &private_display->func_layer;
1525
1526         if (private_layer->waiting_buffer) {
1527                 _pthread_mutex_unlock(&private_display->lock);
1528                 tdm_buffer_unref_backend(private_layer->waiting_buffer);
1529                 _pthread_mutex_lock(&private_display->lock);
1530                 private_layer->waiting_buffer = NULL;
1531
1532                 if (tdm_debug_buffer)
1533                         TDM_INFO("layer(%p) waiting_buffer(%p)",
1534                                          private_layer, private_layer->waiting_buffer);
1535         }
1536
1537         if (private_layer->showing_buffer) {
1538                 _pthread_mutex_unlock(&private_display->lock);
1539                 tdm_buffer_unref_backend(private_layer->showing_buffer);
1540                 _pthread_mutex_lock(&private_display->lock);
1541                 private_layer->showing_buffer = NULL;
1542
1543                 if (tdm_debug_buffer)
1544                         TDM_INFO("layer(%p) showing_buffer(%p)",
1545                                          private_layer, private_layer->showing_buffer);
1546         }
1547
1548         private_layer->usable = 1;
1549
1550         if (!func_layer->layer_unset_buffer) {
1551                 _pthread_mutex_unlock(&private_display->lock);
1552                 TDM_ERR("not implemented!!");
1553                 return TDM_ERROR_NOT_IMPLEMENTED;
1554         }
1555
1556         ret = func_layer->layer_unset_buffer(private_layer->layer_backend);
1557         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
1558
1559         _pthread_mutex_unlock(&private_display->lock);
1560
1561         return ret;
1562 }
1563
1564 EXTERN tbm_surface_h
1565 tdm_layer_get_displaying_buffer(tdm_layer *layer, tdm_error *error)
1566 {
1567         tbm_surface_h buffer;
1568         LAYER_FUNC_ENTRY_ERROR();
1569
1570         _pthread_mutex_lock(&private_display->lock);
1571
1572         if (error)
1573                 *error = TDM_ERROR_NONE;
1574
1575         if (private_layer->showing_buffer) {
1576                 buffer = private_layer->showing_buffer;
1577         } else {
1578                 if (error)
1579                         *error = TDM_ERROR_OPERATION_FAILED;
1580                 _pthread_mutex_unlock(&private_display->lock);
1581                 TDM_ERR("layer(%p) showing_buffer is null", private_layer);
1582                 return NULL;
1583         }
1584         _pthread_mutex_unlock(&private_display->lock);
1585
1586         return buffer;
1587 }
1588
1589 static void
1590 _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
1591 {
1592         TDM_RETURN_IF_FAIL(data != NULL);
1593         tdm_layer *layer = data;
1594         tdm_func_layer *func_layer;
1595         tbm_surface_h surface = NULL;
1596         LAYER_FUNC_ENTRY_VOID_RETURN();
1597
1598         _pthread_mutex_lock(&private_display->lock);
1599
1600         func_layer = &private_display->func_layer;
1601         if (!func_layer->layer_set_buffer) {
1602                 _pthread_mutex_unlock(&private_display->lock);
1603                 return;
1604         }
1605
1606         if (TBM_SURFACE_QUEUE_ERROR_NONE != tbm_surface_queue_acquire(private_layer->buffer_queue, &surface) ||
1607                 surface == NULL) {
1608                 TDM_ERR("layer(%p) tbm_surface_queue_acquire() failed surface:%p",
1609                                 private_layer, surface);
1610                 _pthread_mutex_unlock(&private_display->lock);
1611                 return;
1612         }
1613
1614         ret = func_layer->layer_set_buffer(private_layer->layer_backend, surface);
1615         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
1616
1617         if (ret == TDM_ERROR_NONE) {
1618                 if (private_layer->waiting_buffer) {
1619                         _pthread_mutex_unlock(&private_display->lock);
1620                         tdm_buffer_unref_backend(private_layer->waiting_buffer);
1621                         tbm_surface_queue_release(private_layer->buffer_queue,
1622                                                                           private_layer->waiting_buffer);
1623                         _pthread_mutex_lock(&private_display->lock);
1624                 }
1625
1626                 private_layer->waiting_buffer = tdm_buffer_ref_backend(surface);
1627
1628                 if (tdm_debug_buffer)
1629                         TDM_INFO("layer(%p) waiting_buffer(%p)",
1630                                          private_layer, private_layer->waiting_buffer);
1631
1632                 ret = _tdm_output_commit(private_layer->private_output, 0, NULL, NULL);
1633                 if (ret != TDM_ERROR_NONE)
1634                         TDM_ERR("layer(%p) _tdm_output_commit() is fail", private_layer);
1635         }
1636
1637         _pthread_mutex_unlock(&private_display->lock);
1638 }
1639
1640 static void
1641 _tbm_layer_queue_destroy_cb(tbm_surface_queue_h surface_queue, void *data)
1642 {
1643         TDM_RETURN_IF_FAIL(data != NULL);
1644         tdm_layer *layer = data;
1645         LAYER_FUNC_ENTRY_VOID_RETURN();
1646         TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
1647
1648         _pthread_mutex_lock(&private_display->lock);
1649
1650         if (private_layer->waiting_buffer) {
1651                 _pthread_mutex_unlock(&private_display->lock);
1652                 tdm_buffer_unref_backend(private_layer->waiting_buffer);
1653                 tbm_surface_queue_release(private_layer->buffer_queue,
1654                                                                   private_layer->waiting_buffer);
1655                 _pthread_mutex_lock(&private_display->lock);
1656         }
1657
1658         private_layer->buffer_queue = NULL;
1659
1660         _pthread_mutex_unlock(&private_display->lock);
1661 }
1662
1663 EXTERN tdm_error
1664 tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
1665 {
1666         tdm_func_layer *func_layer;
1667         LAYER_FUNC_ENTRY();
1668
1669         TDM_RETURN_VAL_IF_FAIL(buffer_queue != NULL, TDM_ERROR_INVALID_PARAMETER);
1670
1671         _pthread_mutex_lock(&private_display->lock);
1672
1673         func_layer = &private_display->func_layer;
1674
1675         private_layer->usable = 0;
1676
1677         if (!func_layer->layer_set_buffer) {
1678                 _pthread_mutex_unlock(&private_display->lock);
1679                 TDM_ERR("not implemented!!");
1680                 return TDM_ERROR_NOT_IMPLEMENTED;
1681         }
1682
1683         if (buffer_queue == private_layer->buffer_queue) {
1684                 _pthread_mutex_unlock(&private_display->lock);
1685                 return TDM_ERROR_NONE;
1686         }
1687
1688         if (private_layer->waiting_buffer) {
1689                 _pthread_mutex_unlock(&private_display->lock);
1690                 tdm_buffer_unref_backend(private_layer->waiting_buffer);
1691                 tbm_surface_queue_release(private_layer->buffer_queue,
1692                                                                   private_layer->waiting_buffer);
1693                 private_layer->waiting_buffer = NULL;
1694                 _pthread_mutex_lock(&private_display->lock);
1695
1696                 if (tdm_debug_buffer)
1697                         TDM_INFO("layer(%p) waiting_buffer(%p)",
1698                                          private_layer, private_layer->waiting_buffer);
1699         }
1700
1701         private_layer->buffer_queue = buffer_queue;
1702         tbm_surface_queue_add_acquirable_cb(private_layer->buffer_queue,
1703                                                                                 _tbm_layer_queue_acquirable_cb,
1704                                                                                 layer);
1705         tbm_surface_queue_add_destroy_cb(private_layer->buffer_queue,
1706                                                                          _tbm_layer_queue_destroy_cb,
1707                                                                          layer);
1708         _pthread_mutex_unlock(&private_display->lock);
1709
1710         return ret;
1711 }
1712
1713 EXTERN tdm_error
1714 tdm_layer_unset_buffer_queue(tdm_layer *layer)
1715 {
1716         tdm_func_layer *func_layer;
1717         LAYER_FUNC_ENTRY();
1718
1719         _pthread_mutex_lock(&private_display->lock);
1720
1721         func_layer = &private_display->func_layer;
1722
1723         if (private_layer->waiting_buffer) {
1724                 _pthread_mutex_unlock(&private_display->lock);
1725                 tdm_buffer_unref_backend(private_layer->waiting_buffer);
1726                 tbm_surface_queue_release(private_layer->buffer_queue,
1727                                                                   private_layer->waiting_buffer);
1728                 private_layer->waiting_buffer = NULL;
1729                 _pthread_mutex_lock(&private_display->lock);
1730
1731                 if (tdm_debug_buffer)
1732                         TDM_INFO("layer(%p) waiting_buffer(%p)",
1733                                          private_layer, private_layer->waiting_buffer);
1734         }
1735
1736         if (private_layer->showing_buffer) {
1737                 _pthread_mutex_unlock(&private_display->lock);
1738                 tdm_buffer_unref_backend(private_layer->showing_buffer);
1739                 tbm_surface_queue_release(private_layer->buffer_queue,
1740                                                                   private_layer->showing_buffer);
1741                 _pthread_mutex_lock(&private_display->lock);
1742                 private_layer->showing_buffer = NULL;
1743
1744                 if (tdm_debug_buffer)
1745                         TDM_INFO("layer(%p) showing_buffer(%p)",
1746                                          private_layer, private_layer->showing_buffer);
1747         }
1748
1749         tbm_surface_queue_remove_acquirable_cb(private_layer->buffer_queue, _tbm_layer_queue_acquirable_cb, layer);
1750         tbm_surface_queue_remove_destroy_cb(private_layer->buffer_queue, _tbm_layer_queue_destroy_cb, layer);
1751         private_layer->buffer_queue = NULL;
1752         private_layer->usable = 1;
1753
1754         if (!func_layer->layer_unset_buffer) {
1755                 _pthread_mutex_unlock(&private_display->lock);
1756                 TDM_ERR("not implemented!!");
1757                 return TDM_ERROR_NOT_IMPLEMENTED;
1758         }
1759
1760         ret = func_layer->layer_unset_buffer(private_layer->layer_backend);
1761
1762         _pthread_mutex_unlock(&private_display->lock);
1763
1764         return ret;
1765 }
1766
1767 EXTERN tdm_error
1768 tdm_layer_is_usable(tdm_layer *layer, unsigned int *usable)
1769 {
1770         LAYER_FUNC_ENTRY();
1771
1772         TDM_RETURN_VAL_IF_FAIL(usable != NULL, TDM_ERROR_INVALID_PARAMETER);
1773
1774         _pthread_mutex_lock(&private_display->lock);
1775
1776         *usable = private_layer->usable;
1777
1778         _pthread_mutex_unlock(&private_display->lock);
1779
1780         return ret;
1781 }
1782
1783 EXTERN tdm_error
1784 tdm_layer_set_video_pos(tdm_layer *layer, int zpos)
1785 {
1786         tdm_func_layer *func_layer;
1787         LAYER_FUNC_ENTRY();
1788
1789         _pthread_mutex_lock(&private_display->lock);
1790
1791         func_layer = &private_display->func_layer;
1792
1793         if (!(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)) {
1794                 TDM_ERR("layer(%p) is not video layer", private_layer);
1795                 _pthread_mutex_unlock(&private_display->lock);
1796                 return TDM_ERROR_INVALID_PARAMETER;
1797         }
1798
1799         if (!func_layer->layer_set_video_pos) {
1800                 _pthread_mutex_unlock(&private_display->lock);
1801                 TDM_ERR("not implemented!!");
1802                 return TDM_ERROR_NOT_IMPLEMENTED;
1803         }
1804
1805         ret = func_layer->layer_set_video_pos(private_layer->layer_backend, zpos);
1806
1807         _pthread_mutex_unlock(&private_display->lock);
1808
1809         return ret;
1810 }
1811
1812 EXTERN tdm_capture *
1813 tdm_layer_create_capture(tdm_layer *layer, tdm_error *error)
1814 {
1815         tdm_capture *capture = NULL;
1816
1817         LAYER_FUNC_ENTRY_ERROR();
1818
1819         _pthread_mutex_lock(&private_display->lock);
1820
1821         capture = (tdm_capture *)tdm_capture_create_layer_internal(private_layer, error);
1822
1823         _pthread_mutex_unlock(&private_display->lock);
1824
1825         return capture;
1826 }