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