src/tdm_layer.c

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