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