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