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