src/tdm_layer.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 <boram1288.park@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_private.h"
  41
  42 #define COUNT_MAX   10
  43
  44 #define LAYER_FUNC_ENTRY() \
  45         tdm_private_display *private_display; \
  46         tdm_private_output *private_output; \
  47         tdm_private_layer *private_layer; \
  48         tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
  49         TDM_RETURN_VAL_IF_FAIL(layer != NULL, TDM_ERROR_INVALID_PARAMETER); \
  50         private_layer = (tdm_private_layer*)layer; \
  51         private_output = private_layer->private_output; \
  52         private_display = private_output->private_display
  53
  54 #define LAYER_FUNC_ENTRY_ERROR() \
  55         tdm_private_display *private_display; \
  56         tdm_private_output *private_output; \
  57         tdm_private_layer *private_layer; \
  58         tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
  59         TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(layer != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
  60         private_layer = (tdm_private_layer*)layer; \
  61         private_output = private_layer->private_output; \
  62         private_display = private_output->private_display
  63
  64 #define LAYER_FUNC_ENTRY_VOID_RETURN() \
  65         tdm_private_display *private_display; \
  66         tdm_private_output *private_output; \
  67         tdm_private_layer *private_layer; \
  68         tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
  69         TDM_RETURN_IF_FAIL(layer != NULL); \
  70         private_layer = (tdm_private_layer*)layer; \
  71         private_output = private_layer->private_output; \
  72         private_display = private_output->private_display
  73
  74 static void _tdm_layer_cb_wait_vblank(tdm_vblank *vblank, tdm_error error, unsigned int sequence,
  75                                                                           unsigned int tv_sec, unsigned int tv_usec, void *user_data);
  76 static void _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data);
  77 static void _tbm_layer_queue_destroy_cb(tbm_surface_queue_h surface_queue, void *data);
  78 static void _tdm_layer_cb_output_commit(tdm_output *output, unsigned int sequence,
  79                                                                                 unsigned int tv_sec, unsigned int tv_usec, void *user_data);
  80 static void _tdm_layer_reset_pending_data(tdm_private_layer *private_layer);
  81
  82 EXTERN tdm_output*
  83 tdm_layer_get_output(tdm_layer *layer, tdm_error *error)
  84 {
  85         tdm_output *output;
  86
  87         LAYER_FUNC_ENTRY_ERROR();
  88
  89         _pthread_mutex_lock(&private_display->lock);
  90
  91         if (error)
  92                 *error = TDM_ERROR_NONE;
  93
  94         output = private_layer->private_output;
  95
  96         _pthread_mutex_unlock(&private_display->lock);
  97
  98         return output;
  99 }
 100
 101 EXTERN tdm_error
 102 tdm_layer_get_index(tdm_layer *layer, int *index)
 103 {
 104         LAYER_FUNC_ENTRY();
 105
 106         TDM_RETURN_VAL_IF_FAIL(index != NULL, TDM_ERROR_INVALID_PARAMETER);
 107
 108         _pthread_mutex_lock(&private_display->lock);
 109
 110         *index = private_layer->index;
 111
 112         _pthread_mutex_unlock(&private_display->lock);
 113
 114         return ret;
 115 }
 116
 117 EXTERN tdm_error
 118 tdm_layer_get_capabilities(tdm_layer *layer, tdm_layer_capability *capabilities)
 119 {
 120         LAYER_FUNC_ENTRY();
 121
 122         TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 123
 124         _pthread_mutex_lock(&private_display->lock);
 125
 126         *capabilities = private_layer->caps.capabilities;
 127
 128         _pthread_mutex_unlock(&private_display->lock);
 129
 130         return ret;
 131 }
 132
 133 EXTERN tdm_error
 134 tdm_layer_get_available_formats(tdm_layer *layer, const tbm_format **formats, int *count)
 135 {
 136         LAYER_FUNC_ENTRY();
 137
 138         TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
 139         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 140
 141         _pthread_mutex_lock(&private_display->lock);
 142
 143         *formats = (const tbm_format *)private_layer->caps.formats;
 144         *count = private_layer->caps.format_count;
 145
 146         _pthread_mutex_unlock(&private_display->lock);
 147
 148         return ret;
 149 }
 150
 151 EXTERN tdm_error
 152 tdm_layer_get_available_properties(tdm_layer *layer, const tdm_prop **props, int *count)
 153 {
 154         LAYER_FUNC_ENTRY();
 155
 156         TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
 157         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 158
 159         _pthread_mutex_lock(&private_display->lock);
 160
 161         *props = (const tdm_prop *)private_layer->caps.props;
 162         *count = private_layer->caps.prop_count;
 163
 164         _pthread_mutex_unlock(&private_display->lock);
 165
 166         return ret;
 167 }
 168
 169 EXTERN tdm_error
 170 tdm_layer_get_zpos(tdm_layer *layer, int *zpos)
 171 {
 172         LAYER_FUNC_ENTRY();
 173
 174         TDM_RETURN_VAL_IF_FAIL(zpos != NULL, TDM_ERROR_INVALID_PARAMETER);
 175
 176         _pthread_mutex_lock(&private_display->lock);
 177
 178         *zpos = private_layer->caps.zpos;
 179
 180         _pthread_mutex_unlock(&private_display->lock);
 181
 182         return ret;
 183 }
 184
 185 EXTERN tdm_error
 186 tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
 187 {
 188         tdm_private_module *private_module;
 189         tdm_func_layer *func_layer;
 190         LAYER_FUNC_ENTRY();
 191
 192         _pthread_mutex_lock(&private_display->lock);
 193
 194         private_module = private_layer->private_module;
 195         func_layer = &private_module->func_layer;
 196
 197         if (private_layer->usable)
 198                 TDM_INFO("layer(%p,%d) not usable", private_layer, private_layer->index);
 199
 200         private_layer->usable = 0;
 201
 202         if (!func_layer->layer_set_property) {
 203                 /* LCOV_EXCL_START */
 204                 _pthread_mutex_unlock(&private_display->lock);
 205                 TDM_ERR("not implemented!!");
 206                 return TDM_ERROR_NOT_IMPLEMENTED;
 207                 /* LCOV_EXCL_STOP */
 208         }
 209
 210         ret = func_layer->layer_set_property(private_layer->layer_backend, id, value);
 211
 212         _pthread_mutex_unlock(&private_display->lock);
 213
 214         return ret;
 215 }
 216
 217 EXTERN tdm_error
 218 tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
 219 {
 220         tdm_private_module *private_module;
 221         tdm_func_layer *func_layer;
 222         LAYER_FUNC_ENTRY();
 223
 224         TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
 225
 226         _pthread_mutex_lock(&private_display->lock);
 227
 228         private_module = private_layer->private_module;
 229         func_layer = &private_module->func_layer;
 230
 231         if (!func_layer->layer_get_property) {
 232                 /* LCOV_EXCL_START */
 233                 _pthread_mutex_unlock(&private_display->lock);
 234                 TDM_ERR("not implemented!!");
 235                 return TDM_ERROR_NOT_IMPLEMENTED;
 236                 /* LCOV_EXCL_SOP */
 237         }
 238
 239         ret = func_layer->layer_get_property(private_layer->layer_backend, id, value);
 240
 241         _pthread_mutex_unlock(&private_display->lock);
 242
 243         return ret;
 244 }
 245
 246 INTERN tdm_error
 247 tdm_layer_set_info_internal(tdm_private_layer *private_layer, tdm_info_layer *info)
 248 {
 249         tdm_private_module *private_module;
 250         tdm_func_layer *func_layer;
 251         char fmtstr[128];
 252
 253         private_module = private_layer->private_module;
 254         func_layer = &private_module->func_layer;
 255
 256         if (private_layer->usable)
 257                 TDM_INFO("layer(%p,%d) not usable", private_layer, private_layer->index);
 258
 259         private_layer->usable = 0;
 260
 261         if (!func_layer->layer_set_info) {
 262                 /* LCOV_EXCL_START */
 263                 TDM_ERR("not implemented!!");
 264                 return TDM_ERROR_NOT_IMPLEMENTED;
 265                 /* LCOV_EXCL_STOP */
 266         }
 267
 268         if (info->src_config.format)
 269                 snprintf(fmtstr, 128, "%c%c%c%c", FOURCC_STR(info->src_config.format));
 270         else
 271                 snprintf(fmtstr, 128, "NONE");
 272
 273         TDM_INFO("layer(%p,%d) info: src(%ux%u %u,%u %ux%u %s) dst(%u,%u %ux%u) trans(%d)",
 274                          private_layer, private_layer->index,
 275                          info->src_config.size.h, info->src_config.size.v,
 276                          info->src_config.pos.x, info->src_config.pos.y,
 277                          info->src_config.pos.w, info->src_config.pos.h,
 278                          fmtstr,
 279                          info->dst_pos.x, info->dst_pos.y,
 280                          info->dst_pos.w, info->dst_pos.h,
 281                          info->transform);
 282
 283         private_layer->pending_info_changed = 1;
 284         private_layer->pending_info = *info;
 285
 286         return TDM_ERROR_NONE;
 287 }
 288
 289 EXTERN tdm_error
 290 tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
 291 {
 292         LAYER_FUNC_ENTRY();
 293
 294         TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
 295
 296         _pthread_mutex_lock(&private_display->lock);
 297
 298         ret = tdm_layer_set_info_internal(private_layer, info);
 299
 300         _pthread_mutex_unlock(&private_display->lock);
 301
 302         return ret;
 303 }
 304
 305 EXTERN tdm_error
 306 tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
 307 {
 308         tdm_private_module *private_module;
 309         tdm_func_layer *func_layer;
 310         LAYER_FUNC_ENTRY();
 311
 312         TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
 313
 314         _pthread_mutex_lock(&private_display->lock);
 315
 316         private_module = private_layer->private_module;
 317         func_layer = &private_module->func_layer;
 318
 319         if (!func_layer->layer_get_info) {
 320                 /* LCOV_EXCL_START */
 321                 _pthread_mutex_unlock(&private_display->lock);
 322                 TDM_ERR("not implemented!!");
 323                 return TDM_ERROR_NOT_IMPLEMENTED;
 324                 /* LCOV_EXCL_STOP */
 325         }
 326
 327         ret = func_layer->layer_get_info(private_layer->layer_backend, info);
 328
 329         _pthread_mutex_unlock(&private_display->lock);
 330
 331         return ret;
 332 }
 333
 334 /* LCOV_EXCL_START */
 335 static void
 336 _tdm_layer_dump_buffer(tdm_layer *layer, tbm_surface_h buffer)
 337 {
 338         tdm_private_layer *private_layer = (tdm_private_layer*)layer;
 339         tdm_private_output *private_output = private_layer->private_output;
 340         unsigned int pipe;
 341         char fname[TDM_PATH_LEN], bufs[TDM_PATH_LEN];
 342         int zpos, len = TDM_PATH_LEN;
 343         tdm_private_layer *l = NULL;
 344         char *p = bufs;
 345         int *remain = &len;
 346
 347         pipe = private_output->pipe;
 348         zpos = private_layer->caps.zpos;
 349
 350         bufs[0] = '\0';
 351         LIST_FOR_EACH_ENTRY(l, &private_output->layer_list, link) {
 352                 if (!l->showing_buffer)
 353                         continue;
 354                 TDM_SNPRINTF(p, remain, "_%p", l->showing_buffer->buffer);
 355         }
 356
 357         snprintf(fname, sizeof(fname), "tdm_%d_lyr_%d%s", pipe, zpos, bufs);
 358
 359         tbm_surface_internal_dump_buffer(buffer, fname);
 360         TDM_DBG("%s dump excute", fname);
 361
 362         return;
 363 }
 364 /* LCOV_EXCL_STOP */
 365
 366 void
 367 tdm_layer_free_buffer(tdm_private_layer *private_layer, tdm_private_layer_buffer *layer_buffer)
 368 {
 369         tdm_private_display *private_display;
 370
 371         if (!layer_buffer)
 372                 return;
 373
 374         private_display = private_layer->private_output->private_display;
 375
 376         LIST_DEL(&layer_buffer->link);
 377         if (layer_buffer->buffer) {
 378                 _pthread_mutex_unlock(&private_display->lock);
 379                 tdm_buffer_unref_backend(layer_buffer->buffer);
 380                 if (private_layer->buffer_queue)
 381                         tbm_surface_queue_release(private_layer->buffer_queue, layer_buffer->buffer);
 382                 _pthread_mutex_lock(&private_display->lock);
 383         }
 384         free(layer_buffer);
 385 }
 386
 387 static void
 388 _tdm_layer_free_all_buffers(tdm_private_layer *private_layer)
 389 {
 390         tdm_private_output *private_output = private_layer->private_output;
 391         tdm_private_layer_commit_handler *lm = NULL, *lmm = NULL;
 392         struct list_head clone_list;
 393
 394         LIST_INITHEAD(&clone_list);
 395
 396         _tdm_layer_reset_pending_data(private_layer);
 397
 398         if (private_layer->waiting_buffer) {
 399                 tdm_layer_free_buffer(private_layer, private_layer->waiting_buffer);
 400                 private_layer->waiting_buffer = NULL;
 401
 402                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
 403                         TDM_INFO("layer(%p,%d) waiting_buffer(%p)",
 404                                          private_layer, private_layer->index, private_layer->waiting_buffer);
 405         }
 406
 407         if (private_layer->committed_buffer) {
 408                 tdm_layer_free_buffer(private_layer, private_layer->committed_buffer);
 409                 private_layer->committed_buffer = NULL;
 410
 411                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
 412                         TDM_INFO("layer(%p,%d) committed_buffer(%p)",
 413                                          private_layer, private_layer->index, private_layer->committed_buffer);
 414         }
 415
 416         if (private_layer->showing_buffer) {
 417                 tdm_layer_free_buffer(private_layer, private_layer->showing_buffer);
 418                 private_layer->showing_buffer = NULL;
 419
 420                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
 421                         TDM_INFO("layer(%p,%d) showing_buffer(%p)",
 422                                          private_layer, private_layer->index, private_layer->showing_buffer);
 423         }
 424
 425         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->layer_commit_handler_list, link) {
 426                 if (lm->private_layer != private_layer)
 427                         continue;
 428                 LIST_DEL(&lm->link);
 429                 LIST_ADDTAIL(&lm->link, &clone_list);
 430         }
 431
 432         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &clone_list, link) {
 433                 LIST_DEL(&lm->link);
 434                 tdm_output_remove_commit_handler_internal(private_output, _tdm_layer_cb_output_commit, lm);
 435                 tdm_layer_free_buffer(private_layer, lm->committed_buffer);
 436                 free(lm);
 437         }
 438
 439         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->pending_commit_handler_list, link) {
 440                 if (lm->private_layer != private_layer)
 441                         continue;
 442                 LIST_DEL(&lm->link);
 443                 LIST_ADDTAIL(&lm->link, &clone_list);
 444         }
 445
 446         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &clone_list, link) {
 447                 LIST_DEL(&lm->link);
 448                 tdm_layer_free_buffer(private_layer, lm->committed_buffer);
 449                 free(lm);
 450         }
 451
 452         if (private_layer->buffer_queue) {
 453                 tbm_surface_queue_remove_acquirable_cb(private_layer->buffer_queue, _tbm_layer_queue_acquirable_cb, private_layer);
 454                 tbm_surface_queue_remove_destroy_cb(private_layer->buffer_queue, _tbm_layer_queue_destroy_cb, private_layer);
 455                 private_layer->buffer_queue = NULL;
 456         }
 457 }
 458
 459 INTERN tdm_error
 460 tdm_layer_set_buffer_internal(tdm_private_layer *private_layer, tbm_surface_h buffer)
 461 {
 462         tdm_private_module *private_module;
 463         tdm_private_output *private_output = private_layer->private_output;
 464         tdm_func_layer *func_layer;
 465
 466         /* LCOV_EXCL_START */
 467         /* dump buffer */
 468         if (tdm_dump_enable && !(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO))
 469                 _tdm_layer_dump_buffer(private_layer, buffer);
 470
 471         if (tdm_debug_dump & TDM_DUMP_FLAG_LAYER &&
 472                 !(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)) {
 473                 char str[TDM_PATH_LEN];
 474                 static int i;
 475                 snprintf(str, TDM_PATH_LEN, "layer_%d_%d_%03d",
 476                                  private_output->index, private_layer->index, i++);
 477                 tdm_helper_dump_buffer_str(buffer, tdm_debug_dump_dir, str);
 478         }
 479         /* LCOV_EXCL_STOP */
 480
 481         private_module = private_layer->private_module;
 482         func_layer = &private_module->func_layer;
 483
 484         if (private_layer->usable)
 485                 TDM_INFO("layer(%p,%d) not usable", private_layer, private_layer->index);
 486
 487         private_layer->usable = 0;
 488
 489         if (!func_layer->layer_set_buffer) {
 490                 /* LCOV_EXCL_START */
 491                 TDM_ERR("not implemented!!");
 492                 return TDM_ERROR_NOT_IMPLEMENTED;
 493                 /* LCOV_EXCL_START */
 494         }
 495
 496         private_layer->pending_buffer_changed = 1;
 497
 498         if (private_layer->pending_buffer) {
 499
 500                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
 501                         TDM_INFO("layer(%p,%d) pending_buffer(%p) skipped",
 502                                          private_layer, private_layer->index, private_layer->pending_buffer);
 503
 504                 if (tdm_ttrace_module & TDM_TTRACE_LAYER) {
 505                         tbm_bo bo = tbm_surface_internal_get_bo(private_layer->pending_buffer, 0);
 506                         TDM_TRACE_ASYNC_END((intptr_t)private_layer, "[LAYER] %d", tbm_bo_export(bo));
 507                 }
 508
 509                 tbm_surface_internal_unref(private_layer->pending_buffer);
 510         }
 511
 512         tbm_surface_internal_ref(buffer);
 513         private_layer->pending_buffer = buffer;
 514
 515         if (tdm_debug_module & TDM_DEBUG_BUFFER) {
 516                 tbm_bo bo = tbm_surface_internal_get_bo(private_layer->pending_buffer, 0);
 517                 int flags = tbm_bo_get_flags(bo);
 518                 TDM_INFO("layer(%p,%d) pending_buffer(%p) bo_flags(%x)",
 519                                  private_layer, private_layer->index, private_layer->pending_buffer, flags);
 520         }
 521
 522         if (tdm_ttrace_module & TDM_TTRACE_LAYER) {
 523                 tbm_bo bo = tbm_surface_internal_get_bo(private_layer->pending_buffer, 0);
 524                 TDM_TRACE_ASYNC_BEGIN((intptr_t)private_layer, "[LAYER] %d", tbm_bo_export(bo));
 525         }
 526
 527         return TDM_ERROR_NONE;
 528 }
 529
 530 EXTERN tdm_error
 531 tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
 532 {
 533         LAYER_FUNC_ENTRY();
 534
 535         TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER);
 536
 537         _pthread_mutex_lock(&private_display->lock);
 538
 539         ret = tdm_layer_set_buffer_internal(private_layer, buffer);
 540
 541         _pthread_mutex_unlock(&private_display->lock);
 542
 543         return ret;
 544 }
 545
 546 INTERN tdm_error
 547 tdm_layer_unset_buffer_internal(tdm_private_layer *private_layer)
 548 {
 549         tdm_private_module *private_module;
 550         tdm_func_layer *func_layer;
 551         tdm_error ret = TDM_ERROR_NONE;
 552
 553         private_module = private_layer->private_module;
 554         func_layer = &private_module->func_layer;
 555
 556         _tdm_layer_free_all_buffers(private_layer);
 557
 558         private_layer->usable = 1;
 559
 560         if (private_layer->usable)
 561                 TDM_INFO("layer(%p,%d) now usable", private_layer, private_layer->index);
 562
 563         if (!func_layer->layer_unset_buffer) {
 564                 /* LCOV_EXCL_START */
 565                 TDM_ERR("not implemented!!");
 566                 return TDM_ERROR_NOT_IMPLEMENTED;
 567                 /* LCOV_EXCL_START */
 568         }
 569
 570         ret = func_layer->layer_unset_buffer(private_layer->layer_backend);
 571         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 572
 573         return ret;
 574 }
 575
 576 EXTERN tdm_error
 577 tdm_layer_unset_buffer(tdm_layer *layer)
 578 {
 579         LAYER_FUNC_ENTRY();
 580
 581         _pthread_mutex_lock(&private_display->lock);
 582
 583         ret = tdm_layer_unset_buffer_internal(private_layer);
 584         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 585
 586         _pthread_mutex_unlock(&private_display->lock);
 587
 588         return ret;
 589 }
 590
 591 INTERN void
 592 tdm_layer_committed(tdm_private_layer *private_layer, tdm_private_layer_buffer **committed_buffer)
 593 {
 594         tdm_private_output *private_output = private_layer->private_output;
 595         tdm_private_display *private_display = private_output->private_display;
 596
 597         /* LCOV_EXCL_START */
 598         if (private_display->print_fps) {
 599                 double curr = tdm_helper_get_time();
 600                 if (private_layer->fps_stamp == 0) {
 601                         private_layer->fps_stamp = curr;
 602                 } else if ((curr - private_layer->fps_stamp) > 1.0) {
 603                         TDM_INFO("output(%d) layer(%p,%d) fps: %d",
 604                                          private_output->index, private_layer, private_layer->index, private_layer->fps_count);
 605                         private_layer->fps_count = 0;
 606                         private_layer->fps_stamp = curr;
 607                 } else
 608                         private_layer->fps_count++;
 609         } else if (private_layer->fps_stamp != 0) {
 610                 private_layer->fps_stamp = 0;
 611                 private_layer->fps_count = 0;
 612         }
 613         /* LCOV_EXCL_STOP */
 614
 615         if (private_layer->showing_buffer) {
 616                 if (tdm_ttrace_module & TDM_TTRACE_LAYER) {
 617                         tbm_bo bo = tbm_surface_internal_get_bo(private_layer->showing_buffer->buffer, 0);
 618                         TDM_TRACE_ASYNC_END((intptr_t)private_layer, "[LAYER] %d", tbm_bo_export(bo));
 619                 }
 620
 621                 tdm_layer_free_buffer(private_layer, private_layer->showing_buffer);
 622         }
 623
 624         private_layer->showing_buffer = *committed_buffer;
 625         *committed_buffer = NULL;
 626
 627         if (tdm_debug_module & TDM_DEBUG_BUFFER)
 628                 TDM_INFO("layer(%p,%d) committed_buffer(%p) showing_buffer(%p)",
 629                                  private_layer, private_layer->index, *committed_buffer,
 630                                  (private_layer->showing_buffer) ? private_layer->showing_buffer->buffer : NULL);
 631 }
 632
 633 static void
 634 _tdm_layer_got_output_vblank(tdm_private_output *private_output, unsigned int sequence,
 635                                                          unsigned int tv_sec, unsigned int tv_usec)
 636 {
 637         tdm_private_layer_commit_handler *lm = NULL, *lmm = NULL;
 638         tdm_private_display *private_display;
 639         struct list_head clone_list, pending_clone_list;
 640         tdm_error ret = TDM_ERROR_NONE;
 641
 642         private_display = private_output->private_display;
 643
 644         private_output->layer_waiting_vblank = 0;
 645
 646         LIST_INITHEAD(&clone_list);
 647         LIST_INITHEAD(&pending_clone_list);
 648
 649         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->layer_commit_handler_list, link) {
 650                 LIST_DEL(&lm->link);
 651                 lm->private_layer->committing = 0;
 652                 LIST_ADDTAIL(&lm->link, &clone_list);
 653         }
 654
 655         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->pending_commit_handler_list, link) {
 656                 LIST_DEL(&lm->link);
 657                 lm->private_layer->committing = 0;
 658                 LIST_ADDTAIL(&lm->link, &pending_clone_list);
 659         }
 660
 661         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &clone_list, link) {
 662                 if (tdm_debug_module & TDM_DEBUG_COMMIT)
 663                         TDM_INFO("layer(%p,%d) committed. handle(%p) commited_buffer(%p)",
 664                                          lm->private_layer, lm->private_layer->index, lm, (lm->committed_buffer) ? lm->committed_buffer->buffer : NULL);
 665
 666                 LIST_DEL(&lm->link);
 667                 tdm_layer_committed(lm->private_layer, &lm->committed_buffer);
 668                 _pthread_mutex_unlock(&private_display->lock);
 669                 if (lm->func)
 670                         lm->func(lm->private_layer, sequence, tv_sec, tv_usec, lm->user_data);
 671                 _pthread_mutex_lock(&private_display->lock);
 672                 if (lm->committed_buffer)
 673                         tdm_layer_free_buffer(lm->private_layer, lm->committed_buffer);
 674                 free(lm);
 675         }
 676
 677         if (LIST_IS_EMPTY(&pending_clone_list))
 678                 return;
 679
 680         TDM_GOTO_IF_FAIL(private_output->vblank != NULL, wait_failed);
 681
 682         ret = tdm_output_commit_internal(private_output, 0, NULL, NULL);
 683         TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, wait_failed);
 684
 685         if (tdm_debug_module & TDM_DEBUG_COMMIT)
 686                 TDM_INFO("layer commit: output(%d) commit", private_output->pipe);
 687
 688         if (!TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->current_dpms_value)) {
 689                 /* tdm_vblank APIs is for server. it should be called in unlock status*/
 690                 if (!private_output->layer_waiting_vblank) {
 691                         _pthread_mutex_unlock(&private_display->lock);
 692                         ret = tdm_vblank_wait(private_output->vblank, 0, 0, 1, _tdm_layer_cb_wait_vblank, private_output);
 693                         _pthread_mutex_lock(&private_display->lock);
 694                         TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, wait_failed);
 695                         private_output->layer_waiting_vblank = 1;
 696                 }
 697         }
 698
 699         if (tdm_debug_module & TDM_DEBUG_COMMIT)
 700                 TDM_INFO("layer commit: output(%d) wait vblank", private_output->pipe);
 701
 702         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &pending_clone_list, link) {
 703                 LIST_DEL(&lm->link);
 704                 LIST_ADDTAIL(&lm->link, &private_output->layer_commit_handler_list);
 705         }
 706
 707         if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->current_dpms_value)) {
 708                 TDM_WRN("dpms %s. Directly call vblank callback.", tdm_dpms_str(private_output->current_dpms_value));
 709                 _pthread_mutex_unlock(&private_display->lock);
 710                 _tdm_layer_cb_wait_vblank(private_output->vblank, 0, 0, 0, 0, private_output);
 711                 _pthread_mutex_lock(&private_display->lock);
 712         }
 713
 714         return;
 715 wait_failed:
 716         /* CAUTION: Once _tdm_layer_commit returns success, the layer commit handler MUST be called always.
 717          * That is, even if we get error in _tdm_layer_got_output_vblank() function for some reasons,
 718          * the layer commit handler MUST be called.
 719          */
 720         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &pending_clone_list, link) {
 721                 TDM_WRN("Directly call layer commit handlers: ret(%d)\n", ret);
 722                 LIST_DEL(&lm->link);
 723                 _pthread_mutex_unlock(&private_display->lock);
 724                 if (lm->func)
 725                         lm->func(lm->private_layer, sequence, tv_sec, tv_usec, lm->user_data);
 726                 _pthread_mutex_lock(&private_display->lock);
 727                 tdm_layer_free_buffer(lm->private_layer, lm->committed_buffer);
 728                 free(lm);
 729         }
 730
 731         return;
 732 }
 733
 734 static void
 735 _tdm_layer_cb_output_commit(tdm_output *output, unsigned int sequence,
 736                                                         unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 737 {
 738         tdm_private_layer_commit_handler *layer_commit_handler = user_data;
 739         tdm_private_layer_commit_handler *lm = NULL;
 740         tdm_private_display *private_display;
 741         tdm_private_output *private_output = output;
 742         tdm_private_layer *private_layer;
 743         int found = 0;
 744
 745         TDM_RETURN_IF_FAIL(layer_commit_handler != NULL);
 746
 747         private_display = private_output->private_display;
 748
 749         LIST_FOR_EACH_ENTRY(lm, &private_output->layer_commit_handler_list, link) {
 750                 if (layer_commit_handler == lm) {
 751                         found = 1;
 752                         break;
 753                 }
 754         }
 755
 756         if (!found)
 757                 return;
 758
 759         LIST_DEL(&layer_commit_handler->link);
 760
 761         private_layer = layer_commit_handler->private_layer;
 762
 763         private_layer->committing = 0;
 764
 765         if (tdm_debug_module & TDM_DEBUG_COMMIT)
 766                 TDM_INFO("layer(%p,%d) commit: output(%d) committed. handle(%p)",
 767                                  private_layer, private_layer->index, private_output->pipe, layer_commit_handler);
 768
 769         _pthread_mutex_lock(&private_display->lock);
 770
 771         tdm_layer_committed(private_layer, &layer_commit_handler->committed_buffer);
 772
 773         if (layer_commit_handler->func) {
 774                 _pthread_mutex_unlock(&private_display->lock);
 775                 layer_commit_handler->func(private_layer, sequence,
 776                                                                    tv_sec, tv_usec, layer_commit_handler->user_data);
 777                 _pthread_mutex_lock(&private_display->lock);
 778         }
 779
 780         free(layer_commit_handler);
 781
 782         _pthread_mutex_unlock(&private_display->lock);
 783 }
 784
 785 static void
 786 _tdm_layer_cb_wait_vblank(tdm_vblank *vblank, tdm_error error, unsigned int sequence,
 787                                                   unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 788 {
 789         tdm_private_output *private_output = user_data;
 790         tdm_private_display *private_display;
 791
 792         TDM_RETURN_IF_FAIL(private_output != NULL);
 793
 794         private_display = private_output->private_display;
 795
 796         _pthread_mutex_lock(&private_display->lock);
 797
 798         if (tdm_debug_module & TDM_DEBUG_COMMIT)
 799                 TDM_INFO("layer commit: output(%d) got vblank", private_output->pipe);
 800
 801         _tdm_layer_got_output_vblank(private_output, sequence, tv_sec, tv_usec);
 802
 803         _pthread_mutex_unlock(&private_display->lock);
 804 }
 805
 806 static unsigned int
 807 _tdm_lauer_get_output_used_layer_count(tdm_private_output *private_output)
 808 {
 809         tdm_private_layer *private_layer = NULL;
 810         unsigned int count = 0;
 811
 812         LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
 813                 if (!private_layer->usable)
 814                         count++;
 815         }
 816
 817         return count;
 818 }
 819
 820 /* commit_per_vblank == 1: we can commit if
 821  *                           - there is no previous commit request
 822  *                           - only 1 layer is used
 823  * commit_per_vblank == 2: we can commit if
 824  *                           - there is no previous commit request
 825  */
 826 static int
 827 _tdm_layer_commit_possible(tdm_private_layer *private_layer)
 828 {
 829         tdm_private_output *private_output = private_layer->private_output;
 830
 831         TDM_RETURN_VAL_IF_FAIL(private_output->commit_per_vblank > 0, 1);
 832
 833         /* There is a previous commit request which is not done and displayed on screen yet.
 834          * We can't commit at this time.
 835          */
 836         if (!LIST_IS_EMPTY(&private_output->layer_commit_handler_list)) {
 837                 if (tdm_debug_module & TDM_DEBUG_COMMIT)
 838                         TDM_INFO("layer(%p,%d) commit: not possible(previous commit)",
 839                                          private_layer, private_layer->index);
 840                 return 0;
 841         }
 842
 843         if (private_output->commit_per_vblank == 1 && _tdm_lauer_get_output_used_layer_count(private_output) > 1) {
 844                 if (tdm_debug_module & TDM_DEBUG_COMMIT)
 845                         TDM_INFO("layer(%p,%d) commit: not possible(more than 2 layers)",
 846                                          private_layer, private_layer->index);
 847                 return 0;
 848         }
 849
 850         if (tdm_debug_module & TDM_DEBUG_COMMIT)
 851                 TDM_INFO("layer(%p,%d) commit: possible", private_layer, private_layer->index);
 852
 853         return 1;
 854 }
 855
 856 static void
 857 _tdm_layer_reset_pending_data(tdm_private_layer *private_layer)
 858 {
 859         private_layer->pending_info_changed = 0;
 860         memset(&private_layer->pending_info, 0, sizeof private_layer->pending_info);
 861
 862         private_layer->pending_buffer_changed = 0;
 863         if (private_layer->pending_buffer) {
 864                 tbm_surface_internal_unref(private_layer->pending_buffer);
 865                 private_layer->pending_buffer = NULL;
 866         }
 867 }
 868
 869 INTERN tdm_error
 870 tdm_layer_commit_pending_data(tdm_private_layer *private_layer)
 871 {
 872         tdm_private_module *private_module;
 873         tdm_func_layer *func_layer;
 874         tdm_error ret = TDM_ERROR_NONE;
 875
 876         private_module = private_layer->private_module;
 877         func_layer = &private_module->func_layer;
 878
 879         if (private_layer->pending_info_changed) {
 880                 ret = func_layer->layer_set_info(private_layer->layer_backend, &private_layer->pending_info);
 881                 TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, done);
 882         }
 883
 884         if (private_layer->pending_buffer_changed) {
 885                 tdm_private_layer_buffer *layer_buffer;
 886
 887                 layer_buffer = calloc(1, sizeof(tdm_private_layer_buffer));
 888                 TDM_GOTO_IF_FAIL(layer_buffer != NULL, done);
 889
 890                 LIST_INITHEAD(&layer_buffer->link);
 891
 892                 ret = func_layer->layer_set_buffer(private_layer->layer_backend, private_layer->pending_buffer);
 893                 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 894
 895                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
 896                         TDM_INFO("layer(%p,%d) pending_buffer(%p) committed",
 897                                          private_layer, private_layer->index, private_layer->pending_buffer);
 898
 899                 if (ret == TDM_ERROR_NONE) {
 900                         if (private_layer->waiting_buffer)
 901                                 tdm_layer_free_buffer(private_layer, private_layer->waiting_buffer);
 902
 903                         private_layer->waiting_buffer = layer_buffer;
 904                         private_layer->waiting_buffer->buffer = tdm_buffer_ref_backend(private_layer->pending_buffer);
 905                         if (tdm_debug_module & TDM_DEBUG_BUFFER)
 906                                 TDM_INFO("layer(%p,%d) waiting_buffer(%p)",
 907                                                  private_layer, private_layer->index, private_layer->waiting_buffer->buffer);
 908                 } else
 909                         tdm_layer_free_buffer(private_layer, layer_buffer);
 910         }
 911
 912 done:
 913         _tdm_layer_reset_pending_data(private_layer);
 914
 915         return ret;
 916 }
 917
 918 /* CAUTION: Once _tdm_layer_commit returns success, the layer commit handler MUST be called always.
 919  * That is, even if we get error in _tdm_layer_got_output_vblank() function for some reasons,
 920  * the layer commit handler MUST be called.
 921  */
 922 static tdm_error
 923 _tdm_layer_commit(tdm_layer *layer, tdm_layer_commit_handler func, void *user_data)
 924 {
 925         tdm_private_layer_commit_handler *layer_commit_handler;
 926         LAYER_FUNC_ENTRY();
 927
 928         layer_commit_handler = calloc(1, sizeof(tdm_private_layer_commit_handler));
 929         if (!layer_commit_handler) {
 930                 /* LCOV_EXCL_START */
 931                 TDM_ERR("failed: alloc memory");
 932                 return TDM_ERROR_OUT_OF_MEMORY;
 933                 /* LCOV_EXCL_STOP */
 934         }
 935
 936         if (tdm_debug_module & TDM_DEBUG_COMMIT)
 937                 TDM_INFO("layer(%p,%d) commit: handle(%p)", private_layer, private_layer->index, layer_commit_handler);
 938
 939         LIST_INITHEAD(&layer_commit_handler->link);
 940         layer_commit_handler->private_layer = private_layer;
 941         layer_commit_handler->func = func;
 942         layer_commit_handler->user_data = user_data;
 943
 944         layer_commit_handler->committed_buffer = private_layer->waiting_buffer;
 945         private_layer->waiting_buffer = NULL;
 946
 947         if (!private_layer->committing && layer_commit_handler->committed_buffer)
 948                 private_layer->commiting_buffer = layer_commit_handler->committed_buffer->buffer;
 949
 950         if (private_layer->committing)
 951                 TDM_WRN("layer(%p,%d) too many commit", private_layer, private_layer->index);
 952         else
 953                 private_layer->committing = 1;
 954
 955         if (tdm_debug_module & TDM_DEBUG_BUFFER)
 956                 TDM_INFO("layer(%p,%d) waiting_buffer(%p) committed_buffer(%p)",
 957                                  private_layer, private_layer->index, private_layer->waiting_buffer,
 958                                  (layer_commit_handler->committed_buffer) ? layer_commit_handler->committed_buffer->buffer : NULL);
 959
 960         if (!private_output->commit_per_vblank) {
 961                 TDM_GOTO_IF_FAIL(private_output->commit_type == TDM_COMMIT_TYPE_OUTPUT, commit_failed);
 962
 963                 LIST_ADDTAIL(&layer_commit_handler->link, &private_output->layer_commit_handler_list);
 964                 ret = tdm_output_commit_internal(private_layer->private_output, 0, _tdm_layer_cb_output_commit, layer_commit_handler);
 965                 TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed);
 966
 967                 if (tdm_debug_module & TDM_DEBUG_COMMIT)
 968                         TDM_INFO("layer(%p,%d) commit: no commit-per-vblank", private_layer, private_layer->index);
 969         } else {
 970                 TDM_GOTO_IF_FAIL(private_output->commit_type == TDM_COMMIT_TYPE_LAYER, commit_failed);
 971
 972                 if (_tdm_layer_commit_possible(private_layer)) {
 973                         /* add to layer_commit_handler_list */
 974                         LIST_ADDTAIL(&layer_commit_handler->link, &private_output->layer_commit_handler_list);
 975                         ret = tdm_output_commit_internal(private_layer->private_output, 0, _tdm_layer_cb_output_commit, layer_commit_handler);
 976                         TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed);
 977
 978                         if (tdm_debug_module & TDM_DEBUG_COMMIT)
 979                                 TDM_INFO("layer(%p,%d) commit: output", private_layer, private_layer->index);
 980                 } else {
 981                         /* add to pending_commit_handler_list. It will be commited when a vblank occurs */
 982                         LIST_ADDTAIL(&layer_commit_handler->link, &private_output->pending_commit_handler_list);
 983
 984                         if (tdm_debug_module & TDM_DEBUG_COMMIT)
 985                                 TDM_INFO("layer(%p,%d) commit: pending", private_layer, private_layer->index);
 986                 }
 987
 988                 if (!private_output->vblank) {
 989                         /* tdm_vblank APIs is for server. it should be called in unlock status*/
 990                         _pthread_mutex_unlock(&private_display->lock);
 991                         private_output->vblank = tdm_vblank_create(private_display, private_output, NULL);
 992                         _pthread_mutex_lock(&private_display->lock);
 993                         TDM_GOTO_IF_FAIL(private_output->vblank != NULL, commit_failed);
 994                 }
 995
 996                 if (!private_output->layer_waiting_vblank) {
 997                         /* tdm_vblank APIs is for server. it should be called in unlock status*/
 998                         _pthread_mutex_unlock(&private_display->lock);
 999                         ret = tdm_vblank_wait(private_output->vblank, 0, 0, 1, _tdm_layer_cb_wait_vblank, private_output);
1000                         _pthread_mutex_lock(&private_display->lock);
1001                         TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed);
1002                         private_output->layer_waiting_vblank = 1;
1003
1004                         if (tdm_debug_module & TDM_DEBUG_COMMIT)
1005                                 TDM_INFO("layer(%p,%d) commit: wait vblank", private_layer, private_layer->index);
1006                 }
1007         }
1008
1009         return ret;
1010
1011 commit_failed:
1012         if (layer_commit_handler) {
1013                 private_layer->waiting_buffer = layer_commit_handler->committed_buffer;
1014                 LIST_DEL(&layer_commit_handler->link);
1015                 free(layer_commit_handler);
1016         }
1017         return ret;
1018 }
1019
1020 INTERN tdm_error
1021 tdm_layer_commit_internal(tdm_private_layer *private_layer, tdm_layer_commit_handler func, void *user_data)
1022 {
1023         tdm_private_output *private_output = private_layer->private_output;
1024         tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */
1025
1026         if (private_output->commit_type == TDM_COMMIT_TYPE_NONE) {
1027                 if (!private_output->commit_per_vblank)
1028                         private_output->commit_type = TDM_COMMIT_TYPE_OUTPUT;
1029                 else
1030                         private_output->commit_type = TDM_COMMIT_TYPE_LAYER;
1031         }
1032
1033         if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->current_dpms_value)) {
1034                 TDM_ERR("layer(%p,%d)'s output(%d) dpms: %s", private_layer, private_layer->index, private_output->pipe,
1035                                 tdm_dpms_str(private_output->current_dpms_value));
1036                 return TDM_ERROR_DPMS_OFF;
1037         }
1038
1039         /* don't call this inside of _tdm_layer_commit */
1040         ret = tdm_layer_commit_pending_data(private_layer);
1041         if (ret != TDM_ERROR_NONE) {
1042                 TDM_ERR("layer(%p,%d) committing pending data failed", private_layer, private_layer->index);
1043                 return ret;
1044         }
1045
1046         ret = _tdm_layer_commit(private_layer, func, user_data);
1047
1048         return ret;
1049 }
1050
1051 EXTERN tdm_error
1052 tdm_layer_commit(tdm_layer *layer, tdm_layer_commit_handler func, void *user_data)
1053 {
1054         LAYER_FUNC_ENTRY();
1055
1056         _pthread_mutex_lock(&private_display->lock);
1057
1058         ret = tdm_layer_commit_internal(private_layer, func, user_data);
1059
1060         _pthread_mutex_unlock(&private_display->lock);
1061
1062         return ret;
1063 }
1064
1065 EXTERN tdm_error
1066 tdm_layer_is_committing(tdm_layer *layer, unsigned int *committing)
1067 {
1068         LAYER_FUNC_ENTRY();
1069
1070         TDM_RETURN_VAL_IF_FAIL(committing != NULL, TDM_ERROR_INVALID_PARAMETER);
1071
1072         _pthread_mutex_lock(&private_display->lock);
1073
1074         *committing = private_layer->committing;
1075
1076         _pthread_mutex_unlock(&private_display->lock);
1077
1078         return ret;
1079 }
1080
1081 INTERN void
1082 tdm_layer_remove_commit_handler_internal(tdm_layer *layer, tdm_layer_commit_handler func, void *user_data)
1083 {
1084         tdm_private_layer *private_layer = (tdm_private_layer*)layer;
1085         tdm_private_output *private_output = private_layer->private_output;
1086         tdm_private_layer_commit_handler *lm = NULL, *lmm = NULL;
1087
1088         if (!func && !user_data)
1089                 return;
1090
1091         TDM_RETURN_IF_FAIL(private_layer != NULL);
1092         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
1093
1094         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->layer_commit_handler_list, link) {
1095                 if (lm->func == func && lm->user_data == user_data) {
1096                         LIST_DEL(&lm->link);
1097                         tdm_output_remove_commit_handler_internal(private_output, _tdm_layer_cb_output_commit, lm);
1098                         tdm_layer_free_buffer(private_layer, lm->committed_buffer);
1099                         free(lm);
1100                         break;
1101                 }
1102         }
1103
1104         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->pending_commit_handler_list, link) {
1105                 if (lm->func == func && lm->user_data == user_data) {
1106                         LIST_DEL(&lm->link);
1107                         tdm_output_remove_commit_handler_internal(private_output, _tdm_layer_cb_output_commit, lm);
1108                         tdm_layer_free_buffer(private_layer, lm->committed_buffer);
1109                         free(lm);
1110                         break;
1111                 }
1112         }
1113 }
1114
1115 EXTERN tdm_error
1116 tdm_layer_remove_commit_handler(tdm_layer *layer, tdm_layer_commit_handler func, void *user_data)
1117 {
1118         LAYER_FUNC_ENTRY();
1119
1120         _pthread_mutex_lock(&private_display->lock);
1121
1122         tdm_layer_remove_commit_handler_internal(layer, func, user_data);
1123
1124         _pthread_mutex_unlock(&private_display->lock);
1125
1126         return ret;
1127 }
1128
1129 EXTERN tbm_surface_h
1130 tdm_layer_get_displaying_buffer(tdm_layer *layer, tdm_error *error)
1131 {
1132         tbm_surface_h buffer;
1133         LAYER_FUNC_ENTRY_ERROR();
1134
1135         _pthread_mutex_lock(&private_display->lock);
1136
1137         if (error)
1138                 *error = TDM_ERROR_NONE;
1139
1140         if (private_layer->showing_buffer) {
1141                 buffer = private_layer->showing_buffer->buffer;
1142         } else {
1143                 _pthread_mutex_unlock(&private_display->lock);
1144                 TDM_DBG("layer(%p,%d) showing_buffer is null", private_layer, private_layer->index);
1145                 return NULL;
1146         }
1147         _pthread_mutex_unlock(&private_display->lock);
1148
1149         return buffer;
1150 }
1151
1152 static void
1153 _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
1154 {
1155         TDM_RETURN_IF_FAIL(data != NULL);
1156         tdm_layer *layer = data;
1157         tdm_private_module *private_module;
1158         tdm_func_layer *func_layer;
1159         tbm_surface_h buffer = NULL;
1160         LAYER_FUNC_ENTRY_VOID_RETURN();
1161
1162         _pthread_mutex_lock(&private_display->lock);
1163
1164         private_module = private_layer->private_module;
1165         func_layer = &private_module->func_layer;
1166
1167         if (!func_layer->layer_set_buffer) {
1168                 /* LCOV_EXCL_START */
1169                 _pthread_mutex_unlock(&private_display->lock);
1170                 return;
1171                 /* LCOV_EXCL_STOP */
1172         }
1173
1174         if (TBM_SURFACE_QUEUE_ERROR_NONE != tbm_surface_queue_acquire(private_layer->buffer_queue, &buffer) ||
1175                 buffer == NULL) {
1176                 /* LCOV_EXCL_START */
1177                 TDM_ERR("layer(%p,%d) tbm_surface_queue_acquire() failed surface:%p",
1178                                 private_layer, private_layer->index, buffer);
1179                 _pthread_mutex_unlock(&private_display->lock);
1180                 return;
1181                 /* LCOV_EXCL_STOP */
1182         }
1183
1184         ret = tdm_layer_set_buffer_internal(private_layer, buffer);
1185         if (ret != TDM_ERROR_NONE) {
1186                 TDM_ERR("tdm_layer_set_buffer_internal failed");
1187                 _pthread_mutex_unlock(&private_display->lock);
1188                 return;
1189         }
1190
1191         ret = tdm_layer_commit_internal(private_layer, NULL, NULL);
1192         if (ret != TDM_ERROR_NONE) {
1193                 TDM_ERR("tdm_layer_commit_internal failed");
1194                 _pthread_mutex_unlock(&private_display->lock);
1195                 return;
1196         }
1197
1198         _pthread_mutex_unlock(&private_display->lock);
1199 }
1200
1201 static void
1202 _tbm_layer_queue_destroy_cb(tbm_surface_queue_h surface_queue, void *data)
1203 {
1204         TDM_RETURN_IF_FAIL(data != NULL);
1205         tdm_layer *layer = data;
1206         LAYER_FUNC_ENTRY_VOID_RETURN();
1207         TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
1208
1209         _pthread_mutex_lock(&private_display->lock);
1210
1211         private_layer->buffer_queue = NULL;
1212
1213         _tdm_layer_free_all_buffers(private_layer);
1214
1215         _pthread_mutex_unlock(&private_display->lock);
1216 }
1217
1218 EXTERN tdm_error
1219 tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
1220 {
1221         tdm_private_module *private_module;
1222         tdm_func_layer *func_layer;
1223         LAYER_FUNC_ENTRY();
1224
1225         TDM_RETURN_VAL_IF_FAIL(buffer_queue != NULL, TDM_ERROR_INVALID_PARAMETER);
1226
1227         _pthread_mutex_lock(&private_display->lock);
1228
1229         private_module = private_layer->private_module;
1230         func_layer = &private_module->func_layer;
1231
1232         if (private_layer->usable)
1233                 TDM_INFO("layer(%p,%d) not usable", private_layer, private_layer->index);
1234
1235         private_layer->usable = 0;
1236
1237         if (!func_layer->layer_set_buffer) {
1238                 /* LCOV_EXCL_START */
1239                 _pthread_mutex_unlock(&private_display->lock);
1240                 TDM_ERR("not implemented!!");
1241                 return TDM_ERROR_NOT_IMPLEMENTED;
1242                 /* LCOV_EXCL_STOP */
1243         }
1244
1245         if (buffer_queue == private_layer->buffer_queue) {
1246                 _pthread_mutex_unlock(&private_display->lock);
1247                 return TDM_ERROR_NONE;
1248         }
1249
1250         if (private_layer->waiting_buffer) {
1251                 tdm_layer_free_buffer(private_layer, private_layer->waiting_buffer);
1252                 private_layer->waiting_buffer = NULL;
1253
1254                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
1255                         TDM_INFO("layer(%p,%d) waiting_buffer(%p)",
1256                                          private_layer, private_layer->index, private_layer->waiting_buffer);
1257         }
1258
1259         private_layer->buffer_queue = buffer_queue;
1260         tbm_surface_queue_add_acquirable_cb(private_layer->buffer_queue,
1261                                                                                 _tbm_layer_queue_acquirable_cb,
1262                                                                                 private_layer);
1263         tbm_surface_queue_add_destroy_cb(private_layer->buffer_queue,
1264                                                                          _tbm_layer_queue_destroy_cb,
1265                                                                          private_layer);
1266         _pthread_mutex_unlock(&private_display->lock);
1267
1268         return ret;
1269 }
1270
1271 tdm_error
1272 tdm_layer_get_own_buffer_queue(tdm_layer *layer, tbm_surface_queue_h *buffer_queue)
1273 {
1274         LAYER_FUNC_ENTRY();
1275
1276         TDM_RETURN_VAL_IF_FAIL(buffer_queue != NULL, TDM_ERROR_INVALID_PARAMETER);
1277
1278         _pthread_mutex_lock(&private_display->lock);
1279
1280         _pthread_mutex_unlock(&private_display->lock);
1281
1282         return ret;
1283 }
1284
1285 EXTERN tdm_error
1286 tdm_layer_unset_buffer_queue(tdm_layer *layer)
1287 {
1288         return tdm_layer_unset_buffer(layer);
1289 }
1290
1291 EXTERN tdm_error
1292 tdm_layer_is_usable(tdm_layer *layer, unsigned int *usable)
1293 {
1294         LAYER_FUNC_ENTRY();
1295
1296         TDM_RETURN_VAL_IF_FAIL(usable != NULL, TDM_ERROR_INVALID_PARAMETER);
1297
1298         _pthread_mutex_lock(&private_display->lock);
1299
1300         *usable = private_layer->usable;
1301
1302         _pthread_mutex_unlock(&private_display->lock);
1303
1304         return ret;
1305 }
1306
1307 EXTERN tdm_error
1308 tdm_layer_set_video_pos(tdm_layer *layer, int zpos)
1309 {
1310         tdm_private_module *private_module;
1311         tdm_func_layer *func_layer;
1312         LAYER_FUNC_ENTRY();
1313
1314         _pthread_mutex_lock(&private_display->lock);
1315
1316         private_module = private_layer->private_module;
1317         func_layer = &private_module->func_layer;
1318
1319         if (!(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)) {
1320                 TDM_ERR("layer(%p,%d) is not video layer", private_layer, private_layer->index);
1321                 _pthread_mutex_unlock(&private_display->lock);
1322                 return TDM_ERROR_BAD_REQUEST;
1323         }
1324
1325         if (!func_layer->layer_set_video_pos) {
1326                 /* LCOV_EXCL_START */
1327                 _pthread_mutex_unlock(&private_display->lock);
1328                 TDM_ERR("layer(%p,%d) not implemented!!", private_layer, private_layer->index);
1329                 return TDM_ERROR_NOT_IMPLEMENTED;
1330                 /* LCOV_EXCL_STOP */
1331         }
1332
1333         ret = func_layer->layer_set_video_pos(private_layer->layer_backend, zpos);
1334
1335         _pthread_mutex_unlock(&private_display->lock);
1336
1337         return ret;
1338 }
1339
1340 EXTERN tdm_capture *
1341 tdm_layer_create_capture(tdm_layer *layer, tdm_error *error)
1342 {
1343         tdm_capture *capture = NULL;
1344
1345         LAYER_FUNC_ENTRY_ERROR();
1346
1347         _pthread_mutex_lock(&private_display->lock);
1348
1349         capture = (tdm_capture *)tdm_capture_create_layer_internal(private_layer, error);
1350
1351         _pthread_mutex_unlock(&private_display->lock);
1352
1353         return capture;
1354 }
1355
1356 EXTERN tdm_error
1357 tdm_layer_get_buffer_flags(tdm_layer *layer, unsigned int *flags)
1358 {
1359         tdm_private_module *private_module;
1360         tdm_func_layer *func_layer;
1361         LAYER_FUNC_ENTRY();
1362         TDM_RETURN_VAL_IF_FAIL(flags != NULL, TDM_ERROR_INVALID_PARAMETER);
1363
1364         _pthread_mutex_lock(&private_display->lock);
1365
1366         private_module = private_layer->private_module;
1367         func_layer = &private_module->func_layer;
1368
1369         if (!func_layer->layer_get_buffer_flags) {
1370                 /* LCOV_EXCL_START */
1371                 *flags = 0;
1372                 _pthread_mutex_unlock(&private_display->lock);
1373                 TDM_INFO("not implemented!!");
1374                 return TDM_ERROR_NONE;
1375                 /* LCOV_EXCL_STOP */
1376         }
1377
1378         ret = func_layer->layer_get_buffer_flags(private_layer->layer_backend, flags);
1379
1380         _pthread_mutex_unlock(&private_display->lock);
1381
1382         return ret;
1383 }