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