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_physical_size(tdm_output *output, unsigned int *mmWidth,
 718                                                          unsigned int *mmHeight)
 719 {
 720         OUTPUT_FUNC_ENTRY();
 721
 722         _pthread_mutex_lock(&private_display->lock);
 723
 724         if (mmWidth)
 725                 *mmWidth = private_output->caps.mmWidth;
 726         if (mmHeight)
 727                 *mmHeight = private_output->caps.mmHeight;
 728
 729         _pthread_mutex_unlock(&private_display->lock);
 730
 731         return ret;
 732 }
 733
 734 EXTERN tdm_error
 735 tdm_output_get_subpixel(tdm_output *output, unsigned int *subpixel)
 736 {
 737         OUTPUT_FUNC_ENTRY();
 738         TDM_RETURN_VAL_IF_FAIL(subpixel != NULL, TDM_ERROR_INVALID_PARAMETER);
 739
 740         _pthread_mutex_lock(&private_display->lock);
 741
 742         *subpixel = private_output->caps.subpixel;
 743
 744         _pthread_mutex_unlock(&private_display->lock);
 745
 746         return ret;
 747 }
 748
 749 EXTERN tdm_error
 750 tdm_output_get_pipe(tdm_output *output, unsigned int *pipe)
 751 {
 752         OUTPUT_FUNC_ENTRY();
 753         TDM_RETURN_VAL_IF_FAIL(pipe != NULL, TDM_ERROR_INVALID_PARAMETER);
 754
 755         _pthread_mutex_lock(&private_display->lock);
 756
 757         *pipe = private_output->pipe;
 758
 759         _pthread_mutex_unlock(&private_display->lock);
 760
 761         return ret;
 762 }
 763
 764 EXTERN tdm_error
 765 tdm_output_get_primary_index(tdm_output *output, int *index)
 766 {
 767         tdm_private_layer *private_layer = NULL;
 768
 769         OUTPUT_FUNC_ENTRY();
 770         TDM_RETURN_VAL_IF_FAIL(index != NULL, TDM_ERROR_INVALID_PARAMETER);
 771
 772         _pthread_mutex_lock(&private_display->lock);
 773
 774         LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
 775                 if (private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_PRIMARY) {
 776                         *index = private_layer->index;
 777                         break;
 778                 }
 779         }
 780
 781         _pthread_mutex_unlock(&private_display->lock);
 782
 783         return ret;
 784 }
 785
 786 EXTERN tdm_error
 787 tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value)
 788 {
 789         tdm_func_output *func_output;
 790         OUTPUT_FUNC_ENTRY();
 791
 792         _pthread_mutex_lock(&private_display->lock);
 793
 794         func_output = &private_display->func_output;
 795
 796         if (!func_output->output_set_property) {
 797                 _pthread_mutex_unlock(&private_display->lock);
 798                 TDM_ERR("not implemented!!");
 799                 return TDM_ERROR_NOT_IMPLEMENTED;
 800         }
 801
 802         ret = func_output->output_set_property(private_output->output_backend, id,
 803                                                                                    value);
 804
 805         _pthread_mutex_unlock(&private_display->lock);
 806
 807         return ret;
 808 }
 809
 810 EXTERN tdm_error
 811 tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value)
 812 {
 813         tdm_func_output *func_output;
 814         OUTPUT_FUNC_ENTRY();
 815
 816         TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
 817
 818         _pthread_mutex_lock(&private_display->lock);
 819
 820         func_output = &private_display->func_output;
 821
 822         if (!func_output->output_get_property) {
 823                 _pthread_mutex_unlock(&private_display->lock);
 824                 TDM_ERR("not implemented!!");
 825                 return TDM_ERROR_NOT_IMPLEMENTED;
 826         }
 827
 828         ret = func_output->output_get_property(private_output->output_backend, id,
 829                                                                                    value);
 830
 831         _pthread_mutex_unlock(&private_display->lock);
 832
 833         return ret;
 834 }
 835
 836 INTERN void
 837 tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence,
 838                                          unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 839 {
 840         tdm_private_vblank_handler *vblank_handler = user_data;
 841         tdm_private_display *private_display;
 842
 843         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 844         TDM_RETURN_IF_FAIL(vblank_handler);
 845
 846         private_display = vblank_handler->private_output->private_display;
 847
 848         if (vblank_handler->owner_tid != syscall(SYS_gettid)) {
 849                 tdm_thread_cb_output_vblank output_vblank;
 850                 tdm_error ret;
 851
 852                 output_vblank.base.type = TDM_THREAD_CB_OUTPUT_VBLANK;
 853                 output_vblank.base.length = sizeof output_vblank;
 854                 output_vblank.output_stamp = vblank_handler->private_output->stamp;
 855                 output_vblank.sequence = sequence;
 856                 output_vblank.tv_sec = tv_sec;
 857                 output_vblank.tv_usec = tv_usec;
 858                 output_vblank.user_data = user_data;
 859
 860                 ret = tdm_thread_send_cb(private_display->private_loop, &output_vblank.base);
 861                 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 862
 863                 return;
 864         }
 865
 866         if (vblank_handler->owner_tid != syscall(SYS_gettid))
 867                 TDM_NEVER_GET_HERE();
 868
 869         if (vblank_handler->func) {
 870                 _pthread_mutex_unlock(&private_display->lock);
 871                 vblank_handler->func(vblank_handler->private_output, sequence,
 872                                                          tv_sec, tv_usec, vblank_handler->user_data);
 873                 _pthread_mutex_lock(&private_display->lock);
 874         }
 875
 876         LIST_DEL(&vblank_handler->link);
 877         free(vblank_handler);
 878 }
 879
 880 INTERN void
 881 tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
 882                                          unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 883 {
 884         tdm_private_commit_handler *commit_handler = user_data;
 885         tdm_private_display *private_display;
 886         tdm_private_output *private_output;
 887         tdm_private_layer *private_layer = NULL;
 888
 889         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 890         TDM_RETURN_IF_FAIL(commit_handler);
 891
 892         private_output = commit_handler->private_output;
 893         private_display = private_output->private_display;
 894
 895         if (commit_handler->owner_tid != syscall(SYS_gettid)) {
 896                 tdm_thread_cb_output_commit output_commit;
 897                 tdm_error ret;
 898
 899                 output_commit.base.type = TDM_THREAD_CB_OUTPUT_COMMIT;
 900                 output_commit.base.length = sizeof output_commit;
 901                 output_commit.output_stamp = private_output->stamp;
 902                 output_commit.sequence = sequence;
 903                 output_commit.tv_sec = tv_sec;
 904                 output_commit.tv_usec = tv_usec;
 905                 output_commit.user_data = user_data;
 906
 907                 ret = tdm_thread_send_cb(private_display->private_loop, &output_commit.base);
 908                 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 909
 910                 return;
 911         }
 912
 913         LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
 914                 if (!private_layer->waiting_buffer)
 915                         continue;
 916
 917                 if (private_layer->showing_buffer) {
 918                         _pthread_mutex_unlock(&private_display->lock);
 919                         tdm_buffer_unref_backend(private_layer->showing_buffer);
 920                         _pthread_mutex_lock(&private_display->lock);
 921
 922                         if (private_layer->buffer_queue) {
 923                                 _pthread_mutex_unlock(&private_display->lock);
 924                                 tbm_surface_queue_release(private_layer->buffer_queue,
 925                                                                                   private_layer->showing_buffer);
 926                                 _pthread_mutex_lock(&private_display->lock);
 927                         }
 928                 }
 929
 930                 private_layer->showing_buffer = private_layer->waiting_buffer;
 931                 private_layer->waiting_buffer = NULL;
 932
 933                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
 934                         TDM_INFO("layer(%p) waiting_buffer(%p) showing_buffer(%p)",
 935                                          private_layer, private_layer->waiting_buffer,
 936                                          private_layer->showing_buffer);
 937         }
 938
 939         if (commit_handler->func) {
 940                 _pthread_mutex_unlock(&private_display->lock);
 941                 commit_handler->func(private_output, sequence,
 942                                                          tv_sec, tv_usec, commit_handler->user_data);
 943                 _pthread_mutex_lock(&private_display->lock);
 944         }
 945
 946         LIST_DEL(&commit_handler->link);
 947         free(commit_handler);
 948 }
 949
 950 EXTERN tdm_error
 951 tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
 952                                            tdm_output_vblank_handler func, void *user_data)
 953 {
 954         tdm_func_output *func_output;
 955         tdm_private_vblank_handler *vblank_handler;
 956         OUTPUT_FUNC_ENTRY();
 957
 958         _pthread_mutex_lock(&private_display->lock);
 959
 960         if (private_output->current_dpms_value > TDM_OUTPUT_DPMS_ON) {
 961                 TDM_WRN("output(%d) dpms: %s", private_output->pipe,
 962                                 tdm_dpms_str(private_output->current_dpms_value));
 963                 _pthread_mutex_unlock(&private_display->lock);
 964                 return TDM_ERROR_DPMS_OFF;
 965         }
 966
 967         func_output = &private_display->func_output;
 968
 969         if (!func_output->output_wait_vblank) {
 970                 _pthread_mutex_unlock(&private_display->lock);
 971                 TDM_ERR("not implemented!!");
 972                 return TDM_ERROR_NOT_IMPLEMENTED;
 973         }
 974
 975         vblank_handler = calloc(1, sizeof(tdm_private_vblank_handler));
 976         if (!vblank_handler) {
 977                 TDM_ERR("failed: alloc memory");
 978                 _pthread_mutex_unlock(&private_display->lock);
 979                 return TDM_ERROR_OUT_OF_MEMORY;
 980         }
 981
 982         LIST_ADD(&vblank_handler->link, &private_output->vblank_handler_list);
 983         vblank_handler->private_output = private_output;
 984         vblank_handler->func = func;
 985         vblank_handler->user_data = user_data;
 986         vblank_handler->owner_tid = syscall(SYS_gettid);
 987
 988         ret = func_output->output_wait_vblank(private_output->output_backend, interval,
 989                                                                                   sync, vblank_handler);
 990         if (ret != TDM_ERROR_NONE) {
 991                 _pthread_mutex_unlock(&private_display->lock);
 992                 return ret;
 993         }
 994
 995         if (!private_output->regist_vblank_cb) {
 996                 private_output->regist_vblank_cb = 1;
 997                 ret = func_output->output_set_vblank_handler(private_output->output_backend,
 998                                 tdm_output_cb_vblank);
 999         }
1000
1001         _pthread_mutex_unlock(&private_display->lock);
1002
1003         return ret;
1004 }
1005
1006 static tdm_error
1007 _tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func,
1008                                    void *user_data)
1009 {
1010         tdm_func_output *func_output;
1011         tdm_private_commit_handler *commit_handler;
1012         OUTPUT_FUNC_ENTRY();
1013
1014         func_output = &private_display->func_output;
1015
1016         if (!func_output->output_commit) {
1017                 TDM_ERR("not implemented!!");
1018                 return TDM_ERROR_NOT_IMPLEMENTED;
1019         }
1020
1021         commit_handler = calloc(1, sizeof(tdm_private_commit_handler));
1022         if (!commit_handler) {
1023                 TDM_ERR("failed: alloc memory");
1024                 return TDM_ERROR_OUT_OF_MEMORY;
1025         }
1026
1027         LIST_ADD(&commit_handler->link, &private_output->commit_handler_list);
1028         commit_handler->private_output = private_output;
1029         commit_handler->func = func;
1030         commit_handler->user_data = user_data;
1031         commit_handler->owner_tid = syscall(SYS_gettid);
1032
1033         if (!private_output->regist_commit_cb) {
1034                 private_output->regist_commit_cb = 1;
1035                 ret = func_output->output_set_commit_handler(private_output->output_backend,
1036                                 tdm_output_cb_commit);
1037         }
1038
1039         ret = func_output->output_commit(private_output->output_backend, sync,
1040                                                                          commit_handler);
1041         TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, ret);
1042
1043         return ret;
1044 }
1045
1046 EXTERN tdm_error
1047 tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func,
1048                                   void *user_data)
1049 {
1050         OUTPUT_FUNC_ENTRY();
1051
1052         _pthread_mutex_lock(&private_display->lock);
1053
1054         if (private_output->current_dpms_value > TDM_OUTPUT_DPMS_ON) {
1055                 TDM_ERR("output(%d) dpms: %s", private_output->pipe,
1056                                 tdm_dpms_str(private_output->current_dpms_value));
1057                 _pthread_mutex_unlock(&private_display->lock);
1058                 return TDM_ERROR_DPMS_OFF;
1059         }
1060
1061         ret = _tdm_output_commit(output, sync, func, user_data);
1062
1063         _pthread_mutex_unlock(&private_display->lock);
1064
1065         return ret;
1066 }
1067
1068 EXTERN tdm_error
1069 tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode)
1070 {
1071         tdm_func_output *func_output;
1072         OUTPUT_FUNC_ENTRY();
1073
1074         TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
1075
1076         _pthread_mutex_lock(&private_display->lock);
1077
1078         func_output = &private_display->func_output;
1079
1080         if (!func_output->output_set_mode) {
1081                 _pthread_mutex_unlock(&private_display->lock);
1082                 TDM_ERR("not implemented!!");
1083                 return TDM_ERROR_NOT_IMPLEMENTED;
1084         }
1085
1086         ret = func_output->output_set_mode(private_output->output_backend, mode);
1087
1088         _pthread_mutex_unlock(&private_display->lock);
1089
1090         return ret;
1091 }
1092
1093 EXTERN tdm_error
1094 tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode)
1095 {
1096         tdm_func_output *func_output;
1097         OUTPUT_FUNC_ENTRY();
1098
1099         TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
1100
1101         _pthread_mutex_lock(&private_display->lock);
1102
1103         func_output = &private_display->func_output;
1104
1105         if (!func_output->output_get_mode) {
1106                 _pthread_mutex_unlock(&private_display->lock);
1107                 TDM_ERR("not implemented!!");
1108                 return TDM_ERROR_NOT_IMPLEMENTED;
1109         }
1110
1111         ret = func_output->output_get_mode(private_output->output_backend, mode);
1112
1113         _pthread_mutex_unlock(&private_display->lock);
1114
1115         return ret;
1116 }
1117
1118 static tdm_error
1119 _tdm_output_dpms_changed_timeout(void *user_data)
1120 {
1121         tdm_private_output *private_output = user_data;
1122         tdm_value value;
1123
1124         value.u32 = private_output->current_dpms_value;
1125         tdm_output_call_change_handler_internal(private_output,
1126                                                                                         &private_output->change_handler_list_sub,
1127                                                                                         TDM_OUTPUT_CHANGE_DPMS,
1128                                                                                         value, 0);
1129
1130         return TDM_ERROR_NONE;
1131 }
1132
1133 EXTERN tdm_error
1134 tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
1135 {
1136         tdm_func_output *func_output;
1137         OUTPUT_FUNC_ENTRY();
1138
1139         if (dpms_value > TDM_OUTPUT_DPMS_OFF)
1140                 dpms_value = TDM_OUTPUT_DPMS_OFF;
1141
1142         _pthread_mutex_lock(&private_display->lock);
1143
1144         if (private_output->current_dpms_value == dpms_value) {
1145                 _pthread_mutex_unlock(&private_display->lock);
1146                 return TDM_ERROR_NONE;
1147         }
1148
1149         if (!private_output->dpms_changed_timer) {
1150                 private_output->dpms_changed_timer =
1151                         tdm_event_loop_add_timer_handler(private_output->private_display,
1152                                 _tdm_output_dpms_changed_timeout, private_output, NULL);
1153                 if (!private_output->dpms_changed_timer) {
1154                         TDM_ERR("can't create dpms timer!!");
1155                         _pthread_mutex_unlock(&private_display->lock);
1156                         return TDM_ERROR_OUT_OF_MEMORY;
1157                 }
1158         }
1159
1160         func_output = &private_display->func_output;
1161
1162         if (!func_output->output_set_dpms) {
1163                 _pthread_mutex_unlock(&private_display->lock);
1164                 private_output->current_dpms_value = dpms_value;
1165                 TDM_WRN("not implemented!!");
1166                 return TDM_ERROR_NONE;
1167         }
1168
1169         ret = func_output->output_set_dpms(private_output->output_backend, dpms_value);
1170         if (ret == TDM_ERROR_NONE) {
1171                 tdm_value value;
1172
1173                 private_output->current_dpms_value = dpms_value;
1174
1175                 value.u32 = dpms_value;
1176                 tdm_output_call_change_handler_internal(private_output,
1177                                                                                                 &private_output->change_handler_list_main,
1178                                                                                                 TDM_OUTPUT_CHANGE_DPMS,
1179                                                                                                 value, 0);
1180
1181                 if (!LIST_IS_EMPTY(&private_output->change_handler_list_sub)) {
1182                         ret = tdm_event_loop_source_timer_update(private_output->dpms_changed_timer, 1);
1183                         if (ret != TDM_ERROR_NONE)
1184                                 TDM_NEVER_GET_HERE();
1185                 }
1186         }
1187
1188         _pthread_mutex_unlock(&private_display->lock);
1189
1190         return ret;
1191 }
1192
1193 EXTERN tdm_error
1194 tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value)
1195 {
1196         tdm_func_output *func_output;
1197         OUTPUT_FUNC_ENTRY();
1198
1199         TDM_RETURN_VAL_IF_FAIL(dpms_value != NULL, TDM_ERROR_INVALID_PARAMETER);
1200
1201         _pthread_mutex_lock(&private_display->lock);
1202
1203         func_output = &private_display->func_output;
1204
1205         if (!func_output->output_get_dpms) {
1206                 *dpms_value = private_output->current_dpms_value;
1207                 _pthread_mutex_unlock(&private_display->lock);
1208                 TDM_WRN("not implemented!!");
1209                 return TDM_ERROR_NONE;
1210         }
1211
1212         ret = func_output->output_get_dpms(private_output->output_backend, dpms_value);
1213
1214         _pthread_mutex_unlock(&private_display->lock);
1215
1216         return ret;
1217 }
1218
1219 EXTERN tdm_capture *
1220 tdm_output_create_capture(tdm_output *output, tdm_error *error)
1221 {
1222         tdm_capture *capture = NULL;
1223
1224         OUTPUT_FUNC_ENTRY_ERROR();
1225
1226         _pthread_mutex_lock(&private_display->lock);
1227
1228         capture = (tdm_capture *)tdm_capture_create_output_internal(private_output, error);
1229
1230         _pthread_mutex_unlock(&private_display->lock);
1231
1232         return capture;
1233 }
1234
1235 INTERN void
1236 tdm_output_call_change_handler_internal(tdm_private_output *private_output,
1237                                                                                 struct list_head *change_handler_list,
1238                                                                                 tdm_output_change_type type,
1239                                                                                 tdm_value value,
1240                                                                                 int no_check_thread_id)
1241 {
1242         tdm_private_display *private_display;
1243         tdm_private_change_handler *change_handler = NULL;
1244
1245         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
1246         TDM_RETURN_IF_FAIL(private_output);
1247
1248         private_display = private_output->private_display;
1249         if (!tdm_thread_in_display_thread(syscall(SYS_gettid))) {
1250                 if (type & TDM_OUTPUT_CHANGE_CONNECTION)
1251                         TDM_INFO("output(%d) changed: %s (%d)",
1252                                          private_output->pipe, tdm_status_str(value.u32), value.u32);
1253                 if (type & TDM_OUTPUT_CHANGE_DPMS)
1254                         TDM_INFO("output(%d) changed: dpms %s (%d)",
1255                                          private_output->pipe, tdm_dpms_str(value.u32), value.u32);
1256         }
1257
1258         if (LIST_IS_EMPTY(change_handler_list))
1259                 return;
1260
1261         LIST_FOR_EACH_ENTRY(change_handler, change_handler_list, link) {
1262                 if (!no_check_thread_id && change_handler->owner_tid != syscall(SYS_gettid))
1263                         TDM_NEVER_GET_HERE();
1264
1265                 _pthread_mutex_unlock(&private_display->lock);
1266                 change_handler->func(private_output, type,
1267                                                          value, change_handler->user_data);
1268                 _pthread_mutex_lock(&private_display->lock);
1269         }
1270 }
1271
1272 EXTERN tdm_error
1273 tdm_layer_get_capabilities(tdm_layer *layer, tdm_layer_capability *capabilities)
1274 {
1275         LAYER_FUNC_ENTRY();
1276
1277         TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
1278
1279         _pthread_mutex_lock(&private_display->lock);
1280
1281         *capabilities = private_layer->caps.capabilities;
1282
1283         _pthread_mutex_unlock(&private_display->lock);
1284
1285         return ret;
1286 }
1287
1288 EXTERN tdm_error
1289 tdm_layer_get_available_formats(tdm_layer *layer, const tbm_format **formats, int *count)
1290 {
1291         LAYER_FUNC_ENTRY();
1292
1293         TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
1294         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
1295
1296         _pthread_mutex_lock(&private_display->lock);
1297
1298         *formats = (const tbm_format *)private_layer->caps.formats;
1299         *count = private_layer->caps.format_count;
1300
1301         _pthread_mutex_unlock(&private_display->lock);
1302
1303         return ret;
1304 }
1305
1306 EXTERN tdm_error
1307 tdm_layer_get_available_properties(tdm_layer *layer, const tdm_prop **props, int *count)
1308 {
1309         LAYER_FUNC_ENTRY();
1310
1311         TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
1312         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
1313
1314         _pthread_mutex_lock(&private_display->lock);
1315
1316         *props = (const tdm_prop *)private_layer->caps.props;
1317         *count = private_layer->caps.prop_count;
1318
1319         _pthread_mutex_unlock(&private_display->lock);
1320
1321         return ret;
1322 }
1323
1324 EXTERN tdm_error
1325 tdm_layer_get_zpos(tdm_layer *layer, int *zpos)
1326 {
1327         LAYER_FUNC_ENTRY();
1328
1329         TDM_RETURN_VAL_IF_FAIL(zpos != NULL, TDM_ERROR_INVALID_PARAMETER);
1330
1331         _pthread_mutex_lock(&private_display->lock);
1332
1333         *zpos = private_layer->caps.zpos;
1334
1335         _pthread_mutex_unlock(&private_display->lock);
1336
1337         return ret;
1338 }
1339
1340 EXTERN tdm_error
1341 tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
1342 {
1343         tdm_func_layer *func_layer;
1344         LAYER_FUNC_ENTRY();
1345
1346         _pthread_mutex_lock(&private_display->lock);
1347
1348         func_layer = &private_display->func_layer;
1349
1350         if (!func_layer->layer_set_property) {
1351                 _pthread_mutex_unlock(&private_display->lock);
1352                 TDM_ERR("not implemented!!");
1353                 return TDM_ERROR_NOT_IMPLEMENTED;
1354         }
1355
1356         ret = func_layer->layer_set_property(private_layer->layer_backend, id, value);
1357
1358         _pthread_mutex_unlock(&private_display->lock);
1359
1360         return ret;
1361 }
1362
1363 EXTERN tdm_error
1364 tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
1365 {
1366         tdm_func_layer *func_layer;
1367         LAYER_FUNC_ENTRY();
1368
1369         TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
1370
1371         _pthread_mutex_lock(&private_display->lock);
1372
1373         func_layer = &private_display->func_layer;
1374
1375         if (!func_layer->layer_get_property) {
1376                 _pthread_mutex_unlock(&private_display->lock);
1377                 TDM_ERR("not implemented!!");
1378                 return TDM_ERROR_NOT_IMPLEMENTED;
1379         }
1380
1381         ret = func_layer->layer_get_property(private_layer->layer_backend, id, value);
1382
1383         _pthread_mutex_unlock(&private_display->lock);
1384
1385         return ret;
1386 }
1387
1388 EXTERN tdm_error
1389 tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
1390 {
1391         tdm_func_layer *func_layer;
1392         char fmtstr[128];
1393
1394         LAYER_FUNC_ENTRY();
1395
1396         TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
1397
1398         _pthread_mutex_lock(&private_display->lock);
1399
1400         func_layer = &private_display->func_layer;
1401
1402         if (private_layer->usable)
1403                 TDM_INFO("layer(%p) not usable", private_layer);
1404
1405         private_layer->usable = 0;
1406
1407         if (!func_layer->layer_set_info) {
1408                 _pthread_mutex_unlock(&private_display->lock);
1409                 TDM_ERR("not implemented!!");
1410                 return TDM_ERROR_NOT_IMPLEMENTED;
1411         }
1412
1413         if (info->src_config.format)
1414                 snprintf(fmtstr, 128, "%c%c%c%c", FOURCC_STR(info->src_config.format));
1415         else
1416                 snprintf(fmtstr, 128, "NONE");
1417
1418         TDM_INFO("layer(%p) info: src(%dx%d %d,%d %dx%d %s) dst(%d,%d %dx%d) trans(%d)",
1419                          private_layer, info->src_config.size.h, info->src_config.size.v,
1420                          info->src_config.pos.x, info->src_config.pos.y,
1421                          info->src_config.pos.w, info->src_config.pos.h,
1422                          fmtstr,
1423                          info->dst_pos.x, info->dst_pos.y,
1424                          info->dst_pos.w, info->dst_pos.h,
1425                          info->transform);
1426
1427         ret = func_layer->layer_set_info(private_layer->layer_backend, info);
1428         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
1429
1430         _pthread_mutex_unlock(&private_display->lock);
1431
1432         return ret;
1433 }
1434
1435 EXTERN tdm_error
1436 tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
1437 {
1438         tdm_func_layer *func_layer;
1439         LAYER_FUNC_ENTRY();
1440
1441         TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
1442
1443         _pthread_mutex_lock(&private_display->lock);
1444
1445         func_layer = &private_display->func_layer;
1446
1447         if (!func_layer->layer_get_info) {
1448                 _pthread_mutex_unlock(&private_display->lock);
1449                 TDM_ERR("not implemented!!");
1450                 return TDM_ERROR_NOT_IMPLEMENTED;
1451         }
1452
1453         ret = func_layer->layer_get_info(private_layer->layer_backend, info);
1454
1455         _pthread_mutex_unlock(&private_display->lock);
1456
1457         return ret;
1458 }
1459
1460 static void
1461 _tdm_layer_dump_buffer(tdm_layer *layer, tbm_surface_h buffer)
1462 {
1463         tdm_private_layer *private_layer = (tdm_private_layer*)layer;
1464         tdm_private_output *private_output = private_layer->private_output;
1465         unsigned int pipe;
1466         int zpos;
1467         char fname[PATH_MAX];
1468
1469         pipe = private_output->pipe;
1470         zpos = private_layer->caps.zpos;
1471
1472         snprintf(fname, sizeof(fname), "tdm_%d_lyr_%d", pipe, zpos);
1473
1474         tbm_surface_internal_dump_buffer(buffer, fname);
1475         TDM_DBG("%s dump excute", fname);
1476
1477         return;
1478 }
1479
1480 EXTERN tdm_error
1481 tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
1482 {
1483         tdm_func_layer *func_layer;
1484
1485         LAYER_FUNC_ENTRY();
1486
1487         TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER);
1488
1489         _pthread_mutex_lock(&private_display->lock);
1490
1491         if (tdm_debug_dump & TDM_DUMP_FLAG_LAYER &&
1492                 !(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)) {
1493                 char str[TDM_PATH_LEN];
1494                 static int i;
1495                 snprintf(str, TDM_PATH_LEN, "layer_%d_%d_%03d",
1496                                  private_output->index, private_layer->index, i++);
1497                 tdm_helper_dump_buffer_str(buffer, tdm_debug_dump_dir, str);
1498         }
1499
1500         func_layer = &private_display->func_layer;
1501
1502         if (private_layer->usable)
1503                 TDM_INFO("layer(%p) not usable", private_layer);
1504
1505         private_layer->usable = 0;
1506
1507         if (!func_layer->layer_set_buffer) {
1508                 _pthread_mutex_unlock(&private_display->lock);
1509                 TDM_ERR("not implemented!!");
1510                 return TDM_ERROR_NOT_IMPLEMENTED;
1511         }
1512
1513         ret = func_layer->layer_set_buffer(private_layer->layer_backend, buffer);
1514         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
1515
1516         /* dump buffer */
1517         if (tdm_dump_enable && !(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO))
1518                 _tdm_layer_dump_buffer(layer, buffer);
1519
1520         if (ret == TDM_ERROR_NONE) {
1521                 /* FIXME: should save to pending_buffer first. And after committing
1522                  * successfully, need to move to waiting_buffer.
1523                  */
1524                 if (private_layer->waiting_buffer) {
1525                         _pthread_mutex_unlock(&private_display->lock);
1526                         tdm_buffer_unref_backend(private_layer->waiting_buffer);
1527                         _pthread_mutex_lock(&private_display->lock);
1528                 }
1529
1530                 private_layer->waiting_buffer = tdm_buffer_ref_backend(buffer);
1531                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
1532                         TDM_INFO("layer(%p) waiting_buffer(%p)",
1533                                          private_layer, private_layer->waiting_buffer);
1534         }
1535
1536         _pthread_mutex_unlock(&private_display->lock);
1537
1538         return ret;
1539 }
1540
1541 EXTERN tdm_error
1542 tdm_layer_unset_buffer(tdm_layer *layer)
1543 {
1544         tdm_func_layer *func_layer;
1545         LAYER_FUNC_ENTRY();
1546
1547         _pthread_mutex_lock(&private_display->lock);
1548
1549         func_layer = &private_display->func_layer;
1550
1551         if (private_layer->waiting_buffer) {
1552                 _pthread_mutex_unlock(&private_display->lock);
1553                 tdm_buffer_unref_backend(private_layer->waiting_buffer);
1554                 _pthread_mutex_lock(&private_display->lock);
1555                 private_layer->waiting_buffer = NULL;
1556
1557                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
1558                         TDM_INFO("layer(%p) waiting_buffer(%p)",
1559                                          private_layer, private_layer->waiting_buffer);
1560         }
1561
1562         if (private_layer->showing_buffer) {
1563                 _pthread_mutex_unlock(&private_display->lock);
1564                 tdm_buffer_unref_backend(private_layer->showing_buffer);
1565                 _pthread_mutex_lock(&private_display->lock);
1566                 private_layer->showing_buffer = NULL;
1567
1568                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
1569                         TDM_INFO("layer(%p) showing_buffer(%p)",
1570                                          private_layer, private_layer->showing_buffer);
1571         }
1572
1573         private_layer->usable = 1;
1574
1575         if (private_layer->usable)
1576                 TDM_INFO("layer(%p) now usable", private_layer);
1577
1578         if (!func_layer->layer_unset_buffer) {
1579                 _pthread_mutex_unlock(&private_display->lock);
1580                 TDM_ERR("not implemented!!");
1581                 return TDM_ERROR_NOT_IMPLEMENTED;
1582         }
1583
1584         ret = func_layer->layer_unset_buffer(private_layer->layer_backend);
1585         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
1586
1587         _pthread_mutex_unlock(&private_display->lock);
1588
1589         return ret;
1590 }
1591
1592 EXTERN tbm_surface_h
1593 tdm_layer_get_displaying_buffer(tdm_layer *layer, tdm_error *error)
1594 {
1595         tbm_surface_h buffer;
1596         LAYER_FUNC_ENTRY_ERROR();
1597
1598         _pthread_mutex_lock(&private_display->lock);
1599
1600         if (error)
1601                 *error = TDM_ERROR_NONE;
1602
1603         if (private_layer->showing_buffer) {
1604                 buffer = private_layer->showing_buffer;
1605         } else {
1606                 if (error)
1607                         *error = TDM_ERROR_OPERATION_FAILED;
1608                 _pthread_mutex_unlock(&private_display->lock);
1609                 TDM_DBG("layer(%p) showing_buffer is null", private_layer);
1610                 return NULL;
1611         }
1612         _pthread_mutex_unlock(&private_display->lock);
1613
1614         return buffer;
1615 }
1616
1617 static void
1618 _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
1619 {
1620         TDM_RETURN_IF_FAIL(data != NULL);
1621         tdm_layer *layer = data;
1622         tdm_func_layer *func_layer;
1623         tbm_surface_h surface = NULL;
1624         LAYER_FUNC_ENTRY_VOID_RETURN();
1625
1626         _pthread_mutex_lock(&private_display->lock);
1627
1628         func_layer = &private_display->func_layer;
1629         if (!func_layer->layer_set_buffer) {
1630                 _pthread_mutex_unlock(&private_display->lock);
1631                 return;
1632         }
1633
1634         if (TBM_SURFACE_QUEUE_ERROR_NONE != tbm_surface_queue_acquire(private_layer->buffer_queue, &surface) ||
1635                 surface == NULL) {
1636                 TDM_ERR("layer(%p) tbm_surface_queue_acquire() failed surface:%p",
1637                                 private_layer, surface);
1638                 _pthread_mutex_unlock(&private_display->lock);
1639                 return;
1640         }
1641
1642         ret = func_layer->layer_set_buffer(private_layer->layer_backend, surface);
1643         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
1644
1645         if (ret == TDM_ERROR_NONE) {
1646                 if (private_layer->waiting_buffer) {
1647                         TDM_DBG("layer(%p) drop waiting_buffer(%p)", private_layer, private_layer->waiting_buffer);
1648                         _pthread_mutex_unlock(&private_display->lock);
1649                         tdm_buffer_unref_backend(private_layer->waiting_buffer);
1650                         tbm_surface_queue_release(private_layer->buffer_queue,
1651                                                                           private_layer->waiting_buffer);
1652                         _pthread_mutex_lock(&private_display->lock);
1653                 }
1654
1655                 private_layer->waiting_buffer = tdm_buffer_ref_backend(surface);
1656
1657                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
1658                         TDM_INFO("layer(%p) waiting_buffer(%p)",
1659                                          private_layer, private_layer->waiting_buffer);
1660
1661                 ret = _tdm_output_commit(private_layer->private_output, 0, NULL, NULL);
1662                 if (ret != TDM_ERROR_NONE)
1663                         TDM_ERR("layer(%p) _tdm_output_commit() is fail", private_layer);
1664         }
1665
1666         _pthread_mutex_unlock(&private_display->lock);
1667 }
1668
1669 static void
1670 _tbm_layer_queue_destroy_cb(tbm_surface_queue_h surface_queue, void *data)
1671 {
1672         TDM_RETURN_IF_FAIL(data != NULL);
1673         tdm_layer *layer = data;
1674         LAYER_FUNC_ENTRY_VOID_RETURN();
1675         TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
1676
1677         _pthread_mutex_lock(&private_display->lock);
1678
1679         if (private_layer->waiting_buffer) {
1680                 _pthread_mutex_unlock(&private_display->lock);
1681                 tdm_buffer_unref_backend(private_layer->waiting_buffer);
1682                 tbm_surface_queue_release(private_layer->buffer_queue,
1683                                                                   private_layer->waiting_buffer);
1684                 _pthread_mutex_lock(&private_display->lock);
1685         }
1686
1687         private_layer->buffer_queue = NULL;
1688
1689         _pthread_mutex_unlock(&private_display->lock);
1690 }
1691
1692 EXTERN tdm_error
1693 tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
1694 {
1695         tdm_func_layer *func_layer;
1696         LAYER_FUNC_ENTRY();
1697
1698         TDM_RETURN_VAL_IF_FAIL(buffer_queue != NULL, TDM_ERROR_INVALID_PARAMETER);
1699
1700         _pthread_mutex_lock(&private_display->lock);
1701
1702         func_layer = &private_display->func_layer;
1703
1704         if (private_layer->usable)
1705                 TDM_INFO("layer(%p) not usable", private_layer);
1706
1707         private_layer->usable = 0;
1708
1709         if (!func_layer->layer_set_buffer) {
1710                 _pthread_mutex_unlock(&private_display->lock);
1711                 TDM_ERR("not implemented!!");
1712                 return TDM_ERROR_NOT_IMPLEMENTED;
1713         }
1714
1715         if (buffer_queue == private_layer->buffer_queue) {
1716                 _pthread_mutex_unlock(&private_display->lock);
1717                 return TDM_ERROR_NONE;
1718         }
1719
1720         if (private_layer->waiting_buffer) {
1721                 _pthread_mutex_unlock(&private_display->lock);
1722                 tdm_buffer_unref_backend(private_layer->waiting_buffer);
1723                 tbm_surface_queue_release(private_layer->buffer_queue,
1724                                                                   private_layer->waiting_buffer);
1725                 private_layer->waiting_buffer = NULL;
1726                 _pthread_mutex_lock(&private_display->lock);
1727
1728                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
1729                         TDM_INFO("layer(%p) waiting_buffer(%p)",
1730                                          private_layer, private_layer->waiting_buffer);
1731         }
1732
1733         private_layer->buffer_queue = buffer_queue;
1734         tbm_surface_queue_add_acquirable_cb(private_layer->buffer_queue,
1735                                                                                 _tbm_layer_queue_acquirable_cb,
1736                                                                                 layer);
1737         tbm_surface_queue_add_destroy_cb(private_layer->buffer_queue,
1738                                                                          _tbm_layer_queue_destroy_cb,
1739                                                                          layer);
1740         _pthread_mutex_unlock(&private_display->lock);
1741
1742         return ret;
1743 }
1744
1745 EXTERN tdm_error
1746 tdm_layer_unset_buffer_queue(tdm_layer *layer)
1747 {
1748         tdm_func_layer *func_layer;
1749         LAYER_FUNC_ENTRY();
1750
1751         _pthread_mutex_lock(&private_display->lock);
1752
1753         func_layer = &private_display->func_layer;
1754
1755         if (private_layer->waiting_buffer) {
1756                 _pthread_mutex_unlock(&private_display->lock);
1757                 tdm_buffer_unref_backend(private_layer->waiting_buffer);
1758                 tbm_surface_queue_release(private_layer->buffer_queue,
1759                                                                   private_layer->waiting_buffer);
1760                 private_layer->waiting_buffer = NULL;
1761                 _pthread_mutex_lock(&private_display->lock);
1762
1763                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
1764                         TDM_INFO("layer(%p) waiting_buffer(%p)",
1765                                          private_layer, private_layer->waiting_buffer);
1766         }
1767
1768         if (private_layer->showing_buffer) {
1769                 _pthread_mutex_unlock(&private_display->lock);
1770                 tdm_buffer_unref_backend(private_layer->showing_buffer);
1771                 tbm_surface_queue_release(private_layer->buffer_queue,
1772                                                                   private_layer->showing_buffer);
1773                 _pthread_mutex_lock(&private_display->lock);
1774                 private_layer->showing_buffer = NULL;
1775
1776                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
1777                         TDM_INFO("layer(%p) showing_buffer(%p)",
1778                                          private_layer, private_layer->showing_buffer);
1779         }
1780
1781         tbm_surface_queue_remove_acquirable_cb(private_layer->buffer_queue, _tbm_layer_queue_acquirable_cb, layer);
1782         tbm_surface_queue_remove_destroy_cb(private_layer->buffer_queue, _tbm_layer_queue_destroy_cb, layer);
1783         private_layer->buffer_queue = NULL;
1784         private_layer->usable = 1;
1785
1786         if (private_layer->usable)
1787                 TDM_INFO("layer(%p) now usable", private_layer);
1788
1789         if (!func_layer->layer_unset_buffer) {
1790                 _pthread_mutex_unlock(&private_display->lock);
1791                 TDM_ERR("not implemented!!");
1792                 return TDM_ERROR_NOT_IMPLEMENTED;
1793         }
1794
1795         ret = func_layer->layer_unset_buffer(private_layer->layer_backend);
1796
1797         _pthread_mutex_unlock(&private_display->lock);
1798
1799         return ret;
1800 }
1801
1802 EXTERN tdm_error
1803 tdm_layer_is_usable(tdm_layer *layer, unsigned int *usable)
1804 {
1805         LAYER_FUNC_ENTRY();
1806
1807         TDM_RETURN_VAL_IF_FAIL(usable != NULL, TDM_ERROR_INVALID_PARAMETER);
1808
1809         _pthread_mutex_lock(&private_display->lock);
1810
1811         *usable = private_layer->usable;
1812
1813         _pthread_mutex_unlock(&private_display->lock);
1814
1815         return ret;
1816 }
1817
1818 EXTERN tdm_error
1819 tdm_layer_set_video_pos(tdm_layer *layer, int zpos)
1820 {
1821         tdm_func_layer *func_layer;
1822         LAYER_FUNC_ENTRY();
1823
1824         _pthread_mutex_lock(&private_display->lock);
1825
1826         func_layer = &private_display->func_layer;
1827
1828         if (!(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)) {
1829                 TDM_ERR("layer(%p) is not video layer", private_layer);
1830                 _pthread_mutex_unlock(&private_display->lock);
1831                 return TDM_ERROR_INVALID_PARAMETER;
1832         }
1833
1834         if (!func_layer->layer_set_video_pos) {
1835                 _pthread_mutex_unlock(&private_display->lock);
1836                 TDM_ERR("not implemented!!");
1837                 return TDM_ERROR_NOT_IMPLEMENTED;
1838         }
1839
1840         ret = func_layer->layer_set_video_pos(private_layer->layer_backend, zpos);
1841
1842         _pthread_mutex_unlock(&private_display->lock);
1843
1844         return ret;
1845 }
1846
1847 EXTERN tdm_capture *
1848 tdm_layer_create_capture(tdm_layer *layer, tdm_error *error)
1849 {
1850         tdm_capture *capture = NULL;
1851
1852         LAYER_FUNC_ENTRY_ERROR();
1853
1854         _pthread_mutex_lock(&private_display->lock);
1855
1856         capture = (tdm_capture *)tdm_capture_create_layer_internal(private_layer, error);
1857
1858         _pthread_mutex_unlock(&private_display->lock);
1859
1860         return capture;
1861 }
1862
1863 EXTERN tdm_error
1864 tdm_layer_get_buffer_flags(tdm_layer *layer, unsigned int *flags)
1865 {
1866         tdm_func_layer *func_layer;
1867         LAYER_FUNC_ENTRY();
1868
1869         _pthread_mutex_lock(&private_display->lock);
1870
1871         func_layer = &private_display->func_layer;
1872
1873         if (!func_layer->layer_get_buffer_flags) {
1874                 _pthread_mutex_unlock(&private_display->lock);
1875                 TDM_ERR("not implemented!!");
1876                 return TDM_ERROR_NOT_IMPLEMENTED;
1877         }
1878
1879         ret = func_layer->layer_get_buffer_flags(private_layer->layer_backend, flags);
1880
1881         _pthread_mutex_unlock(&private_display->lock);
1882
1883         return ret;
1884 }