src/tdm_layer.c

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