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_func_pp *func_pp; \
  44         tdm_private_display *private_display; \
  45         tdm_private_pp *private_pp; \
  46         tdm_error ret = TDM_ERROR_NONE; \
  47         TDM_RETURN_VAL_IF_FAIL(pp != NULL, TDM_ERROR_INVALID_PARAMETER); \
  48         private_pp = (tdm_private_pp*)pp; \
  49         private_display = private_pp->private_display; \
  50         func_pp = &private_display->func_pp
  51
  52 static void
  53 _tdm_pp_print_list(struct list_head *list)
  54 {
  55         tdm_pp_private_buffer *b = NULL;
  56         char str[512], *p;
  57         int len = sizeof(str);
  58
  59         TDM_RETURN_IF_FAIL(list != NULL);
  60
  61         p = str;
  62         LIST_FOR_EACH_ENTRY(b, list, link) {
  63                 if (len > 0) {
  64                         int l = snprintf(p, len, " (%p,%p)", b->src, b->dst);
  65                         p += l;
  66                         len -= l;
  67                 } else
  68                         break;
  69         }
  70
  71         TDM_INFO("\t %s", str);
  72 }
  73
  74 static tdm_pp_private_buffer *
  75 _tdm_pp_find_tbm_buffers(struct list_head *list, tbm_surface_h src, tbm_surface_h dst)
  76 {
  77         tdm_pp_private_buffer *b = NULL, *bb = NULL;
  78
  79         LIST_FOR_EACH_ENTRY_SAFE(b, bb, list, link) {
  80                 if (b->src == src && b->dst == dst)
  81                         return b;
  82         }
  83
  84         return NULL;
  85 }
  86
  87 static tdm_pp_private_buffer *
  88 _tdm_pp_find_buffer(struct list_head *list, tdm_pp_private_buffer *pp_buffer)
  89 {
  90         tdm_pp_private_buffer *b = NULL, *bb = NULL;
  91
  92         LIST_FOR_EACH_ENTRY_SAFE(b, bb, list, link) {
  93                 if (b == pp_buffer)
  94                         return b;
  95         }
  96
  97         return NULL;
  98 }
  99
 100 static void
 101 _tdm_pp_thread_cb_done(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
 102 {
 103         tdm_thread_cb_pp_done *pp_done = (tdm_thread_cb_pp_done *)cb_base;
 104         tdm_private_pp *private_pp = object;
 105         tdm_pp_private_buffer *pp_buffer = NULL, *first_entry = NULL;
 106         tbm_surface_h src;
 107         tbm_surface_h dst;
 108
 109         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 110
 111         assert(private_pp->owner_tid == syscall(SYS_gettid));
 112
 113         src = pp_done->src;
 114         dst = pp_done->dst;
 115
 116         if (tdm_debug_dump & TDM_DUMP_FLAG_PP) {
 117                 /* LCOV_EXCL_START */
 118                 char str[TDM_PATH_LEN];
 119                 static int i;
 120                 snprintf(str, TDM_PATH_LEN, "pp_dst_%03d", i++);
 121                 tdm_helper_dump_buffer_str(dst, tdm_debug_dump_dir, str);
 122                 /* LCOV_EXCL_STOP */
 123         }
 124
 125         if (!LIST_IS_EMPTY(&private_pp->buffer_list)) {
 126                 first_entry = container_of((&private_pp->buffer_list)->next, pp_buffer, link);
 127                 if (first_entry->src != src || first_entry->dst != dst)
 128                         TDM_ERR("buffer(%p,%p) is skipped", first_entry->src, first_entry->dst);
 129         } else {
 130                 TDM_NEVER_GET_HERE();
 131         }
 132
 133         if ((pp_buffer = _tdm_pp_find_tbm_buffers(&private_pp->buffer_list, src, dst))) {
 134                 LIST_DEL(&pp_buffer->link);
 135                 LIST_DELINIT(&pp_buffer->commit_link);
 136
 137                 if (tdm_debug_module & TDM_DEBUG_BUFFER)
 138                         TDM_INFO("pp(%p) done: src(%p) dst(%p)", private_pp, src, dst);
 139
 140                 if (tdm_ttrace_module & TDM_TTRACE_PP) {
 141                         tbm_bo bo = tbm_surface_internal_get_bo(dst, 0);
 142                         TDM_TRACE_ASYNC_END((intptr_t)private_pp, "[PP] %d", tbm_bo_export(bo));
 143                 }
 144
 145                 _pthread_mutex_unlock(&private_display->lock);
 146                 if (private_pp->done_func)
 147                         private_pp->done_func(private_pp, src, dst, private_pp->done_user_data);
 148                 tdm_buffer_unref_backend(src);
 149                 tdm_buffer_unref_backend(dst);
 150                 _pthread_mutex_lock(&private_display->lock);
 151
 152                 free(pp_buffer);
 153         }
 154 }
 155
 156 static void
 157 _tdm_pp_cb_done(tdm_pp *pp_backend, tbm_surface_h src, tbm_surface_h dst, void *user_data)
 158 {
 159         tdm_thread_cb_pp_done pp_done;
 160         tdm_private_pp *private_pp = user_data;
 161         tdm_error ret;
 162
 163         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 164
 165         memset(&pp_done, 0, sizeof pp_done);
 166         pp_done.base.type = TDM_THREAD_CB_PP_DONE;
 167         pp_done.base.length = sizeof pp_done;
 168         pp_done.base.object_stamp = private_pp->stamp;
 169         pp_done.base.data = NULL;
 170         pp_done.base.sync = 0;
 171         pp_done.src = src;
 172         pp_done.dst = dst;
 173
 174         ret = tdm_thread_cb_call(private_pp, &pp_done.base);
 175         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 176 }
 177
 178 static void *
 179 _tdm_pp_find_object(tdm_private_display *private_display, double stamp)
 180 {
 181         tdm_private_pp *private_pp = NULL;
 182
 183         TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL);
 184
 185         LIST_FOR_EACH_ENTRY(private_pp, &private_display->pp_list, link) {
 186                 if (private_pp->stamp == stamp)
 187                         return private_pp;
 188         }
 189
 190         return NULL;
 191 }
 192
 193 INTERN tdm_error
 194 tdm_pp_init(tdm_private_display *private_display)
 195 {
 196         tdm_thread_cb_set_find_func(TDM_THREAD_CB_PP_DONE, _tdm_pp_find_object);
 197
 198         return TDM_ERROR_NONE;
 199 }
 200
 201 INTERN tdm_private_pp *
 202 tdm_pp_create_internal(tdm_private_display *private_display, tdm_error *error)
 203 {
 204         tdm_func_display *func_display;
 205         tdm_func_pp *func_pp;
 206         tdm_private_pp *private_pp = NULL;
 207         tdm_pp *pp_backend = NULL;
 208         tdm_error ret = TDM_ERROR_NONE;
 209
 210         TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL);
 211
 212         func_display = &private_display->func_display;
 213         func_pp = &private_display->func_pp;
 214
 215         if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) {
 216                 /* LCOV_EXCL_START */
 217                 TDM_ERR("no pp capability");
 218                 if (error)
 219                         *error = TDM_ERROR_NO_CAPABILITY;
 220                 return NULL;
 221                 /* LCOV_EXCL_STOP */
 222         }
 223
 224         pp_backend = func_display->display_create_pp(private_display->bdata, &ret);
 225         if (ret != TDM_ERROR_NONE) {
 226                 /* LCOV_EXCL_START */
 227                 if (error)
 228                         *error = ret;
 229                 return NULL;
 230                 /* LCOV_EXCL_STOP */
 231         }
 232
 233         private_pp = calloc(1, sizeof(tdm_private_pp));
 234         if (!private_pp) {
 235                 /* LCOV_EXCL_START */
 236                 TDM_ERR("failed: alloc memory");
 237                 func_pp->pp_destroy(pp_backend);
 238                 if (error)
 239                         *error = TDM_ERROR_OUT_OF_MEMORY;
 240                 return NULL;
 241                 /* LCOV_EXCL_STOP */
 242         }
 243
 244         ret = tdm_thread_cb_add(private_pp, TDM_THREAD_CB_PP_DONE, NULL, _tdm_pp_thread_cb_done, NULL);
 245         if (ret != TDM_ERROR_NONE) {
 246                 TDM_ERR("pp tdm_thread_cb_add failed");
 247                 func_pp->pp_destroy(pp_backend);
 248                 free(private_pp);
 249                 if (error)
 250                         *error = ret;
 251                 return NULL;
 252         }
 253
 254         ret = func_pp->pp_set_done_handler(pp_backend, _tdm_pp_cb_done, private_pp);
 255         if (ret != TDM_ERROR_NONE) {
 256                 /* LCOV_EXCL_START */
 257                 TDM_ERR("spp(%p) et pp_done_handler failed", private_pp);
 258                 func_pp->pp_destroy(pp_backend);
 259                 free(private_pp);
 260                 if (error)
 261                         *error = ret;
 262                 return NULL;
 263                 /* LCOV_EXCL_STOP */
 264         }
 265
 266         private_pp->stamp = tdm_helper_get_time();
 267         while (_tdm_pp_find_object(private_display, private_pp->stamp))
 268                 private_pp->stamp++;
 269
 270         LIST_ADD(&private_pp->link, &private_display->pp_list);
 271         private_pp->private_display = private_display;
 272         private_pp->pp_backend = pp_backend;
 273         private_pp->owner_tid = syscall(SYS_gettid);
 274
 275         LIST_INITHEAD(&private_pp->pending_buffer_list);
 276         LIST_INITHEAD(&private_pp->buffer_list);
 277
 278         if (error)
 279                 *error = TDM_ERROR_NONE;
 280
 281         return private_pp;
 282 }
 283
 284 INTERN void
 285 tdm_pp_destroy_internal(tdm_private_pp *private_pp)
 286 {
 287         tdm_private_display *private_display;
 288         tdm_func_pp *func_pp;
 289         tdm_pp_private_buffer *b = NULL, *bb = NULL;
 290         struct list_head clone_list;
 291
 292         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 293
 294         if (!private_pp)
 295                 return;
 296
 297         tdm_thread_cb_remove(private_pp, TDM_THREAD_CB_PP_DONE, NULL, _tdm_pp_thread_cb_done, NULL);
 298
 299         private_display = private_pp->private_display;
 300         func_pp = &private_display->func_pp;
 301
 302         LIST_DEL(&private_pp->link);
 303
 304         func_pp->pp_destroy(private_pp->pp_backend);
 305
 306         if (!LIST_IS_EMPTY(&private_pp->pending_buffer_list)) {
 307                 TDM_WRN("pp(%p) not finished:", private_pp);
 308                 _tdm_pp_print_list(&private_pp->pending_buffer_list);
 309
 310                 LIST_INITHEAD(&clone_list);
 311                 LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->pending_buffer_list, link) {
 312                         LIST_DEL(&b->link);
 313                         LIST_ADDTAIL(&b->link, &clone_list);
 314                 }
 315
 316                 _pthread_mutex_unlock(&private_display->lock);
 317                 LIST_FOR_EACH_ENTRY_SAFE(b, bb, &clone_list, link) {
 318                         LIST_DEL(&b->link);
 319
 320                         if (tdm_ttrace_module & TDM_TTRACE_PP) {
 321                                 tbm_bo bo = tbm_surface_internal_get_bo(b->dst, 0);
 322                                 TDM_TRACE_ASYNC_END((intptr_t)private_pp, "[PP] %d", tbm_bo_export(bo));
 323                         }
 324
 325                         tdm_buffer_unref_backend(b->src);
 326                         tdm_buffer_unref_backend(b->dst);
 327                         free(b);
 328                 }
 329                 _pthread_mutex_lock(&private_display->lock);
 330         }
 331
 332         if (!LIST_IS_EMPTY(&private_pp->buffer_list)) {
 333                 TDM_WRN("pp(%p) not finished:", private_pp);
 334                 _tdm_pp_print_list(&private_pp->buffer_list);
 335
 336                 LIST_INITHEAD(&clone_list);
 337                 LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->buffer_list, link) {
 338                         LIST_DEL(&b->link);
 339                         LIST_ADDTAIL(&b->link, &clone_list);
 340                 }
 341
 342                 _pthread_mutex_unlock(&private_display->lock);
 343                 LIST_FOR_EACH_ENTRY_SAFE(b, bb, &clone_list, link) {
 344                         LIST_DEL(&b->link);
 345
 346                         if (tdm_ttrace_module & TDM_TTRACE_PP) {
 347                                 tbm_bo bo = tbm_surface_internal_get_bo(b->dst, 0);
 348                                 TDM_TRACE_ASYNC_END((intptr_t)private_pp, "[PP] %d", tbm_bo_export(bo));
 349                         }
 350
 351                         tdm_buffer_unref_backend(b->src);
 352                         tdm_buffer_unref_backend(b->dst);
 353                         free(b);
 354                 }
 355                 _pthread_mutex_lock(&private_display->lock);
 356         }
 357
 358         private_pp->stamp = 0;
 359         free(private_pp);
 360 }
 361
 362 EXTERN void
 363 tdm_pp_destroy(tdm_pp *pp)
 364 {
 365         tdm_private_pp *private_pp = pp;
 366         tdm_private_display *private_display;
 367
 368         if (!private_pp)
 369                 return;
 370
 371         private_display = private_pp->private_display;
 372
 373         _pthread_mutex_lock(&private_display->lock);
 374         tdm_pp_destroy_internal(private_pp);
 375         _pthread_mutex_unlock(&private_display->lock);
 376 }
 377
 378 EXTERN tdm_error
 379 tdm_pp_set_info(tdm_pp *pp, tdm_info_pp *info)
 380 {
 381         PP_FUNC_ENTRY();
 382
 383         TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
 384
 385         _pthread_mutex_lock(&private_display->lock);
 386
 387         if (!func_pp->pp_set_info) {
 388                 /* LCOV_EXCL_START */
 389                 _pthread_mutex_unlock(&private_display->lock);
 390                 TDM_DBG("failed: not implemented!!");
 391                 return TDM_ERROR_NOT_IMPLEMENTED;
 392                 /* LCOV_EXCL_STOP */
 393         }
 394
 395         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)",
 396                          private_pp, info->src_config.size.h, info->src_config.size.v,
 397                          info->src_config.pos.x, info->src_config.pos.y,
 398                          info->src_config.pos.w, info->src_config.pos.h,
 399                          FOURCC_STR(info->src_config.format),
 400                          info->dst_config.size.h, info->dst_config.size.v,
 401                          info->dst_config.pos.x, info->dst_config.pos.y,
 402                          info->dst_config.pos.w, info->dst_config.pos.h,
 403                          FOURCC_STR(info->dst_config.format),
 404                          info->transform, info->sync, info->flags);
 405
 406         ret = func_pp->pp_set_info(private_pp->pp_backend, info);
 407         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 408
 409         private_pp->info = *info;
 410
 411         _pthread_mutex_unlock(&private_display->lock);
 412
 413         return ret;
 414 }
 415
 416 EXTERN tdm_error
 417 tdm_pp_set_done_handler(tdm_pp *pp, tdm_pp_done_handler func, void *user_data)
 418 {
 419         tdm_private_display *private_display;
 420         tdm_private_pp *private_pp;
 421         tdm_error ret = TDM_ERROR_NONE;
 422
 423         TDM_RETURN_VAL_IF_FAIL(pp != NULL, TDM_ERROR_INVALID_PARAMETER);
 424
 425         private_pp = (tdm_private_pp*)pp;
 426         private_display = private_pp->private_display;
 427
 428         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 429
 430         _pthread_mutex_lock(&private_display->lock);
 431
 432         private_pp->done_func = func;
 433         private_pp->done_user_data = user_data;
 434
 435         _pthread_mutex_unlock(&private_display->lock);
 436
 437         return ret;
 438 }
 439
 440 EXTERN tdm_error
 441 tdm_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst)
 442 {
 443         tdm_pp_private_buffer *pp_buffer;
 444
 445         PP_FUNC_ENTRY();
 446
 447         TDM_RETURN_VAL_IF_FAIL(src != NULL, TDM_ERROR_INVALID_PARAMETER);
 448         TDM_RETURN_VAL_IF_FAIL(dst != NULL, TDM_ERROR_INVALID_PARAMETER);
 449
 450         _pthread_mutex_lock(&private_display->lock);
 451
 452         if (!func_pp->pp_attach) {
 453                 /* LCOV_EXCL_START */
 454                 _pthread_mutex_unlock(&private_display->lock);
 455                 TDM_DBG("failed: not implemented!!");
 456                 return TDM_ERROR_NOT_IMPLEMENTED;
 457                 /* LCOV_EXCL_STOP */
 458         }
 459
 460         if (tdm_display_check_module_abi(private_display, 1, 2) &&
 461                 private_display->caps_pp.max_attach_count > 0) {
 462                 /* LCOV_EXCL_START */
 463                 int length = LIST_LENGTH(&private_pp->pending_buffer_list) +
 464                                          LIST_LENGTH(&private_pp->buffer_list);
 465                 if (length >= private_display->caps_pp.max_attach_count) {
 466                         _pthread_mutex_unlock(&private_display->lock);
 467                         TDM_DBG("failed: too many attached!! max_attach_count(%d)",
 468                                         private_display->caps_pp.max_attach_count);
 469                         return TDM_ERROR_BAD_REQUEST;
 470                 }
 471                 /* LCOV_EXCL_STOP */
 472         }
 473
 474         if (tdm_debug_dump & TDM_DUMP_FLAG_PP) {
 475                 /* LCOV_EXCL_START */
 476                 char str[TDM_PATH_LEN];
 477                 static int i;
 478                 snprintf(str, TDM_PATH_LEN, "pp_src_%03d", i++);
 479                 tdm_helper_dump_buffer_str(src, tdm_debug_dump_dir, str);
 480                 /* LCOV_EXCL_STOP */
 481         }
 482
 483         pp_buffer = calloc(1, sizeof * pp_buffer);
 484         if (!pp_buffer) {
 485                 /* LCOV_EXCL_START */
 486                 _pthread_mutex_unlock(&private_display->lock);
 487                 TDM_ERR("alloc failed");
 488                 return TDM_ERROR_OUT_OF_MEMORY;
 489                 /* LCOV_EXCL_STOP */
 490         }
 491
 492         ret = func_pp->pp_attach(private_pp->pp_backend, src, dst);
 493         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 494
 495         if (ret != TDM_ERROR_NONE) {
 496                 /* LCOV_EXCL_START */
 497                 free(pp_buffer);
 498                 _pthread_mutex_unlock(&private_display->lock);
 499                 TDM_ERR("attach failed");
 500                 return ret;
 501                 /* LCOV_EXCL_STOP */
 502         }
 503
 504         LIST_ADDTAIL(&pp_buffer->link, &private_pp->pending_buffer_list);
 505         pp_buffer->src = tdm_buffer_ref_backend(src);
 506         pp_buffer->dst = tdm_buffer_ref_backend(dst);
 507
 508         if (tdm_debug_module & TDM_DEBUG_BUFFER) {
 509                 TDM_INFO("pp(%p) attached:", private_pp);
 510                 _tdm_pp_print_list(&private_pp->pending_buffer_list);
 511         }
 512
 513         if (tdm_ttrace_module & TDM_TTRACE_PP) {
 514                 tbm_bo bo = tbm_surface_internal_get_bo(dst, 0);
 515                 TDM_TRACE_ASYNC_BEGIN((intptr_t)pp, "[PP] %d", tbm_bo_export(bo));
 516         }
 517
 518         _pthread_mutex_unlock(&private_display->lock);
 519
 520         return ret;
 521 }
 522
 523 EXTERN tdm_error
 524 tdm_pp_commit(tdm_pp *pp)
 525 {
 526         tdm_pp_private_buffer *b = NULL, *bb = NULL;
 527         struct list_head commit_buffer_list;
 528
 529         PP_FUNC_ENTRY();
 530
 531         _pthread_mutex_lock(&private_display->lock);
 532
 533         if (!func_pp->pp_commit) {
 534                 /* LCOV_EXCL_START */
 535                 _pthread_mutex_unlock(&private_display->lock);
 536                 TDM_DBG("failed: not implemented!!");
 537                 return TDM_ERROR_NOT_IMPLEMENTED;
 538                 /* LCOV_EXCL_STOP */
 539         }
 540
 541         LIST_INITHEAD(&commit_buffer_list);
 542
 543         LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->pending_buffer_list, link) {
 544                 LIST_DEL(&b->link);
 545                 LIST_ADDTAIL(&b->link, &private_pp->buffer_list);
 546                 LIST_ADDTAIL(&b->commit_link, &commit_buffer_list);
 547         }
 548
 549         ret = func_pp->pp_commit(private_pp->pp_backend);
 550         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 551
 552         LIST_FOR_EACH_ENTRY_SAFE(b, bb, &commit_buffer_list, commit_link) {
 553                 LIST_DELINIT(&b->commit_link);
 554
 555                 if (!_tdm_pp_find_buffer(&private_pp->buffer_list, b))
 556                         continue;
 557
 558                 if (ret != TDM_ERROR_NONE) {
 559                         /* Not to call the user release handler when failed.
 560                          * Do we have to call this function here really?
 561                          * User better use set_done_handler to know when pp is done. Using
 562                          * buffer_release_handler is not good.
 563                          */
 564                         tdm_buffer_remove_release_handler_internal(b->src);
 565                         tdm_buffer_remove_release_handler_internal(b->dst);
 566
 567                         _pthread_mutex_unlock(&private_display->lock);
 568                         tdm_buffer_unref_backend(b->src);
 569                         tdm_buffer_unref_backend(b->dst);
 570                         _pthread_mutex_lock(&private_display->lock);
 571                         LIST_DEL(&b->link);
 572
 573                         free(b);
 574                 }
 575         }
 576
 577         _pthread_mutex_unlock(&private_display->lock);
 578
 579         return ret;
 580 }