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.h"
  41 #include "tdm_backend.h"
  42 #include "tdm_private.h"
  43
  44 #define CAPTURE_FUNC_ENTRY() \
  45     tdm_func_capture *func_capture; \
  46     tdm_private_display *private_display; \
  47     tdm_private_capture *private_capture; \
  48     tdm_error ret = TDM_ERROR_NONE; \
  49     TDM_RETURN_VAL_IF_FAIL(capture != NULL, TDM_ERROR_INVALID_PARAMETER); \
  50     private_capture = (tdm_private_capture*)capture; \
  51     private_display = private_capture->private_display; \
  52     func_capture = &private_display->func_capture
  53
  54 static void
  55 _tdm_caputre_cb_done(tdm_capture *capture_backend, tbm_surface_h buffer,
  56                      void *user_data)
  57 {
  58         tdm_private_capture *private_capture = user_data;
  59         tdm_private_display *private_display = private_capture->private_display;
  60         int lock_after_cb_done = 0;
  61         int ret;
  62
  63         ret = pthread_mutex_trylock(&private_display->lock);
  64         if (ret == 0)
  65                 pthread_mutex_unlock(&private_display->lock);
  66         else  if (ret == EBUSY) {
  67                 pthread_mutex_unlock(&private_display->lock);
  68                 lock_after_cb_done = 1;
  69         }
  70
  71         if (tdm_debug_buffer)
  72                 TDM_INFO("done: %p", buffer);
  73
  74         tdm_buffer_remove_list(&private_capture->buffer_list, buffer);
  75
  76         tdm_buffer_unref_backend(buffer);
  77
  78         if (lock_after_cb_done)
  79                 pthread_mutex_lock(&private_display->lock);
  80 }
  81
  82 INTERN tdm_private_capture *
  83 tdm_capture_create_output_internal(tdm_private_output *private_output,
  84                                    tdm_error *error)
  85 {
  86         tdm_private_display *private_display = private_output->private_display;
  87         tdm_func_output *func_output = &private_display->func_output;
  88         tdm_func_capture *func_capture = &private_display->func_capture;
  89         tdm_private_capture *private_capture = NULL;
  90         tdm_capture *capture_backend = NULL;
  91         tdm_error ret = TDM_ERROR_NONE;
  92
  93         if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
  94                 TDM_ERR("no capture capability");
  95                 if (error)
  96                         *error = TDM_ERROR_NO_CAPABILITY;
  97                 return NULL;
  98         }
  99
 100         capture_backend = func_output->output_create_capture(
 101                                   private_output->output_backend, &ret);
 102         if (ret != TDM_ERROR_NONE) {
 103                 if (error)
 104                         *error = ret;
 105                 return NULL;
 106         }
 107
 108         private_capture = calloc(1, sizeof(tdm_private_capture));
 109         if (!private_capture) {
 110                 TDM_ERR("failed: alloc memory");
 111                 func_capture->capture_destroy(capture_backend);
 112                 if (error)
 113                         *error = TDM_ERROR_OUT_OF_MEMORY;
 114                 return NULL;
 115         }
 116
 117         ret = func_capture->capture_set_done_handler(capture_backend,
 118                         _tdm_caputre_cb_done, private_capture);
 119         if (ret != TDM_ERROR_NONE) {
 120                 TDM_ERR("set capture_done_handler failed");
 121                 func_capture->capture_destroy(capture_backend);
 122                 if (error)
 123                         *error = ret;
 124                 return NULL;
 125         }
 126
 127         LIST_ADD(&private_capture->link, &private_output->capture_list);
 128         private_capture->target = TDM_CAPTURE_TARGET_OUTPUT;
 129         private_capture->private_display = private_display;
 130         private_capture->private_output = private_output;
 131         private_capture->private_layer = NULL;
 132         private_capture->capture_backend = capture_backend;
 133
 134         LIST_INITHEAD(&private_capture->buffer_list);
 135
 136         if (error)
 137                 *error = TDM_ERROR_NONE;
 138
 139         return private_capture;
 140 }
 141
 142 INTERN tdm_private_capture *
 143 tdm_capture_create_layer_internal(tdm_private_layer *private_layer,
 144                                   tdm_error *error)
 145 {
 146         tdm_private_output *private_output = private_layer->private_output;
 147         tdm_private_display *private_display = private_output->private_display;
 148         tdm_func_layer *func_layer = &private_display->func_layer;
 149         tdm_func_capture *func_capture = &private_display->func_capture;
 150         tdm_private_capture *private_capture = NULL;
 151         tdm_capture *capture_backend = NULL;
 152         tdm_error ret = TDM_ERROR_NONE;
 153
 154         if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
 155                 TDM_ERR("no capture capability");
 156                 if (error)
 157                         *error = TDM_ERROR_NO_CAPABILITY;
 158                 return NULL;
 159         }
 160
 161         capture_backend = func_layer->layer_create_capture(private_layer->layer_backend,
 162                           &ret);
 163         if (ret != TDM_ERROR_NONE)
 164                 return NULL;
 165
 166         private_capture = calloc(1, sizeof(tdm_private_capture));
 167         if (!private_capture) {
 168                 TDM_ERR("failed: alloc memory");
 169                 func_capture->capture_destroy(capture_backend);
 170                 if (error)
 171                         *error = TDM_ERROR_OUT_OF_MEMORY;
 172                 return NULL;
 173         }
 174
 175         LIST_ADD(&private_capture->link, &private_output->capture_list);
 176         private_capture->target = TDM_CAPTURE_TARGET_LAYER;
 177         private_capture->private_display = private_display;
 178         private_capture->private_output = private_output;
 179         private_capture->private_layer = private_layer;
 180         private_capture->capture_backend = capture_backend;
 181
 182         LIST_INITHEAD(&private_capture->buffer_list);
 183
 184         if (error)
 185                 *error = TDM_ERROR_NONE;
 186
 187         return private_capture;
 188 }
 189
 190 INTERN void
 191 tdm_capture_destroy_internal(tdm_private_capture *private_capture)
 192 {
 193         tdm_func_capture *func_capture;
 194
 195         if (!private_capture)
 196                 return;
 197
 198         LIST_DEL(&private_capture->link);
 199
 200         func_capture = &private_capture->private_display->func_capture;
 201         func_capture->capture_destroy(private_capture->capture_backend);
 202
 203         if (!LIST_IS_EMPTY(&private_capture->buffer_list)) {
 204                 char str[256] = {0,};
 205                 tdm_buffer_dump_list(&private_capture->buffer_list, str, 256);
 206                 if (strlen(str) > 0)
 207                         TDM_WRN("not finished: %s buffers", str);
 208         }
 209
 210         free(private_capture);
 211 }
 212
 213 EXTERN void
 214 tdm_capture_destroy(tdm_capture *capture)
 215 {
 216         tdm_private_capture *private_capture = capture;
 217         tdm_private_display *private_display;
 218
 219         if (!private_capture)
 220                 return;
 221
 222         private_display = private_capture->private_display;
 223
 224         pthread_mutex_lock(&private_display->lock);
 225         tdm_capture_destroy_internal(private_capture);
 226         pthread_mutex_unlock(&private_display->lock);
 227 }
 228
 229 EXTERN tdm_error
 230 tdm_capture_set_info(tdm_capture *capture, tdm_info_capture *info)
 231 {
 232         CAPTURE_FUNC_ENTRY();
 233
 234         TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
 235
 236         pthread_mutex_lock(&private_display->lock);
 237
 238         if (!func_capture->capture_set_info) {
 239                 pthread_mutex_unlock(&private_display->lock);
 240                 return TDM_ERROR_NONE;
 241         }
 242
 243         ret = func_capture->capture_set_info(private_capture->capture_backend, info);
 244
 245         pthread_mutex_unlock(&private_display->lock);
 246
 247         return ret;
 248 }
 249
 250 EXTERN tdm_error
 251 tdm_capture_attach(tdm_capture *capture, tbm_surface_h buffer)
 252 {
 253         CAPTURE_FUNC_ENTRY();
 254
 255         TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER);
 256
 257         pthread_mutex_lock(&private_display->lock);
 258
 259         if (!func_capture->capture_attach) {
 260                 pthread_mutex_unlock(&private_display->lock);
 261                 return TDM_ERROR_NONE;
 262         }
 263
 264         tdm_buffer_ref_backend(buffer);
 265         ret = func_capture->capture_attach(private_capture->capture_backend, buffer);
 266
 267         if (ret == TDM_ERROR_NONE)
 268                 tdm_buffer_add_list(&private_capture->buffer_list, buffer);
 269
 270         if (tdm_debug_buffer) {
 271                 char str[256] = {0,};
 272                 tdm_buffer_dump_list(&private_capture->buffer_list, str, 256);
 273                 TDM_INFO("attached: %s", str);
 274         }
 275
 276         pthread_mutex_unlock(&private_display->lock);
 277
 278         return ret;
 279 }
 280
 281 EXTERN tdm_error
 282 tdm_capture_commit(tdm_capture *capture)
 283 {
 284         CAPTURE_FUNC_ENTRY();
 285
 286         pthread_mutex_lock(&private_display->lock);
 287
 288         if (!func_capture->capture_commit) {
 289                 pthread_mutex_unlock(&private_display->lock);
 290                 return TDM_ERROR_NONE;
 291         }
 292
 293         ret = func_capture->capture_commit(private_capture->capture_backend);
 294
 295         pthread_mutex_unlock(&private_display->lock);
 296
 297         return ret;
 298 }