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         char fname[PATH_MAX], bufs[PATH_MAX];
 285         int zpos, len = PATH_MAX;
 286         tdm_private_layer *l = NULL;
 287         char *p = bufs;
 288         int *remain = &len;
 289
 290         pipe = private_output->pipe;
 291         zpos = private_layer->caps.zpos;
 292
 293         bufs[0] = '\0';
 294         LIST_FOR_EACH_ENTRY(l, &private_output->layer_list, link) {
 295                 if (!l->showing_buffer)
 296                         continue;
 297                 TDM_SNPRINTF(p, remain, "_%p", l->showing_buffer->buffer);
 298         }
 299
 300         snprintf(fname, sizeof(fname), "tdm_%d_lyr_%d%s", pipe, zpos, bufs);
 301
 302         tbm_surface_internal_dump_buffer(buffer, fname);
 303         TDM_DBG("%s dump excute", fname);
 304
 305         return;
 306 }
 307
 308 static void
 309 _tdm_layer_free_buffer(tdm_private_layer *private_layer, tdm_private_layer_buffer *layer_buffer)
 310 {
 311         tdm_private_display *private_display;
 312
 313         if (!layer_buffer)
 314                 return;
 315
 316         private_display = private_layer->private_output->private_display;
 317
 318         LIST_DEL(&layer_buffer->link);
 319         if (layer_buffer->buffer) {
 320                 _pthread_mutex_unlock(&private_display->lock);
 321                 tdm_buffer_unref_backend(layer_buffer->buffer);
 322                 if (private_layer->buffer_queue)
 323                         tbm_surface_queue_release(private_layer->buffer_queue, layer_buffer->buffer);
 324                 _pthread_mutex_lock(&private_display->lock);
 325         }
 326         free(layer_buffer);
 327 }
 328
 329 static void
 330 _tdm_layer_free_all_buffers(tdm_private_layer *private_layer)
 331 {
 332         tdm_private_output *private_output = private_layer->private_output;
 333         tdm_private_layer_commit_handler *lm = NULL, *lmm = NULL;
 334         struct list_head clone_list;
 335
 336         LIST_INITHEAD(&clone_list);
 337
 338         if (private_layer->waiting_buffer) {
 339                 _tdm_layer_free_buffer(private_layer, private_layer->waiting_buffer);
 340                 private_layer->waiting_buffer = NULL;
 341
 342                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
 343                         TDM_INFO("layer(%p) waiting_buffer(%p)",
 344                                          private_layer, private_layer->waiting_buffer);
 345         }
 346
 347         if (private_layer->committed_buffer) {
 348                 _tdm_layer_free_buffer(private_layer, private_layer->committed_buffer);
 349                 private_layer->committed_buffer = NULL;
 350
 351                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
 352                         TDM_INFO("layer(%p) committed_buffer(%p)",
 353                                          private_layer, private_layer->committed_buffer);
 354         }
 355
 356         if (private_layer->showing_buffer) {
 357                 _tdm_layer_free_buffer(private_layer, private_layer->showing_buffer);
 358                 private_layer->showing_buffer = NULL;
 359
 360                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
 361                         TDM_INFO("layer(%p) showing_buffer(%p)",
 362                                          private_layer, private_layer->showing_buffer);
 363         }
 364
 365         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->layer_commit_handler_list, link) {
 366                 if (lm->private_layer != private_layer)
 367                         continue;
 368                 LIST_DEL(&lm->link);
 369                 LIST_ADDTAIL(&lm->link, &clone_list);
 370         }
 371
 372         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &clone_list, link) {
 373                 LIST_DEL(&lm->link);
 374                 tdm_output_remove_commit_handler_internal(private_output, _tdm_layer_cb_output_commit, lm);
 375                 _tdm_layer_free_buffer(private_layer, lm->committed_buffer);
 376                 free(lm);
 377         }
 378
 379         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->pending_commit_handler_list, link) {
 380                 if (lm->private_layer != private_layer)
 381                         continue;
 382                 LIST_DEL(&lm->link);
 383                 LIST_ADDTAIL(&lm->link, &clone_list);
 384         }
 385
 386         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &clone_list, link) {
 387                 LIST_DEL(&lm->link);
 388                 _tdm_layer_free_buffer(private_layer, lm->committed_buffer);
 389                 free(lm);
 390         }
 391
 392         if (private_layer->buffer_queue) {
 393                 tbm_surface_queue_remove_acquirable_cb(private_layer->buffer_queue, _tbm_layer_queue_acquirable_cb, private_layer);
 394                 tbm_surface_queue_remove_destroy_cb(private_layer->buffer_queue, _tbm_layer_queue_destroy_cb, private_layer);
 395                 private_layer->buffer_queue = NULL;
 396         }
 397 }
 398
 399 EXTERN tdm_error
 400 tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
 401 {
 402         tdm_func_layer *func_layer;
 403         tdm_private_layer_buffer *layer_buffer;
 404
 405         LAYER_FUNC_ENTRY();
 406
 407         TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER);
 408
 409         _pthread_mutex_lock(&private_display->lock);
 410
 411         if (tdm_debug_dump & TDM_DUMP_FLAG_LAYER &&
 412                 !(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)) {
 413                 char str[TDM_PATH_LEN];
 414                 static int i;
 415                 snprintf(str, TDM_PATH_LEN, "layer_%d_%d_%03d",
 416                                  private_output->index, private_layer->index, i++);
 417                 tdm_helper_dump_buffer_str(buffer, tdm_debug_dump_dir, str);
 418         }
 419
 420         func_layer = &private_display->func_layer;
 421
 422         if (private_layer->usable)
 423                 TDM_INFO("layer(%p) not usable", private_layer);
 424
 425         private_layer->usable = 0;
 426
 427         if (!func_layer->layer_set_buffer) {
 428                 _pthread_mutex_unlock(&private_display->lock);
 429                 TDM_ERR("not implemented!!");
 430                 return TDM_ERROR_NOT_IMPLEMENTED;
 431         }
 432
 433         layer_buffer = calloc(1, sizeof(tdm_private_layer_buffer));
 434         if (!layer_buffer) {
 435                 _pthread_mutex_unlock(&private_display->lock);
 436                 TDM_ERR("alloc failed");
 437                 return TDM_ERROR_OUT_OF_MEMORY;
 438         }
 439         LIST_INITHEAD(&layer_buffer->link);
 440
 441         ret = func_layer->layer_set_buffer(private_layer->layer_backend, buffer);
 442         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 443
 444         if (ret == TDM_ERROR_NONE) {
 445                 if (private_layer->waiting_buffer)
 446                         _tdm_layer_free_buffer(private_layer, private_layer->waiting_buffer);
 447
 448                 private_layer->waiting_buffer = layer_buffer;
 449                 private_layer->waiting_buffer->buffer = tdm_buffer_ref_backend(buffer);
 450                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
 451                         TDM_INFO("layer(%p) waiting_buffer(%p)",
 452                                          private_layer, private_layer->waiting_buffer->buffer);
 453         } else
 454                 _tdm_layer_free_buffer(private_layer, layer_buffer);
 455
 456         _pthread_mutex_unlock(&private_display->lock);
 457
 458         return ret;
 459 }
 460
 461 EXTERN tdm_error
 462 tdm_layer_unset_buffer(tdm_layer *layer)
 463 {
 464         tdm_func_layer *func_layer;
 465         LAYER_FUNC_ENTRY();
 466
 467         _pthread_mutex_lock(&private_display->lock);
 468
 469         func_layer = &private_display->func_layer;
 470
 471         _tdm_layer_free_all_buffers(private_layer);
 472
 473         private_layer->usable = 1;
 474
 475         if (private_layer->usable)
 476                 TDM_INFO("layer(%p) now usable", private_layer);
 477
 478         if (!func_layer->layer_unset_buffer) {
 479                 _pthread_mutex_unlock(&private_display->lock);
 480                 TDM_ERR("not implemented!!");
 481                 return TDM_ERROR_NOT_IMPLEMENTED;
 482         }
 483
 484         ret = func_layer->layer_unset_buffer(private_layer->layer_backend);
 485         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 486
 487         _pthread_mutex_unlock(&private_display->lock);
 488
 489         return ret;
 490 }
 491
 492 INTERN void
 493 tdm_layer_committed(tdm_private_layer *private_layer, tdm_private_layer_buffer **committed_buffer)
 494 {
 495         tdm_private_output *private_output = private_layer->private_output;
 496         tdm_private_display *private_display = private_output->private_display;
 497
 498         if (private_display->print_fps) {
 499                 double curr = tdm_helper_get_time();
 500                 if (private_layer->fps_stamp == 0) {
 501                         private_layer->fps_stamp = curr;
 502                 } else if ((curr - private_layer->fps_stamp) > 1.0) {
 503                         TDM_INFO("output(%d) layer(%d) fps: %d", private_output->index, private_layer->index, private_layer->fps_count);
 504                         private_layer->fps_count = 0;
 505                         private_layer->fps_stamp = curr;
 506                 } else
 507                         private_layer->fps_count++;
 508         } else if (private_layer->fps_stamp != 0) {
 509                 private_layer->fps_stamp = 0;
 510                 private_layer->fps_count = 0;
 511         }
 512
 513         if (private_layer->showing_buffer)
 514                 _tdm_layer_free_buffer(private_layer, private_layer->showing_buffer);
 515
 516         private_layer->showing_buffer = *committed_buffer;
 517         *committed_buffer = NULL;
 518
 519         /* dump buffer */
 520         if (tdm_dump_enable && !(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO) && private_layer->showing_buffer)
 521                 _tdm_layer_dump_buffer(private_layer, private_layer->showing_buffer->buffer);
 522
 523         if (tdm_debug_module & TDM_DEBUG_BUFFER)
 524                 TDM_INFO("layer(%p) committed_buffer(%p) showing_buffer(%p)",
 525                                  private_layer, *committed_buffer,
 526                                  (private_layer->showing_buffer) ? private_layer->showing_buffer->buffer : NULL);
 527 }
 528
 529 static void
 530 _tdm_layer_got_output_vblank(tdm_private_output *private_output, unsigned int sequence,
 531                                                          unsigned int tv_sec, unsigned int tv_usec)
 532 {
 533         tdm_private_layer_commit_handler *lm = NULL, *lmm = NULL;
 534         tdm_private_display *private_display;
 535         struct list_head clone_list, pending_clone_list;
 536         tdm_error ret = TDM_ERROR_NONE;
 537
 538         private_display = private_output->private_display;
 539
 540         private_output->layer_waiting_vblank = 0;
 541
 542         LIST_INITHEAD(&clone_list);
 543         LIST_INITHEAD(&pending_clone_list);
 544
 545         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->layer_commit_handler_list, link) {
 546                 LIST_DEL(&lm->link);
 547                 lm->private_layer->committing = 0;
 548                 LIST_ADDTAIL(&lm->link, &clone_list);
 549         }
 550
 551         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->pending_commit_handler_list, link) {
 552                 LIST_DEL(&lm->link);
 553                 lm->private_layer->committing = 0;
 554                 LIST_ADDTAIL(&lm->link, &pending_clone_list);
 555         }
 556
 557         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &clone_list, link) {
 558                 if (tdm_debug_module & TDM_DEBUG_COMMIT)
 559                         TDM_INFO("layer(%p) committed. handle(%p) commited_buffer(%p)",
 560                                          lm->private_layer, lm, (lm->committed_buffer) ? lm->committed_buffer->buffer : NULL);
 561
 562                 LIST_DEL(&lm->link);
 563                 tdm_layer_committed(lm->private_layer, &lm->committed_buffer);
 564                 _pthread_mutex_unlock(&private_display->lock);
 565                 if (lm->func)
 566                         lm->func(lm->private_layer, sequence, tv_sec, tv_usec, lm->user_data);
 567                 _pthread_mutex_lock(&private_display->lock);
 568                 if (lm->committed_buffer)
 569                         _tdm_layer_free_buffer(lm->private_layer, lm->committed_buffer);
 570                 free(lm);
 571         }
 572
 573         if (LIST_IS_EMPTY(&pending_clone_list))
 574                 return;
 575
 576         TDM_GOTO_IF_FAIL(private_output->vblank != NULL, wait_failed);
 577
 578         ret = tdm_output_commit_internal(private_output, 0, NULL, NULL);
 579         TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, wait_failed);
 580
 581         if (tdm_debug_module & TDM_DEBUG_COMMIT)
 582                 TDM_INFO("layer commit: output(%d) commit", private_output->pipe);
 583
 584         if (private_output->current_dpms_value == TDM_OUTPUT_DPMS_ON) {
 585                 /* tdm_vblank APIs is for server. it should be called in unlock status*/
 586                 if (!private_output->layer_waiting_vblank) {
 587                         _pthread_mutex_unlock(&private_display->lock);
 588                         ret = tdm_vblank_wait(private_output->vblank, 0, 0, 1, _tdm_layer_cb_wait_vblank, private_output);
 589                         _pthread_mutex_lock(&private_display->lock);
 590                         TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, wait_failed);
 591                         private_output->layer_waiting_vblank = 1;
 592                 }
 593         }
 594
 595         if (tdm_debug_module & TDM_DEBUG_COMMIT)
 596                 TDM_INFO("layer commit: output(%d) wait vblank", private_output->pipe);
 597
 598         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &pending_clone_list, link) {
 599                 LIST_DEL(&lm->link);
 600                 LIST_ADDTAIL(&lm->link, &private_output->layer_commit_handler_list);
 601         }
 602
 603         if (private_output->current_dpms_value != TDM_OUTPUT_DPMS_ON) {
 604                 TDM_WRN("TDM_OUTPUT_DPMS_OFF. Directly call vblank callback.");
 605                 _pthread_mutex_unlock(&private_display->lock);
 606                 _tdm_layer_cb_wait_vblank(private_output->vblank, 0, 0, 0, 0, private_output);
 607                 _pthread_mutex_lock(&private_display->lock);
 608         }
 609
 610         return;
 611 wait_failed:
 612         /* CAUTION: Once _tdm_layer_commit returns success, the layer commit handler MUST be called always.
 613          * That is, even if we get error in _tdm_layer_got_output_vblank() function for some reasons,
 614          * the layer commit handler MUST be called.
 615          */
 616         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &pending_clone_list, link) {
 617                 TDM_WRN("Directly call layer commit handlers: ret(%d)\n", ret);
 618                 LIST_DEL(&lm->link);
 619                 _pthread_mutex_unlock(&private_display->lock);
 620                 if (lm->func)
 621                         lm->func(lm->private_layer, sequence, tv_sec, tv_usec, lm->user_data);
 622                 _pthread_mutex_lock(&private_display->lock);
 623                 _tdm_layer_free_buffer(lm->private_layer, lm->committed_buffer);
 624                 free(lm);
 625         }
 626
 627         return;
 628 }
 629
 630 static void
 631 _tdm_layer_cb_output_commit(tdm_output *output, unsigned int sequence,
 632                                                         unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 633 {
 634         tdm_private_layer_commit_handler *layer_commit_handler = user_data;
 635         tdm_private_layer_commit_handler *lm = NULL;
 636         tdm_private_display *private_display;
 637         tdm_private_output *private_output = output;
 638         tdm_private_layer *private_layer;
 639         int found = 0;
 640
 641         TDM_RETURN_IF_FAIL(layer_commit_handler != NULL);
 642
 643         private_display = private_output->private_display;
 644
 645         LIST_FOR_EACH_ENTRY(lm, &private_output->layer_commit_handler_list, link) {
 646                 if (layer_commit_handler == lm) {
 647                         found = 1;
 648                         break;
 649                 }
 650         }
 651
 652         if (!found)
 653                 return;
 654
 655         private_layer = layer_commit_handler->private_layer;
 656
 657         if (tdm_debug_module & TDM_DEBUG_COMMIT)
 658                 TDM_INFO("layer(%p) commit: output(%d) committed. handle(%p)",
 659                                  private_layer, private_output->pipe, layer_commit_handler);
 660
 661         _pthread_mutex_lock(&private_display->lock);
 662
 663         tdm_layer_committed(private_layer, &layer_commit_handler->committed_buffer);
 664
 665         if (layer_commit_handler->func) {
 666                 _pthread_mutex_unlock(&private_display->lock);
 667                 layer_commit_handler->func(private_output, sequence,
 668                                                                    tv_sec, tv_usec, layer_commit_handler->user_data);
 669                 _pthread_mutex_lock(&private_display->lock);
 670         }
 671
 672         LIST_DEL(&layer_commit_handler->link);
 673         free(layer_commit_handler);
 674
 675         _pthread_mutex_unlock(&private_display->lock);
 676 }
 677
 678 static void
 679 _tdm_layer_cb_wait_vblank(tdm_vblank *vblank, tdm_error error, unsigned int sequence,
 680                                                   unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 681 {
 682         tdm_private_output *private_output = user_data;
 683         tdm_private_display *private_display;
 684
 685         TDM_RETURN_IF_FAIL(private_output != NULL);
 686
 687         private_display = private_output->private_display;
 688
 689         _pthread_mutex_lock(&private_display->lock);
 690
 691         if (tdm_debug_module & TDM_DEBUG_COMMIT)
 692                 TDM_INFO("layer commit: output(%d) got vblank", private_output->pipe);
 693
 694         _tdm_layer_got_output_vblank(private_output, sequence, tv_sec, tv_usec);
 695
 696         _pthread_mutex_unlock(&private_display->lock);
 697 }
 698
 699 static unsigned int
 700 _tdm_lauer_get_output_used_layer_count(tdm_private_output *private_output)
 701 {
 702         tdm_private_layer *private_layer = NULL;
 703         unsigned int count = 0;
 704
 705         LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
 706                 if (!private_layer->usable)
 707                         count++;
 708         }
 709
 710         return count;
 711 }
 712
 713 /* commit_per_vblank == 1: we can commit if
 714  *                           - there is no previous commit request
 715  *                           - only 1 layer is used
 716  * commit_per_vblank == 2: we can commit if
 717  *                           - there is no previous commit request
 718  */
 719 static int
 720 _tdm_layer_commit_possible(tdm_private_layer *private_layer)
 721 {
 722         tdm_private_output *private_output = private_layer->private_output;
 723         tdm_private_display *private_display = private_output->private_display;
 724
 725         TDM_RETURN_VAL_IF_FAIL(private_display->commit_per_vblank > 0, 1);
 726
 727         /* There is a previous commit request which is not done and displayed on screen yet.
 728          * We can't commit at this time.
 729          */
 730         if (!LIST_IS_EMPTY(&private_output->layer_commit_handler_list)) {
 731                 if (tdm_debug_module & TDM_DEBUG_COMMIT)
 732                         TDM_INFO("layer(%p) commit: not possible(previous commit)", private_layer);
 733                 return 0;
 734         }
 735
 736         if (private_display->commit_per_vblank == 1 && _tdm_lauer_get_output_used_layer_count(private_output) > 1) {
 737                 if (tdm_debug_module & TDM_DEBUG_COMMIT)
 738                         TDM_INFO("layer(%p) commit: not possible(more than 2 layers)", private_layer);
 739                 return 0;
 740         }
 741
 742         if (tdm_debug_module & TDM_DEBUG_COMMIT)
 743                 TDM_INFO("layer(%p) commit: possible", private_layer);
 744
 745         return 1;
 746 }
 747
 748 /* CAUTION: Once _tdm_layer_commit returns success, the layer commit handler MUST be called always.
 749  * That is, even if we get error in _tdm_layer_got_output_vblank() function for some reasons,
 750  * the layer commit handler MUST be called.
 751  */
 752 static tdm_error
 753 _tdm_layer_commit(tdm_layer *layer, tdm_layer_commit_handler func, void *user_data)
 754 {
 755         tdm_private_layer_commit_handler *layer_commit_handler;
 756         LAYER_FUNC_ENTRY();
 757
 758         layer_commit_handler = calloc(1, sizeof(tdm_private_layer_commit_handler));
 759         if (!layer_commit_handler) {
 760                 TDM_ERR("failed: alloc memory");
 761                 return TDM_ERROR_OUT_OF_MEMORY;
 762         }
 763
 764         if (tdm_debug_module & TDM_DEBUG_COMMIT)
 765                 TDM_INFO("layer(%p) commit: handle(%p)", private_layer, layer_commit_handler);
 766
 767         LIST_INITHEAD(&layer_commit_handler->link);
 768         layer_commit_handler->private_layer = private_layer;
 769         layer_commit_handler->func = func;
 770         layer_commit_handler->user_data = user_data;
 771
 772         layer_commit_handler->committed_buffer = private_layer->waiting_buffer;
 773         private_layer->waiting_buffer = NULL;
 774
 775         if (tdm_debug_module & TDM_DEBUG_BUFFER)
 776                 TDM_INFO("layer(%p) waiting_buffer(%p) committed_buffer(%p)",
 777                                  private_layer, private_layer->waiting_buffer,
 778                                  (layer_commit_handler->committed_buffer) ? layer_commit_handler->committed_buffer->buffer : NULL);
 779
 780         if (!private_display->commit_per_vblank) {
 781                 TDM_GOTO_IF_FAIL(private_display->commit_type == TDM_COMMIT_TYPE_OUTPUT, commit_failed);
 782
 783                 LIST_ADDTAIL(&layer_commit_handler->link, &private_output->layer_commit_handler_list);
 784                 ret = tdm_output_commit_internal(private_layer->private_output, 0, _tdm_layer_cb_output_commit, layer_commit_handler);
 785                 TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed);
 786
 787                 if (tdm_debug_module & TDM_DEBUG_COMMIT)
 788                         TDM_INFO("layer(%p) commit: no commit-per-vblank", private_layer);
 789         } else {
 790                 TDM_GOTO_IF_FAIL(private_display->commit_type == TDM_COMMIT_TYPE_LAYER, commit_failed);
 791
 792                 if (private_layer->committing)
 793                         TDM_WRN("layer(%d) too many commit", private_layer->index);
 794                 else
 795                         private_layer->committing = 1;
 796
 797                 if (_tdm_layer_commit_possible(private_layer)) {
 798                         /* add to layer_commit_handler_list */
 799                         LIST_ADDTAIL(&layer_commit_handler->link, &private_output->layer_commit_handler_list);
 800                         ret = tdm_output_commit_internal(private_layer->private_output, 0, NULL, NULL);
 801                         TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed);
 802
 803                         if (tdm_debug_module & TDM_DEBUG_COMMIT)
 804                                 TDM_INFO("layer(%p) commit: output", private_layer);
 805                 } else {
 806                         /* add to pending_commit_handler_list. It will be commited when a vblank occurs */
 807                         LIST_ADDTAIL(&layer_commit_handler->link, &private_output->pending_commit_handler_list);
 808
 809                         if (tdm_debug_module & TDM_DEBUG_COMMIT)
 810                                 TDM_INFO("layer(%p) commit: pending", private_layer);
 811                 }
 812
 813                 if (!private_output->vblank) {
 814                         /* tdm_vblank APIs is for server. it should be called in unlock status*/
 815                         _pthread_mutex_unlock(&private_display->lock);
 816                         private_output->vblank = tdm_vblank_create(private_display, private_output, NULL);
 817                         _pthread_mutex_lock(&private_display->lock);
 818                         TDM_GOTO_IF_FAIL(private_output->vblank != NULL, commit_failed);
 819                 }
 820
 821                 if (!private_output->layer_waiting_vblank) {
 822                         /* tdm_vblank APIs is for server. it should be called in unlock status*/
 823                         _pthread_mutex_unlock(&private_display->lock);
 824                         ret = tdm_vblank_wait(private_output->vblank, 0, 0, 1, _tdm_layer_cb_wait_vblank, private_output);
 825                         _pthread_mutex_lock(&private_display->lock);
 826                         TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed);
 827                         private_output->layer_waiting_vblank = 1;
 828
 829                         if (tdm_debug_module & TDM_DEBUG_COMMIT)
 830                                 TDM_INFO("layer(%p) commit: wait vblank", private_layer);
 831                 }
 832         }
 833
 834         return ret;
 835
 836 commit_failed:
 837         if (layer_commit_handler) {
 838                 private_layer->waiting_buffer = layer_commit_handler->committed_buffer;
 839                 LIST_DEL(&layer_commit_handler->link);
 840                 free(layer_commit_handler);
 841         }
 842         return ret;
 843 }
 844
 845 EXTERN tdm_error
 846 tdm_layer_commit(tdm_layer *layer, tdm_layer_commit_handler func, void *user_data)
 847 {
 848         LAYER_FUNC_ENTRY();
 849
 850         _pthread_mutex_lock(&private_display->lock);
 851
 852         if (private_display->commit_type == TDM_COMMIT_TYPE_NONE) {
 853                 if (!private_display->commit_per_vblank)
 854                         private_display->commit_type = TDM_COMMIT_TYPE_OUTPUT;
 855                 else
 856                         private_display->commit_type = TDM_COMMIT_TYPE_LAYER;
 857         }
 858
 859         if (private_output->current_dpms_value > TDM_OUTPUT_DPMS_ON) {
 860                 TDM_ERR("layer(%p)'s output(%d) dpms: %s", layer, private_output->pipe,
 861                                 tdm_dpms_str(private_output->current_dpms_value));
 862                 _pthread_mutex_unlock(&private_display->lock);
 863                 return TDM_ERROR_DPMS_OFF;
 864         }
 865
 866         ret = _tdm_layer_commit(private_layer, func, user_data);
 867
 868         _pthread_mutex_unlock(&private_display->lock);
 869
 870         return ret;
 871 }
 872
 873 EXTERN tdm_error
 874 tdm_layer_is_committing(tdm_layer *layer, unsigned int *committing)
 875 {
 876         LAYER_FUNC_ENTRY();
 877
 878         TDM_RETURN_VAL_IF_FAIL(committing != NULL, TDM_ERROR_INVALID_PARAMETER);
 879
 880         _pthread_mutex_lock(&private_display->lock);
 881
 882         *committing = private_layer->committing;
 883
 884         _pthread_mutex_unlock(&private_display->lock);
 885
 886         return ret;
 887 }
 888
 889 INTERN void
 890 tdm_layer_remove_commit_handler_internal(tdm_layer *layer, tdm_layer_commit_handler func, void *user_data)
 891 {
 892         tdm_private_layer *private_layer = (tdm_private_layer*)layer;
 893         tdm_private_output *private_output = private_layer->private_output;
 894         tdm_private_layer_commit_handler *lm = NULL, *lmm = NULL;
 895
 896         TDM_RETURN_IF_FAIL(private_layer != NULL);
 897         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 898
 899         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->layer_commit_handler_list, link) {
 900                 if (lm->func == func && lm->user_data == user_data) {
 901                         LIST_DEL(&lm->link);
 902                         tdm_output_remove_commit_handler_internal(private_output, _tdm_layer_cb_output_commit, lm);
 903                         _tdm_layer_free_buffer(private_layer, lm->committed_buffer);
 904                         free(lm);
 905                         break;
 906                 }
 907         }
 908
 909         LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->pending_commit_handler_list, link) {
 910                 if (lm->func == func && lm->user_data == user_data) {
 911                         LIST_DEL(&lm->link);
 912                         tdm_output_remove_commit_handler_internal(private_output, _tdm_layer_cb_output_commit, lm);
 913                         _tdm_layer_free_buffer(private_layer, lm->committed_buffer);
 914                         free(lm);
 915                         break;
 916                 }
 917         }
 918 }
 919
 920 EXTERN tdm_error
 921 tdm_layer_remove_commit_handler(tdm_layer *layer, tdm_layer_commit_handler func, void *user_data)
 922 {
 923         LAYER_FUNC_ENTRY();
 924
 925         _pthread_mutex_lock(&private_display->lock);
 926
 927         tdm_layer_remove_commit_handler_internal(layer, func, user_data);
 928
 929         _pthread_mutex_unlock(&private_display->lock);
 930
 931         return ret;
 932 }
 933
 934 EXTERN tbm_surface_h
 935 tdm_layer_get_displaying_buffer(tdm_layer *layer, tdm_error *error)
 936 {
 937         tbm_surface_h buffer;
 938         LAYER_FUNC_ENTRY_ERROR();
 939
 940         _pthread_mutex_lock(&private_display->lock);
 941
 942         if (error)
 943                 *error = TDM_ERROR_NONE;
 944
 945         if (private_layer->showing_buffer) {
 946                 buffer = private_layer->showing_buffer->buffer;
 947         } else {
 948                 if (error)
 949                         *error = TDM_ERROR_OPERATION_FAILED;
 950                 _pthread_mutex_unlock(&private_display->lock);
 951                 TDM_DBG("layer(%p) showing_buffer is null", private_layer);
 952                 return NULL;
 953         }
 954         _pthread_mutex_unlock(&private_display->lock);
 955
 956         return buffer;
 957 }
 958
 959 static void
 960 _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
 961 {
 962         TDM_RETURN_IF_FAIL(data != NULL);
 963         tdm_layer *layer = data;
 964         tdm_func_layer *func_layer;
 965         tbm_surface_h surface = NULL;
 966         tdm_private_layer_buffer *layer_buffer;
 967         LAYER_FUNC_ENTRY_VOID_RETURN();
 968
 969         _pthread_mutex_lock(&private_display->lock);
 970
 971         func_layer = &private_display->func_layer;
 972         if (!func_layer->layer_set_buffer) {
 973                 _pthread_mutex_unlock(&private_display->lock);
 974                 return;
 975         }
 976
 977         layer_buffer = calloc(1, sizeof(tdm_private_layer_buffer));
 978         if (!layer_buffer) {
 979                 _pthread_mutex_unlock(&private_display->lock);
 980                 TDM_ERR("alloc failed");
 981                 return;
 982         }
 983         LIST_INITHEAD(&layer_buffer->link);
 984
 985         if (TBM_SURFACE_QUEUE_ERROR_NONE != tbm_surface_queue_acquire(private_layer->buffer_queue, &surface) ||
 986                 surface == NULL) {
 987                 TDM_ERR("layer(%p) tbm_surface_queue_acquire() failed surface:%p",
 988                                 private_layer, surface);
 989                 _pthread_mutex_unlock(&private_display->lock);
 990                 free(layer_buffer);
 991                 return;
 992         }
 993
 994         ret = func_layer->layer_set_buffer(private_layer->layer_backend, surface);
 995         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 996
 997         if (ret == TDM_ERROR_NONE) {
 998                 if (private_layer->waiting_buffer) {
 999                         TDM_DBG("layer(%p) drop waiting_buffer(%p)", private_layer, private_layer->waiting_buffer->buffer);
1000                         _tdm_layer_free_buffer(private_layer, private_layer->waiting_buffer);
1001                 }
1002
1003                 private_layer->waiting_buffer = layer_buffer;
1004                 private_layer->waiting_buffer->buffer = tdm_buffer_ref_backend(surface);
1005
1006                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
1007                         TDM_INFO("layer(%p) waiting_buffer(%p)",
1008                                          private_layer, private_layer->waiting_buffer->buffer);
1009
1010                 if (private_display->commit_type == TDM_COMMIT_TYPE_OUTPUT) {
1011                         ret = tdm_output_commit_internal(private_layer->private_output, 0, NULL, NULL);
1012                         if (ret != TDM_ERROR_NONE)
1013                                 TDM_ERR("tdm_output_commit_internal() is fail");
1014                 } else if (private_display->commit_type == TDM_COMMIT_TYPE_LAYER) {
1015                         ret = _tdm_layer_commit(private_layer, NULL, NULL);
1016                         if (ret != TDM_ERROR_NONE)
1017                                 TDM_ERR("layer(%p) _tdm_layer_commit() is fail", private_layer);
1018                 } else {
1019                         TDM_NEVER_GET_HERE();
1020                 }
1021         } else
1022                 _tdm_layer_free_buffer(private_layer, layer_buffer);
1023
1024         _pthread_mutex_unlock(&private_display->lock);
1025 }
1026
1027 static void
1028 _tbm_layer_queue_destroy_cb(tbm_surface_queue_h surface_queue, void *data)
1029 {
1030         TDM_RETURN_IF_FAIL(data != NULL);
1031         tdm_layer *layer = data;
1032         LAYER_FUNC_ENTRY_VOID_RETURN();
1033         TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
1034
1035         _pthread_mutex_lock(&private_display->lock);
1036
1037         private_layer->buffer_queue = NULL;
1038
1039         _tdm_layer_free_all_buffers(private_layer);
1040
1041         _pthread_mutex_unlock(&private_display->lock);
1042 }
1043
1044 EXTERN tdm_error
1045 tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
1046 {
1047         tdm_func_layer *func_layer;
1048         LAYER_FUNC_ENTRY();
1049
1050         TDM_RETURN_VAL_IF_FAIL(buffer_queue != NULL, TDM_ERROR_INVALID_PARAMETER);
1051
1052         _pthread_mutex_lock(&private_display->lock);
1053
1054         func_layer = &private_display->func_layer;
1055
1056         if (private_layer->usable)
1057                 TDM_INFO("layer(%p) not usable", private_layer);
1058
1059         private_layer->usable = 0;
1060
1061         if (!func_layer->layer_set_buffer) {
1062                 _pthread_mutex_unlock(&private_display->lock);
1063                 TDM_ERR("not implemented!!");
1064                 return TDM_ERROR_NOT_IMPLEMENTED;
1065         }
1066
1067         if (buffer_queue == private_layer->buffer_queue) {
1068                 _pthread_mutex_unlock(&private_display->lock);
1069                 return TDM_ERROR_NONE;
1070         }
1071
1072         if (private_layer->waiting_buffer) {
1073                 _tdm_layer_free_buffer(private_layer, private_layer->waiting_buffer);
1074                 private_layer->waiting_buffer = NULL;
1075
1076                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
1077                         TDM_INFO("layer(%p) waiting_buffer(%p)",
1078                                          private_layer, private_layer->waiting_buffer);
1079         }
1080
1081         private_layer->buffer_queue = buffer_queue;
1082         tbm_surface_queue_add_acquirable_cb(private_layer->buffer_queue,
1083                                                                                 _tbm_layer_queue_acquirable_cb,
1084                                                                                 private_layer);
1085         tbm_surface_queue_add_destroy_cb(private_layer->buffer_queue,
1086                                                                          _tbm_layer_queue_destroy_cb,
1087                                                                          private_layer);
1088         _pthread_mutex_unlock(&private_display->lock);
1089
1090         return ret;
1091 }
1092
1093 EXTERN tdm_error
1094 tdm_layer_unset_buffer_queue(tdm_layer *layer)
1095 {
1096         return tdm_layer_unset_buffer(layer);
1097 }
1098
1099 EXTERN tdm_error
1100 tdm_layer_is_usable(tdm_layer *layer, unsigned int *usable)
1101 {
1102         LAYER_FUNC_ENTRY();
1103
1104         TDM_RETURN_VAL_IF_FAIL(usable != NULL, TDM_ERROR_INVALID_PARAMETER);
1105
1106         _pthread_mutex_lock(&private_display->lock);
1107
1108         *usable = private_layer->usable;
1109
1110         _pthread_mutex_unlock(&private_display->lock);
1111
1112         return ret;
1113 }
1114
1115 EXTERN tdm_error
1116 tdm_layer_set_video_pos(tdm_layer *layer, int zpos)
1117 {
1118         tdm_func_layer *func_layer;
1119         LAYER_FUNC_ENTRY();
1120
1121         _pthread_mutex_lock(&private_display->lock);
1122
1123         func_layer = &private_display->func_layer;
1124
1125         if (!(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)) {
1126                 TDM_ERR("layer(%p) is not video layer", private_layer);
1127                 _pthread_mutex_unlock(&private_display->lock);
1128                 return TDM_ERROR_INVALID_PARAMETER;
1129         }
1130
1131         if (!func_layer->layer_set_video_pos) {
1132                 _pthread_mutex_unlock(&private_display->lock);
1133                 TDM_ERR("not implemented!!");
1134                 return TDM_ERROR_NOT_IMPLEMENTED;
1135         }
1136
1137         ret = func_layer->layer_set_video_pos(private_layer->layer_backend, zpos);
1138
1139         _pthread_mutex_unlock(&private_display->lock);
1140
1141         return ret;
1142 }
1143
1144 EXTERN tdm_capture *
1145 tdm_layer_create_capture(tdm_layer *layer, tdm_error *error)
1146 {
1147         tdm_capture *capture = NULL;
1148
1149         LAYER_FUNC_ENTRY_ERROR();
1150
1151         _pthread_mutex_lock(&private_display->lock);
1152
1153         capture = (tdm_capture *)tdm_capture_create_layer_internal(private_layer, error);
1154
1155         _pthread_mutex_unlock(&private_display->lock);
1156
1157         return capture;
1158 }
1159
1160 EXTERN tdm_error
1161 tdm_layer_get_buffer_flags(tdm_layer *layer, unsigned int *flags)
1162 {
1163         tdm_func_layer *func_layer;
1164         LAYER_FUNC_ENTRY();
1165
1166         _pthread_mutex_lock(&private_display->lock);
1167
1168         func_layer = &private_display->func_layer;
1169
1170         if (!func_layer->layer_get_buffer_flags) {
1171                 _pthread_mutex_unlock(&private_display->lock);
1172                 TDM_ERR("not implemented!!");
1173                 return TDM_ERROR_NOT_IMPLEMENTED;
1174         }
1175
1176         ret = func_layer->layer_get_buffer_flags(private_layer->layer_backend, flags);
1177
1178         _pthread_mutex_unlock(&private_display->lock);
1179
1180         return ret;
1181 }