src/tdm_pp.c

   1 /**************************************************************************
   2  *
   3  * libtdm
   4  *
   5  * Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
   6  *
   7  * Contact: Eunchul Kim <chulspro.kim@samsung.com>,
   8  *          JinYoung Jeon <jy0.jeon@samsung.com>,
   9  *          Taeheon Kim <th908.kim@samsung.com>,
  10  *          YoungJun Cho <yj44.cho@samsung.com>,
  11  *          SooChan Lim <sc1.lim@samsung.com>,
  12  *          Boram Park <sc1.lim@samsung.com>
  13  *
  14  * Permission is hereby granted, free of charge, to any person obtaining a
  15  * copy of this software and associated documentation files (the
  16  * "Software"), to deal in the Software without restriction, including
  17  * without limitation the rights to use, copy, modify, merge, publish,
  18  * distribute, sub license, and/or sell copies of the Software, and to
  19  * permit persons to whom the Software is furnished to do so, subject to
  20  * the following conditions:
  21  *
  22  * The above copyright notice and this permission notice (including the
  23  * next paragraph) shall be included in all copies or substantial portions
  24  * of the Software.
  25  *
  26  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  27  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  29  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  30  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  31  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  32  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  33  *
  34 **************************************************************************/
  35
  36 #ifdef HAVE_CONFIG_H
  37 #include "config.h"
  38 #endif
  39
  40 #include "tdm_private.h"
  41
  42 #define PP_FUNC_ENTRY() \
  43         tdm_private_module *private_module; \
  44         tdm_func_pp *func_pp; \
  45         tdm_private_display *private_display; \
  46         tdm_private_pp *private_pp; \
  47         tdm_error ret = TDM_ERROR_NONE; \
  48         TDM_RETURN_VAL_IF_FAIL(pp != NULL, TDM_ERROR_INVALID_PARAMETER); \
  49         private_pp = (tdm_private_pp*)pp; \
  50         private_display = private_pp->private_display; \
  51         private_module = private_pp->private_module; \
  52         func_pp = &private_module->func_pp
  53
  54 static void
  55 _tdm_pp_print_list(struct list_head *list)
  56 {
  57         tdm_pp_private_buffer *b = NULL;
  58         char str[512], *p;
  59         int len = sizeof(str);
  60
  61         TDM_RETURN_IF_FAIL(list != NULL);
  62
  63         p = str;
  64         LIST_FOR_EACH_ENTRY(b, list, link) {
  65                 if (len > 0) {
  66                         tbm_bo src_bo = tbm_surface_internal_get_bo(b->src, 0);
  67                         tbm_bo dst_bo = tbm_surface_internal_get_bo(b->dst, 0);
  68                         int src_flags = tbm_bo_get_flags(src_bo);
  69                         int dst_flags = tbm_bo_get_flags(dst_bo);
  70                         int l = snprintf(p, len, " (%p[bo_flags:%x], %p[bo_flags:%x])",
  71                                                          b->src, src_flags, b->dst, dst_flags);
  72                         p += l;
  73                         len -= l;
  74                 } else
  75                         break;
  76         }
  77
  78         TDM_INFO("\t %s", str);
  79 }
  80
  81 static tdm_pp_private_buffer *
  82 _tdm_pp_find_tbm_buffers(struct list_head *list, tbm_surface_h src, tbm_surface_h dst)
  83 {
  84         tdm_pp_private_buffer *b = NULL, *bb = NULL;
  85
  86         LIST_FOR_EACH_ENTRY_SAFE(b, bb, list, link) {
  87                 if (b->src == src && b->dst == dst)
  88                         return b;
  89         }
  90
  91         return NULL;
  92 }
  93
  94 static tdm_pp_private_buffer *
  95 _tdm_pp_find_buffer(struct list_head *list, tdm_pp_private_buffer *pp_buffer)
  96 {
  97         tdm_pp_private_buffer *b = NULL, *bb = NULL;
  98
  99         LIST_FOR_EACH_ENTRY_SAFE(b, bb, list, link) {
 100                 if (b == pp_buffer)
 101                         return b;
 102         }
 103
 104         return NULL;
 105 }
 106
 107 static void
 108 _tdm_pp_thread_cb_done(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
 109 {
 110         tdm_thread_cb_pp_done *pp_done = (tdm_thread_cb_pp_done *)cb_base;
 111         tdm_private_pp *private_pp = object;
 112         tdm_pp_private_buffer *pp_buffer = NULL, *first_entry = NULL;
 113         tbm_surface_h src;
 114         tbm_surface_h dst;
 115
 116         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 117
 118         assert(private_pp->owner_tid == syscall(SYS_gettid));
 119
 120         src = pp_done->src;
 121         dst = pp_done->dst;
 122
 123         if (tdm_debug_dump & TDM_DUMP_FLAG_PP) {
 124                 /* LCOV_EXCL_START */
 125                 char str[TDM_PATH_LEN];
 126                 static int i;
 127                 snprintf(str, TDM_PATH_LEN, "pp_dst_%03d", i++);
 128                 tdm_helper_dump_buffer_str(dst, tdm_debug_dump_dir, str);
 129                 /* LCOV_EXCL_STOP */
 130         }
 131
 132         if (!LIST_IS_EMPTY(&private_pp->buffer_list)) {
 133                 first_entry = container_of((&private_pp->buffer_list)->next, pp_buffer, link);
 134                 if (first_entry->src != src || first_entry->dst != dst)
 135                         TDM_ERR("buffer(%p,%p) is skipped", first_entry->src, first_entry->dst);
 136         } else {
 137                 TDM_NEVER_GET_HERE();
 138         }
 139
 140         if ((pp_buffer = _tdm_pp_find_tbm_buffers(&private_pp->buffer_list, src, dst))) {
 141                 LIST_DEL(&pp_buffer->link);
 142                 LIST_DELINIT(&pp_buffer->commit_link);
 143
 144                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
 145                         TDM_INFO("pp(%p) done: src(%p) dst(%p)", private_pp, src, dst);
 146
 147                 if (tdm_ttrace_module & TDM_TTRACE_PP) {
 148                         tbm_bo bo = tbm_surface_internal_get_bo(dst, 0);
 149                         TDM_TRACE_ASYNC_END((intptr_t)private_pp, "[PP] %d", tbm_bo_export(bo));
 150                 }
 151
 152                 _pthread_mutex_unlock(&private_display->lock);
 153                 if (private_pp->done_func)
 154                         private_pp->done_func(private_pp, src, dst, private_pp->done_user_data);
 155                 tdm_buffer_unref_backend(src);
 156                 tdm_buffer_unref_backend(dst);
 157                 _pthread_mutex_lock(&private_display->lock);
 158
 159                 free(pp_buffer);
 160         }
 161 }
 162
 163 static void
 164 _tdm_pp_cb_done(tdm_pp *pp_module, tbm_surface_h src, tbm_surface_h dst, void *user_data)
 165 {
 166         tdm_thread_cb_pp_done pp_done;
 167         tdm_private_pp *private_pp = user_data;
 168         tdm_error ret;
 169
 170         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 171
 172         memset(&pp_done, 0, sizeof pp_done);
 173         pp_done.base.type = TDM_THREAD_CB_PP_DONE;
 174         pp_done.base.length = sizeof pp_done;
 175         pp_done.base.object_stamp = private_pp->stamp;
 176         pp_done.base.data = NULL;
 177         pp_done.base.sync = 0;
 178         pp_done.src = src;
 179         pp_done.dst = dst;
 180
 181         ret = tdm_thread_cb_call(private_pp, &pp_done.base, 1);
 182         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 183 }
 184
 185 static void *
 186 _tdm_pp_find_object(tdm_private_display *private_display, double stamp)
 187 {
 188         tdm_private_module *private_module = NULL;
 189         tdm_private_pp *private_pp = NULL;
 190
 191         TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL);
 192
 193         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 194                 LIST_FOR_EACH_ENTRY(private_pp, &private_module->pp_list, link) {
 195                         if (private_pp->stamp == stamp)
 196                                 return private_pp;
 197                 }
 198         }
 199
 200         return NULL;
 201 }
 202
 203 INTERN tdm_error
 204 tdm_pp_init(tdm_private_display *private_display)
 205 {
 206         tdm_thread_cb_set_find_func(TDM_THREAD_CB_PP_DONE, _tdm_pp_find_object);
 207
 208         return TDM_ERROR_NONE;
 209 }
 210
 211 INTERN tdm_private_pp *
 212 tdm_pp_create_internal(tdm_private_module *private_module, tdm_error *error)
 213 {
 214         tdm_private_display *private_display;
 215         tdm_func_display *func_display;
 216         tdm_func_pp *func_pp;
 217         tdm_private_pp *private_pp = NULL;
 218         tdm_pp *pp_module = NULL;
 219         tdm_error ret = TDM_ERROR_NONE;
 220
 221         TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL);
 222         TDM_RETURN_VAL_IF_FAIL(private_module != NULL, NULL);
 223
 224         private_display = private_module->private_display;
 225         func_display = &private_module->func_display;
 226         func_pp = &private_module->func_pp;
 227
 228         if (!(private_module->capabilities & TDM_DISPLAY_CAPABILITY_PP)) {
 229                 /* LCOV_EXCL_START */
 230                 TDM_ERR("backedn(%s) no pp capability", private_module->module_data->name);
 231                 if (error)
 232                         *error = TDM_ERROR_NO_CAPABILITY;
 233                 return NULL;
 234                 /* LCOV_EXCL_STOP */
 235         }
 236
 237         pp_module = func_display->display_create_pp(private_module->bdata, &ret);
 238         if (ret != TDM_ERROR_NONE) {
 239                 /* LCOV_EXCL_START */
 240                 if (error)
 241                         *error = ret;
 242                 return NULL;
 243                 /* LCOV_EXCL_STOP */
 244         }
 245
 246         private_pp = calloc(1, sizeof(tdm_private_pp));
 247         if (!private_pp) {
 248                 /* LCOV_EXCL_START */
 249                 TDM_ERR("failed: alloc memory");
 250                 func_pp->pp_destroy(pp_module);
 251                 if (error)
 252                         *error = TDM_ERROR_OUT_OF_MEMORY;
 253                 return NULL;
 254                 /* LCOV_EXCL_STOP */
 255         }
 256
 257         ret = tdm_thread_cb_add(private_pp, TDM_THREAD_CB_PP_DONE, NULL, _tdm_pp_thread_cb_done, NULL);
 258         if (ret != TDM_ERROR_NONE) {
 259                 TDM_ERR("pp tdm_thread_cb_add failed");
 260                 func_pp->pp_destroy(pp_module);
 261                 free(private_pp);
 262                 if (error)
 263                         *error = ret;
 264                 return NULL;
 265         }
 266
 267         ret = func_pp->pp_set_done_handler(pp_module, _tdm_pp_cb_done, private_pp);
 268         if (ret != TDM_ERROR_NONE) {
 269                 /* LCOV_EXCL_START */
 270                 TDM_ERR("spp(%p) et pp_done_handler failed", private_pp);
 271                 func_pp->pp_destroy(pp_module);
 272                 free(private_pp);
 273                 if (error)
 274                         *error = ret;
 275                 return NULL;
 276                 /* LCOV_EXCL_STOP */
 277         }
 278
 279         private_pp->stamp = tdm_helper_get_time();
 280         while (_tdm_pp_find_object(private_display, private_pp->stamp))
 281                 private_pp->stamp++;
 282
 283         LIST_ADD(&private_pp->link, &private_module->pp_list);
 284         private_pp->private_display = private_module->private_display;
 285         private_pp->private_module = private_module;
 286         private_pp->pp_module = pp_module;
 287         private_pp->owner_tid = syscall(SYS_gettid);
 288
 289         LIST_INITHEAD(&private_pp->pending_buffer_list);
 290         LIST_INITHEAD(&private_pp->buffer_list);
 291
 292         if (error)
 293                 *error = TDM_ERROR_NONE;
 294
 295         return private_pp;
 296 }
 297
 298 INTERN void
 299 tdm_pp_destroy_internal(tdm_private_pp *private_pp)
 300 {
 301         tdm_private_display *private_display;
 302         tdm_private_module *private_module;
 303         tdm_func_pp *func_pp;
 304         tdm_pp_private_buffer *b = NULL, *bb = NULL;
 305         struct list_head clone_list;
 306
 307         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 308
 309         if (!private_pp)
 310                 return;
 311
 312         tdm_thread_cb_remove(private_pp, TDM_THREAD_CB_PP_DONE, NULL, _tdm_pp_thread_cb_done, NULL);
 313
 314         private_display = private_pp->private_display;
 315         private_module = private_pp->private_module;
 316         func_pp = &private_module->func_pp;
 317
 318         LIST_DEL(&private_pp->link);
 319
 320         func_pp->pp_destroy(private_pp->pp_module);
 321
 322         if (!LIST_IS_EMPTY(&private_pp->pending_buffer_list)) {
 323                 TDM_WRN("pp(%p) not finished:", private_pp);
 324                 _tdm_pp_print_list(&private_pp->pending_buffer_list);
 325
 326                 LIST_INITHEAD(&clone_list);
 327                 LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->pending_buffer_list, link) {
 328                         LIST_DEL(&b->link);
 329                         LIST_ADDTAIL(&b->link, &clone_list);
 330                 }
 331
 332                 _pthread_mutex_unlock(&private_display->lock);
 333                 LIST_FOR_EACH_ENTRY_SAFE(b, bb, &clone_list, link) {
 334                         LIST_DEL(&b->link);
 335
 336                         if (tdm_ttrace_module & TDM_TTRACE_PP) {
 337                                 tbm_bo bo = tbm_surface_internal_get_bo(b->dst, 0);
 338                                 TDM_TRACE_ASYNC_END((intptr_t)private_pp, "[PP] %d", tbm_bo_export(bo));
 339                         }
 340
 341                         tdm_buffer_unref_backend(b->src);
 342                         tdm_buffer_unref_backend(b->dst);
 343                         free(b);
 344                 }
 345                 _pthread_mutex_lock(&private_display->lock);
 346         }
 347
 348         if (!LIST_IS_EMPTY(&private_pp->buffer_list)) {
 349                 TDM_WRN("pp(%p) not finished:", private_pp);
 350                 _tdm_pp_print_list(&private_pp->buffer_list);
 351
 352                 LIST_INITHEAD(&clone_list);
 353                 LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->buffer_list, link) {
 354                         LIST_DEL(&b->link);
 355                         LIST_ADDTAIL(&b->link, &clone_list);
 356                 }
 357
 358                 _pthread_mutex_unlock(&private_display->lock);
 359                 LIST_FOR_EACH_ENTRY_SAFE(b, bb, &clone_list, link) {
 360                         LIST_DEL(&b->link);
 361
 362                         if (tdm_ttrace_module & TDM_TTRACE_PP) {
 363                                 tbm_bo bo = tbm_surface_internal_get_bo(b->dst, 0);
 364                                 TDM_TRACE_ASYNC_END((intptr_t)private_pp, "[PP] %d", tbm_bo_export(bo));
 365                         }
 366
 367                         tdm_buffer_unref_backend(b->src);
 368                         tdm_buffer_unref_backend(b->dst);
 369                         free(b);
 370                 }
 371                 _pthread_mutex_lock(&private_display->lock);
 372         }
 373
 374         private_pp->stamp = 0;
 375         free(private_pp);
 376 }
 377
 378 EXTERN void
 379 tdm_pp_destroy(tdm_pp *pp)
 380 {
 381         tdm_private_pp *private_pp = pp;
 382         tdm_private_display *private_display;
 383
 384         if (!private_pp)
 385                 return;
 386
 387         private_display = private_pp->private_display;
 388
 389         _pthread_mutex_lock(&private_display->lock);
 390         tdm_pp_destroy_internal(private_pp);
 391         _pthread_mutex_unlock(&private_display->lock);
 392 }
 393
 394 EXTERN tdm_error
 395 tdm_pp_set_info(tdm_pp *pp, tdm_info_pp *info)
 396 {
 397         PP_FUNC_ENTRY();
 398
 399         TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
 400
 401         _pthread_mutex_lock(&private_display->lock);
 402
 403         if (!func_pp->pp_set_info) {
 404                 /* LCOV_EXCL_START */
 405                 _pthread_mutex_unlock(&private_display->lock);
 406                 TDM_DBG("failed: not implemented!!");
 407                 return TDM_ERROR_NOT_IMPLEMENTED;
 408                 /* LCOV_EXCL_STOP */
 409         }
 410
 411         TDM_INFO("pp(%p) info: src(%ux%u %u,%u %ux%u %c%c%c%c) dst(%ux%u %u,%u %ux%u %c%c%c%c) trans(%d) sync(%d) flags(%x)",
 412                          private_pp, info->src_config.size.h, info->src_config.size.v,
 413                          info->src_config.pos.x, info->src_config.pos.y,
 414                          info->src_config.pos.w, info->src_config.pos.h,
 415                          FOURCC_STR(info->src_config.format),
 416                          info->dst_config.size.h, info->dst_config.size.v,
 417                          info->dst_config.pos.x, info->dst_config.pos.y,
 418                          info->dst_config.pos.w, info->dst_config.pos.h,
 419                          FOURCC_STR(info->dst_config.format),
 420                          info->transform, info->sync, info->flags);
 421
 422         ret = func_pp->pp_set_info(private_pp->pp_module, info);
 423         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 424
 425         private_pp->info = *info;
 426
 427         _pthread_mutex_unlock(&private_display->lock);
 428
 429         return ret;
 430 }
 431
 432 EXTERN tdm_error
 433 tdm_pp_set_done_handler(tdm_pp *pp, tdm_pp_done_handler func, void *user_data)
 434 {
 435         tdm_private_display *private_display;
 436         tdm_private_pp *private_pp;
 437         tdm_error ret = TDM_ERROR_NONE;
 438
 439         TDM_RETURN_VAL_IF_FAIL(pp != NULL, TDM_ERROR_INVALID_PARAMETER);
 440
 441         private_pp = (tdm_private_pp*)pp;
 442         private_display = private_pp->private_display;
 443
 444         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 445
 446         _pthread_mutex_lock(&private_display->lock);
 447
 448         private_pp->done_func = func;
 449         private_pp->done_user_data = user_data;
 450
 451         _pthread_mutex_unlock(&private_display->lock);
 452
 453         return ret;
 454 }
 455
 456 EXTERN tdm_error
 457 tdm_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst)
 458 {
 459         tdm_pp_private_buffer *pp_buffer;
 460
 461         PP_FUNC_ENTRY();
 462
 463         TDM_RETURN_VAL_IF_FAIL(src != NULL, TDM_ERROR_INVALID_PARAMETER);
 464         TDM_RETURN_VAL_IF_FAIL(dst != NULL, TDM_ERROR_INVALID_PARAMETER);
 465
 466         _pthread_mutex_lock(&private_display->lock);
 467
 468         if (!func_pp->pp_attach) {
 469                 /* LCOV_EXCL_START */
 470                 _pthread_mutex_unlock(&private_display->lock);
 471                 TDM_DBG("failed: not implemented!!");
 472                 return TDM_ERROR_NOT_IMPLEMENTED;
 473                 /* LCOV_EXCL_STOP */
 474         }
 475
 476         if (tdm_module_check_abi(private_module, 1, 2) &&
 477                 private_module->caps_pp.max_attach_count > 0) {
 478                 /* LCOV_EXCL_START */
 479                 int length = LIST_LENGTH(&private_pp->pending_buffer_list) +
 480                                          LIST_LENGTH(&private_pp->buffer_list);
 481                 if (length >= private_module->caps_pp.max_attach_count) {
 482                         _pthread_mutex_unlock(&private_display->lock);
 483                         TDM_DBG("failed: backend(%s) too many attached!! max_attach_count(%d)",
 484                                         private_module->module_data->name, private_module->caps_pp.max_attach_count);
 485                         return TDM_ERROR_BAD_REQUEST;
 486                 }
 487                 /* LCOV_EXCL_STOP */
 488         }
 489
 490         if (tdm_debug_dump & TDM_DUMP_FLAG_PP) {
 491                 /* LCOV_EXCL_START */
 492                 char str[TDM_PATH_LEN];
 493                 static int i;
 494                 snprintf(str, TDM_PATH_LEN, "pp_src_%03d", i++);
 495                 tdm_helper_dump_buffer_str(src, tdm_debug_dump_dir, str);
 496                 /* LCOV_EXCL_STOP */
 497         }
 498
 499         pp_buffer = calloc(1, sizeof * pp_buffer);
 500         if (!pp_buffer) {
 501                 /* LCOV_EXCL_START */
 502                 _pthread_mutex_unlock(&private_display->lock);
 503                 TDM_ERR("alloc failed");
 504                 return TDM_ERROR_OUT_OF_MEMORY;
 505                 /* LCOV_EXCL_STOP */
 506         }
 507
 508         ret = func_pp->pp_attach(private_pp->pp_module, src, dst);
 509         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 510
 511         if (ret != TDM_ERROR_NONE) {
 512                 /* LCOV_EXCL_START */
 513                 free(pp_buffer);
 514                 _pthread_mutex_unlock(&private_display->lock);
 515                 TDM_ERR("attach failed");
 516                 return ret;
 517                 /* LCOV_EXCL_STOP */
 518         }
 519
 520         LIST_ADDTAIL(&pp_buffer->link, &private_pp->pending_buffer_list);
 521         pp_buffer->src = tdm_buffer_ref_backend(src);
 522         pp_buffer->dst = tdm_buffer_ref_backend(dst);
 523
 524         if (tdm_debug_module & TDM_DEBUG_BUFFER) {
 525                 TDM_INFO("pp(%p) attached:", private_pp);
 526                 _tdm_pp_print_list(&private_pp->pending_buffer_list);
 527         }
 528
 529         if (tdm_ttrace_module & TDM_TTRACE_PP) {
 530                 tbm_bo bo = tbm_surface_internal_get_bo(dst, 0);
 531                 TDM_TRACE_ASYNC_BEGIN((intptr_t)pp, "[PP] %d", tbm_bo_export(bo));
 532         }
 533
 534         _pthread_mutex_unlock(&private_display->lock);
 535
 536         return ret;
 537 }
 538
 539 EXTERN tdm_error
 540 tdm_pp_commit(tdm_pp *pp)
 541 {
 542         tdm_pp_private_buffer *b = NULL, *bb = NULL;
 543         struct list_head commit_buffer_list;
 544
 545         PP_FUNC_ENTRY();
 546
 547         _pthread_mutex_lock(&private_display->lock);
 548
 549         if (!func_pp->pp_commit) {
 550                 /* LCOV_EXCL_START */
 551                 _pthread_mutex_unlock(&private_display->lock);
 552                 TDM_DBG("failed: not implemented!!");
 553                 return TDM_ERROR_NOT_IMPLEMENTED;
 554                 /* LCOV_EXCL_STOP */
 555         }
 556
 557         LIST_INITHEAD(&commit_buffer_list);
 558
 559         LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->pending_buffer_list, link) {
 560                 LIST_DEL(&b->link);
 561                 LIST_ADDTAIL(&b->link, &private_pp->buffer_list);
 562                 LIST_ADDTAIL(&b->commit_link, &commit_buffer_list);
 563         }
 564
 565         ret = func_pp->pp_commit(private_pp->pp_module);
 566         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 567
 568         LIST_FOR_EACH_ENTRY_SAFE(b, bb, &commit_buffer_list, commit_link) {
 569                 LIST_DELINIT(&b->commit_link);
 570
 571                 if (!_tdm_pp_find_buffer(&private_pp->buffer_list, b))
 572                         continue;
 573
 574                 if (ret != TDM_ERROR_NONE) {
 575                         /* Not to call the user release handler when failed.
 576                          * Do we have to call this function here really?
 577                          * User better use set_done_handler to know when pp is done. Using
 578                          * buffer_release_handler is not good.
 579                          */
 580                         tdm_buffer_remove_release_handler_internal(b->src);
 581                         tdm_buffer_remove_release_handler_internal(b->dst);
 582
 583                         _pthread_mutex_unlock(&private_display->lock);
 584                         tdm_buffer_unref_backend(b->src);
 585                         tdm_buffer_unref_backend(b->dst);
 586                         _pthread_mutex_lock(&private_display->lock);
 587                         LIST_DEL(&b->link);
 588
 589                         free(b);
 590                 }
 591         }
 592
 593         _pthread_mutex_unlock(&private_display->lock);
 594
 595         return ret;
 596 }