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