src/tdm_capture.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 CAPTURE_FUNC_ENTRY() \
  43         tdm_func_capture *func_capture; \
  44         tdm_private_display *private_display; \
  45         tdm_private_capture *private_capture; \
  46         tdm_error ret = TDM_ERROR_NONE; \
  47         TDM_RETURN_VAL_IF_FAIL(capture != NULL, TDM_ERROR_INVALID_PARAMETER); \
  48         private_capture = (tdm_private_capture*)capture; \
  49         private_display = private_capture->private_display; \
  50         func_capture = &private_display->func_capture
  51
  52 static void
  53 _tdm_capture_print_list(struct list_head *list)
  54 {
  55         tdm_capture_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)", b->buffer);
  65                         p += l;
  66                         len -= l;
  67                 } else
  68                         break;
  69         }
  70
  71         TDM_INFO("\t %s", str);
  72 }
  73
  74 static tdm_capture_private_buffer *
  75 _tdm_capture_find_tbm_buffer(struct list_head *list, tbm_surface_h buffer)
  76 {
  77         tdm_capture_private_buffer *b = NULL, *bb = NULL;
  78
  79         LIST_FOR_EACH_ENTRY_SAFE(b, bb, list, link) {
  80                 if (b->buffer == buffer)
  81                         return b;
  82         }
  83
  84         return NULL;
  85 }
  86
  87 static tdm_capture_private_buffer *
  88 _tdm_capture_find_buffer(struct list_head *list, tdm_capture_private_buffer *capture_buffer)
  89 {
  90         tdm_capture_private_buffer *b = NULL, *bb = NULL;
  91
  92         LIST_FOR_EACH_ENTRY_SAFE(b, bb, list, link) {
  93                 if (b == capture_buffer)
  94                         return b;
  95         }
  96
  97         return NULL;
  98 }
  99
 100 INTERN void
 101 tdm_capture_cb_done(tdm_capture *capture_backend, tbm_surface_h buffer,
 102                                         void *user_data)
 103 {
 104         tdm_private_capture *private_capture = user_data;
 105         tdm_private_display *private_display = private_capture->private_display;
 106         tdm_capture_private_buffer *capture_buffer = NULL, *first_entry = NULL;
 107
 108         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 109
 110         if (private_capture->owner_tid != syscall(SYS_gettid)) {
 111                 tdm_thread_cb_capture_done capture_done;
 112                 tdm_error ret;
 113
 114                 capture_done.base.type = TDM_THREAD_CB_CAPTURE_DONE;
 115                 capture_done.base.length = sizeof capture_done;
 116                 capture_done.capture_stamp = private_capture->stamp;
 117                 capture_done.buffer = buffer;
 118                 capture_done.user_data = user_data;
 119
 120                 ret = tdm_thread_send_cb(private_display->private_loop, &capture_done.base);
 121                 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 122
 123                 return;
 124         }
 125
 126         if (private_capture->owner_tid != syscall(SYS_gettid))
 127                 TDM_NEVER_GET_HERE();
 128
 129         if (tdm_debug_dump & TDM_DUMP_FLAG_CAPTURE) {
 130                 /* LCOV_EXCL_START */
 131                 char str[TDM_PATH_LEN];
 132                 static int i;
 133                 snprintf(str, TDM_PATH_LEN, "capture_%03d", i++);
 134                 tdm_helper_dump_buffer_str(buffer, tdm_debug_dump_dir, str);
 135                 /* LCOV_EXCL_STOP */
 136         }
 137
 138         if (tdm_debug_module & TDM_DEBUG_BUFFER)
 139                 TDM_INFO("capture(%p) done: %p", private_capture, buffer);
 140
 141         if (tdm_ttrace_module & TDM_TTRACE_CAPTURE) {
 142                 tbm_bo bo = tbm_surface_internal_get_bo(buffer, 0);
 143                 TDM_TRACE_ASYNC_END((intptr_t)private_capture, "[CAPTURE] %d", tbm_bo_export(bo));
 144         }
 145
 146         if (!LIST_IS_EMPTY(&private_capture->buffer_list)) {
 147                 first_entry = container_of((&private_capture->buffer_list)->next, capture_buffer, link);
 148                 if (first_entry->buffer != buffer)
 149                         TDM_ERR("buffer(%p) is skipped", first_entry->buffer);
 150         } else {
 151                 TDM_NEVER_GET_HERE();
 152         }
 153
 154         if ((capture_buffer = _tdm_capture_find_tbm_buffer(&private_capture->buffer_list, buffer))) {
 155                 LIST_DEL(&capture_buffer->link);
 156                 LIST_DELINIT(&capture_buffer->commit_link);
 157
 158                 _pthread_mutex_unlock(&private_display->lock);
 159                 if (private_capture->done_func)
 160                         private_capture->done_func(capture_buffer, buffer, private_capture->done_user_data);
 161                 tdm_buffer_unref_backend(buffer);
 162                 _pthread_mutex_lock(&private_display->lock);
 163
 164                 free(capture_buffer);
 165         }
 166 }
 167
 168 INTERN tdm_private_capture *
 169 tdm_capture_find_stamp(tdm_private_display *private_display, double stamp)
 170 {
 171         tdm_private_capture *private_capture = NULL;
 172
 173         TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL);
 174
 175         LIST_FOR_EACH_ENTRY(private_capture, &private_display->capture_list, display_link) {
 176                 if (private_capture->stamp == stamp)
 177                         return private_capture;
 178         }
 179
 180         return NULL;
 181 }
 182
 183 INTERN tdm_private_capture *
 184 tdm_capture_create_output_internal(tdm_private_output *private_output,
 185                                                                    tdm_error *error)
 186 {
 187         tdm_private_display *private_display = private_output->private_display;
 188         tdm_func_output *func_output = &private_display->func_output;
 189         tdm_func_capture *func_capture = &private_display->func_capture;
 190         tdm_private_capture *private_capture = NULL;
 191         tdm_capture *capture_backend = NULL;
 192         tdm_error ret = TDM_ERROR_NONE;
 193
 194         TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL);
 195
 196         if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
 197                 /* LCOV_EXCL_START */
 198                 TDM_ERR("no capture capability");
 199                 if (error)
 200                         *error = TDM_ERROR_NO_CAPABILITY;
 201                 return NULL;
 202                 /* LCOV_EXCL_STOP */
 203         }
 204
 205         if (!(private_display->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT)) {
 206                 /* LCOV_EXCL_START */
 207                 TDM_ERR("no output capture capability");
 208                 if (error)
 209                         *error = TDM_ERROR_NO_CAPABILITY;
 210                 return NULL;
 211                 /* LCOV_EXCL_STOP */
 212         }
 213
 214         capture_backend = func_output->output_create_capture(
 215                                                   private_output->output_backend, &ret);
 216         if (ret != TDM_ERROR_NONE) {
 217                 /* LCOV_EXCL_START */
 218                 if (error)
 219                         *error = ret;
 220                 return NULL;
 221                 /* LCOV_EXCL_STOP */
 222         }
 223
 224         private_capture = calloc(1, sizeof(tdm_private_capture));
 225         if (!private_capture) {
 226                 /* LCOV_EXCL_START */
 227                 TDM_ERR("failed: alloc memory");
 228                 func_capture->capture_destroy(capture_backend);
 229                 if (error)
 230                         *error = TDM_ERROR_OUT_OF_MEMORY;
 231                 return NULL;
 232                 /* LCOV_EXCL_STOP */
 233         }
 234
 235         ret = func_capture->capture_set_done_handler(capture_backend,
 236                         tdm_capture_cb_done, private_capture);
 237         if (ret != TDM_ERROR_NONE) {
 238                 /* LCOV_EXCL_START */
 239                 TDM_ERR("capture(%p) set capture_done_handler failed", private_capture);
 240                 func_capture->capture_destroy(capture_backend);
 241                 if (error)
 242                         *error = ret;
 243                 return NULL;
 244                 /* LCOV_EXCL_STOP */
 245         }
 246
 247         private_capture->stamp = tdm_helper_get_time();
 248         while (tdm_capture_find_stamp(private_display, private_capture->stamp))
 249                 private_capture->stamp++;
 250
 251         LIST_ADD(&private_capture->link, &private_output->capture_list);
 252         LIST_ADD(&private_capture->display_link, &private_display->capture_list);
 253
 254         private_capture->target = TDM_CAPTURE_TARGET_OUTPUT;
 255         private_capture->private_display = private_display;
 256         private_capture->private_output = private_output;
 257         private_capture->private_layer = NULL;
 258         private_capture->capture_backend = capture_backend;
 259         private_capture->owner_tid = syscall(SYS_gettid);
 260
 261         LIST_INITHEAD(&private_capture->pending_buffer_list);
 262         LIST_INITHEAD(&private_capture->buffer_list);
 263
 264         TDM_DBG("capture(%p) create", private_capture);
 265
 266         if (error)
 267                 *error = TDM_ERROR_NONE;
 268
 269         return private_capture;
 270 }
 271
 272 /* LCOV_EXCL_START */
 273 INTERN tdm_private_capture *
 274 tdm_capture_create_layer_internal(tdm_private_layer *private_layer,
 275                                                                   tdm_error *error)
 276 {
 277         tdm_private_output *private_output = private_layer->private_output;
 278         tdm_private_display *private_display = private_output->private_display;
 279         tdm_func_layer *func_layer = &private_display->func_layer;
 280         tdm_func_capture *func_capture = &private_display->func_capture;
 281         tdm_private_capture *private_capture = NULL;
 282         tdm_capture *capture_backend = NULL;
 283         tdm_error ret = TDM_ERROR_NONE;
 284
 285         TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL);
 286
 287         if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
 288                 TDM_ERR("no capture capability");
 289                 if (error)
 290                         *error = TDM_ERROR_NO_CAPABILITY;
 291                 return NULL;
 292         }
 293
 294         if (!(private_display->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_LAYER)) {
 295                 TDM_ERR("no layer capture capability");
 296                 if (error)
 297                         *error = TDM_ERROR_NO_CAPABILITY;
 298                 return NULL;
 299         }
 300
 301         capture_backend = func_layer->layer_create_capture(private_layer->layer_backend,
 302                                           &ret);
 303         if (ret != TDM_ERROR_NONE)
 304                 return NULL;
 305
 306         private_capture = calloc(1, sizeof(tdm_private_capture));
 307         if (!private_capture) {
 308                 TDM_ERR("failed: alloc memory");
 309                 func_capture->capture_destroy(capture_backend);
 310                 if (error)
 311                         *error = TDM_ERROR_OUT_OF_MEMORY;
 312                 return NULL;
 313         }
 314
 315         private_capture->stamp = tdm_helper_get_time();
 316         while (tdm_capture_find_stamp(private_display, private_capture->stamp))
 317                 private_capture->stamp++;
 318
 319         LIST_ADD(&private_capture->link, &private_layer->capture_list);
 320         LIST_ADD(&private_capture->display_link, &private_display->capture_list);
 321
 322         private_capture->target = TDM_CAPTURE_TARGET_LAYER;
 323         private_capture->private_display = private_display;
 324         private_capture->private_output = private_output;
 325         private_capture->private_layer = private_layer;
 326         private_capture->capture_backend = capture_backend;
 327         private_capture->owner_tid = syscall(SYS_gettid);
 328
 329         LIST_INITHEAD(&private_capture->pending_buffer_list);
 330         LIST_INITHEAD(&private_capture->buffer_list);
 331
 332         TDM_DBG("capture(%p) create", private_capture);
 333
 334         if (error)
 335                 *error = TDM_ERROR_NONE;
 336
 337         return private_capture;
 338 }
 339 /* LCOV_EXCL_STOP */
 340
 341 INTERN void
 342 tdm_capture_destroy_internal(tdm_private_capture *private_capture)
 343 {
 344         tdm_private_display *private_display;
 345         tdm_func_capture *func_capture;
 346         tdm_capture_private_buffer *b = NULL, *bb = NULL;
 347         struct list_head clone_list;
 348
 349         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 350
 351         if (!private_capture)
 352                 return;
 353
 354         private_display = private_capture->private_display;
 355
 356         LIST_DEL(&private_capture->link);
 357         LIST_DEL(&private_capture->display_link);
 358
 359         func_capture = &private_capture->private_display->func_capture;
 360         func_capture->capture_destroy(private_capture->capture_backend);
 361
 362         if (!LIST_IS_EMPTY(&private_capture->pending_buffer_list)) {
 363                 TDM_WRN("capture(%p) not finished:", private_capture);
 364                 _tdm_capture_print_list(&private_capture->pending_buffer_list);
 365
 366                 LIST_INITHEAD(&clone_list);
 367                 LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_capture->pending_buffer_list, link) {
 368                         LIST_DEL(&b->link);
 369                         LIST_ADDTAIL(&b->link, &clone_list);
 370                 }
 371
 372                 _pthread_mutex_unlock(&private_display->lock);
 373                 LIST_FOR_EACH_ENTRY_SAFE(b, bb, &clone_list, link) {
 374                         LIST_DEL(&b->link);
 375
 376                         if (tdm_ttrace_module & TDM_TTRACE_CAPTURE) {
 377                                 tbm_bo bo = tbm_surface_internal_get_bo(b->buffer, 0);
 378                                 TDM_TRACE_ASYNC_END((intptr_t)private_capture, "[CAPTURE] %d", tbm_bo_export(bo));
 379                         }
 380
 381                         tdm_buffer_unref_backend(b->buffer);
 382                         free(b);
 383                 }
 384                 _pthread_mutex_lock(&private_display->lock);
 385         }
 386
 387         if (!LIST_IS_EMPTY(&private_capture->buffer_list)) {
 388                 TDM_WRN("capture(%p) not finished:", private_capture);
 389                 _tdm_capture_print_list(&private_capture->buffer_list);
 390
 391                 LIST_INITHEAD(&clone_list);
 392                 LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_capture->buffer_list, link) {
 393                         LIST_DEL(&b->link);
 394                         LIST_ADDTAIL(&b->link, &clone_list);
 395                 }
 396
 397                 _pthread_mutex_unlock(&private_display->lock);
 398                 LIST_FOR_EACH_ENTRY_SAFE(b, bb, &clone_list, link) {
 399                         LIST_DEL(&b->link);
 400
 401                         if (tdm_ttrace_module & TDM_TTRACE_CAPTURE) {
 402                                 tbm_bo bo = tbm_surface_internal_get_bo(b->buffer, 0);
 403                                 TDM_TRACE_ASYNC_END((intptr_t)private_capture, "[CAPTURE] %d", tbm_bo_export(bo));
 404                         }
 405
 406                         tdm_buffer_unref_backend(b->buffer);
 407                         free(b);
 408                 }
 409                 _pthread_mutex_lock(&private_display->lock);
 410         }
 411
 412         private_capture->stamp = 0;
 413         free(private_capture);
 414 }
 415
 416 EXTERN void
 417 tdm_capture_destroy(tdm_capture *capture)
 418 {
 419         tdm_private_capture *private_capture = capture;
 420         tdm_private_display *private_display;
 421
 422         if (!private_capture)
 423                 return;
 424
 425         TDM_DBG("capture(%p) destroy", private_capture);
 426
 427         private_display = private_capture->private_display;
 428
 429         _pthread_mutex_lock(&private_display->lock);
 430         tdm_capture_destroy_internal(private_capture);
 431         _pthread_mutex_unlock(&private_display->lock);
 432 }
 433
 434 EXTERN tdm_error
 435 tdm_capture_set_info(tdm_capture *capture, tdm_info_capture *info)
 436 {
 437         CAPTURE_FUNC_ENTRY();
 438
 439         TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
 440         TDM_RETURN_VAL_IF_FAIL(info->type != 0, TDM_ERROR_INVALID_PARAMETER);
 441
 442         _pthread_mutex_lock(&private_display->lock);
 443
 444         if (!func_capture->capture_set_info) {
 445                 /* LCOV_EXCL_START */
 446                 _pthread_mutex_unlock(&private_display->lock);
 447                 TDM_DBG("failed: not implemented!!");
 448                 return TDM_ERROR_NOT_IMPLEMENTED;
 449                 /* LCOV_EXCL_STOP */
 450         }
 451
 452         if (info->type == TDM_CAPTURE_TYPE_STREAM && info->frequency == 0) {
 453                 tdm_private_output *private_output = private_capture->private_output;
 454                 info->frequency = private_output->current_mode->vrefresh;
 455         }
 456
 457         TDM_INFO("capture(%p) info: dst(%ux%u %u,%u %ux%u %c%c%c%c) trans(%d) type(%d) freq(%d) flags(%x)",
 458                          private_capture,
 459                          info->dst_config.size.h, info->dst_config.size.v,
 460                          info->dst_config.pos.x, info->dst_config.pos.y,
 461                          info->dst_config.pos.w, info->dst_config.pos.h,
 462                          FOURCC_STR(info->dst_config.format),
 463                          info->transform, info->type, info->frequency, info->flags);
 464
 465         ret = func_capture->capture_set_info(private_capture->capture_backend, info);
 466         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 467
 468         private_capture->info = *info;
 469
 470         _pthread_mutex_unlock(&private_display->lock);
 471
 472         return ret;
 473 }
 474
 475 EXTERN tdm_error
 476 tdm_capture_set_done_handler(tdm_capture *capture, tdm_capture_done_handler func, void *user_data)
 477 {
 478         tdm_private_display *private_display;
 479         tdm_private_capture *private_capture;
 480         tdm_error ret = TDM_ERROR_NONE;
 481
 482         TDM_RETURN_VAL_IF_FAIL(capture != NULL, TDM_ERROR_INVALID_PARAMETER);
 483
 484         private_capture = (tdm_private_capture*)capture;
 485         private_display = private_capture->private_display;
 486
 487         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 488
 489         _pthread_mutex_lock(&private_display->lock);
 490
 491         private_capture->done_func = func;
 492         private_capture->done_user_data = user_data;
 493
 494         _pthread_mutex_unlock(&private_display->lock);
 495
 496         return ret;
 497 }
 498
 499 EXTERN tdm_error
 500 tdm_capture_attach(tdm_capture *capture, tbm_surface_h buffer)
 501 {
 502         tdm_capture_private_buffer *capture_buffer;
 503
 504         CAPTURE_FUNC_ENTRY();
 505
 506         TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER);
 507
 508         _pthread_mutex_lock(&private_display->lock);
 509
 510         if (!func_capture->capture_attach) {
 511                 /* LCOV_EXCL_START */
 512                 _pthread_mutex_unlock(&private_display->lock);
 513                 TDM_DBG("failed: not implemented!!");
 514                 return TDM_ERROR_NOT_IMPLEMENTED;
 515                 /* LCOV_EXCL_STOP */
 516         }
 517
 518         if (tdm_display_check_module_abi(private_display, 1, 2) &&
 519                 private_display->caps_capture.max_attach_count > 0) {
 520                 /* LCOV_EXCL_START */
 521                 int length = LIST_LENGTH(&private_capture->pending_buffer_list) +
 522                                          LIST_LENGTH(&private_capture->buffer_list);
 523                 if (length >= private_display->caps_capture.max_attach_count) {
 524                         _pthread_mutex_unlock(&private_display->lock);
 525                         TDM_DBG("failed: too many attached!! max_attach_count(%d)",
 526                                         private_display->caps_capture.max_attach_count);
 527                         return TDM_ERROR_BAD_REQUEST;
 528                 }
 529                 /* LCOV_EXCL_STOP */
 530         }
 531
 532         capture_buffer = calloc(1, sizeof * capture_buffer);
 533         if (!capture_buffer) {
 534                 /* LCOV_EXCL_START */
 535                 _pthread_mutex_unlock(&private_display->lock);
 536                 TDM_ERR("alloc failed");
 537                 return TDM_ERROR_OUT_OF_MEMORY;
 538                 /* LCOV_EXCL_STOP */
 539         }
 540
 541         ret = func_capture->capture_attach(private_capture->capture_backend, buffer);
 542         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 543
 544         if (ret != TDM_ERROR_NONE) {
 545                 /* LCOV_EXCL_START */
 546                 free(capture_buffer);
 547                 _pthread_mutex_unlock(&private_display->lock);
 548                 TDM_ERR("attach failed");
 549                 return ret;
 550                 /* LCOV_EXCL_STOP */
 551         }
 552
 553         LIST_ADDTAIL(&capture_buffer->link, &private_capture->pending_buffer_list);
 554         capture_buffer->buffer = tdm_buffer_ref_backend(buffer);
 555
 556         if (tdm_debug_module & TDM_DEBUG_BUFFER) {
 557                 TDM_INFO("capture(%p) attached:", private_capture);
 558                 tdm_buffer_list_dump(&private_capture->buffer_list);
 559         }
 560
 561         if (tdm_ttrace_module & TDM_TTRACE_CAPTURE) {
 562                 tbm_bo bo = tbm_surface_internal_get_bo(buffer, 0);
 563                 TDM_TRACE_ASYNC_BEGIN((intptr_t)capture, "[CAPTURE] %d", tbm_bo_export(bo));
 564         }
 565
 566         _pthread_mutex_unlock(&private_display->lock);
 567
 568         return ret;
 569 }
 570
 571 EXTERN tdm_error
 572 tdm_capture_commit(tdm_capture *capture)
 573 {
 574         tdm_capture_private_buffer *b = NULL, *bb = NULL;
 575         tdm_private_output *private_output;
 576         struct list_head commit_buffer_list;
 577
 578         CAPTURE_FUNC_ENTRY();
 579
 580         _pthread_mutex_lock(&private_display->lock);
 581
 582         private_output = private_capture->private_output;
 583
 584         /* TODO: possible when standby mode? can't decide it yet. no scenario. */
 585         if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->current_dpms_value)) {
 586                 TDM_ERR("output(%d) dpms: %s", private_output->pipe,
 587                                 tdm_dpms_str(private_output->current_dpms_value));
 588                 _pthread_mutex_unlock(&private_display->lock);
 589                 return TDM_ERROR_BAD_REQUEST;
 590         }
 591
 592         if (!func_capture->capture_commit) {
 593                 /* LCOV_EXCL_START */
 594                 _pthread_mutex_unlock(&private_display->lock);
 595                 TDM_DBG("failed: not implemented!!");
 596                 return TDM_ERROR_NOT_IMPLEMENTED;
 597                 /* LCOV_EXCL_STOP */
 598         }
 599
 600         LIST_INITHEAD(&commit_buffer_list);
 601
 602         LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_capture->pending_buffer_list, link) {
 603                 LIST_DEL(&b->link);
 604                 LIST_ADDTAIL(&b->link, &private_capture->buffer_list);
 605                 LIST_ADDTAIL(&b->commit_link, &commit_buffer_list);
 606         }
 607
 608         ret = func_capture->capture_commit(private_capture->capture_backend);
 609         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 610
 611         LIST_FOR_EACH_ENTRY_SAFE(b, bb, &commit_buffer_list, commit_link) {
 612                 LIST_DELINIT(&b->commit_link);
 613
 614                 if (!_tdm_capture_find_buffer(&private_capture->buffer_list, b))
 615                         continue;
 616
 617                 if (ret != TDM_ERROR_NONE) {
 618                         /* LCOV_EXCL_START */
 619                         /* Not to call the user release handler when failed.
 620                          * Do we have to call this function here really?
 621                          * User better use set_done_handler to know when pp is done. Using
 622                          * buffer_release_handler is not good.
 623                          */
 624                         tdm_buffer_remove_release_handler_internal(b->buffer);
 625
 626                         _pthread_mutex_unlock(&private_display->lock);
 627                         tdm_buffer_unref_backend(b->buffer);
 628                         _pthread_mutex_lock(&private_display->lock);
 629                         LIST_DEL(&b->link);
 630
 631                         free(b);
 632                         /* LCOV_EXCL_STOP */
 633                 }
 634         }
 635
 636         _pthread_mutex_unlock(&private_display->lock);
 637
 638         return ret;
 639 }