/**************************************************************************
-
-libtdm
-
-Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
-
-Contact: Eunchul Kim <chulspro.kim@samsung.com>,
- JinYoung Jeon <jy0.jeon@samsung.com>,
- Taeheon Kim <th908.kim@samsung.com>,
- YoungJun Cho <yj44.cho@samsung.com>,
- SooChan Lim <sc1.lim@samsung.com>,
- Boram Park <sc1.lim@samsung.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sub license, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice (including the
-next paragraph) shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
-IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
-ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
+ *
+ * libtdm
+ *
+ * Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
+ *
+ * Contact: Eunchul Kim <chulspro.kim@samsung.com>,
+ * JinYoung Jeon <jy0.jeon@samsung.com>,
+ * Taeheon Kim <th908.kim@samsung.com>,
+ * YoungJun Cho <yj44.cho@samsung.com>,
+ * SooChan Lim <sc1.lim@samsung.com>,
+ * Boram Park <sc1.lim@samsung.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
**************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
-#include "tdm.h"
-#include "tdm_backend.h"
#include "tdm_private.h"
#define COUNT_MAX 10
#define DISPLAY_FUNC_ENTRY() \
- tdm_private_display *private_display; \
- tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
- TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER); \
- private_display = (tdm_private_display*)dpy;
+ tdm_private_display *private_display; \
+ tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
+ TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER); \
+ TDM_RETURN_VAL_IF_FAIL(tdm_display_is_valid(dpy), TDM_ERROR_INVALID_PARAMETER); \
+ private_display = (tdm_private_display*)dpy;
#define DISPLAY_FUNC_ENTRY_ERROR() \
- tdm_private_display *private_display; \
- tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
- TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
- private_display = (tdm_private_display*)dpy;
-
-#define OUTPUT_FUNC_ENTRY() \
- tdm_private_display *private_display; \
- tdm_private_output *private_output; \
- tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
- TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER); \
- private_output = (tdm_private_output*)output; \
- private_display = private_output->private_display
-
-#define OUTPUT_FUNC_ENTRY_ERROR() \
- tdm_private_display *private_display; \
- tdm_private_output *private_output; \
- tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
- TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(output != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
- private_output = (tdm_private_output*)output; \
- private_display = private_output->private_display
-
-#define LAYER_FUNC_ENTRY() \
- tdm_private_display *private_display; \
- tdm_private_output *private_output; \
- tdm_private_layer *private_layer; \
- tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
- TDM_RETURN_VAL_IF_FAIL(layer != NULL, TDM_ERROR_INVALID_PARAMETER); \
- private_layer = (tdm_private_layer*)layer; \
- private_output = private_layer->private_output; \
- private_display = private_output->private_display
-
-#define LAYER_FUNC_ENTRY_ERROR() \
- tdm_private_display *private_display; \
- tdm_private_output *private_output; \
- tdm_private_layer *private_layer; \
- tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
- TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(layer != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
- private_layer = (tdm_private_layer*)layer; \
- private_output = private_layer->private_output; \
- private_display = private_output->private_display
-
-EXTERN tdm_error
-tdm_display_get_capabilities(tdm_display *dpy, tdm_display_capability *capabilities)
-{
- DISPLAY_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- pthread_mutex_lock(&private_display->lock);
-
- *capabilities = private_display->capabilities;
-
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_display_get_pp_capabilities(tdm_display *dpy, tdm_pp_capability *capabilities)
-{
- DISPLAY_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- pthread_mutex_lock(&private_display->lock);
+ tdm_private_display *private_display; \
+ tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
+ TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
+ TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(tdm_display_is_valid(dpy), TDM_ERROR_INVALID_PARAMETER, NULL); \
+ private_display = (tdm_private_display*)dpy;
- *capabilities = private_display->caps_pp.capabilities;
-
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
+#define BACKEND_FUNC_ENTRY() \
+ tdm_private_module *private_module; \
+ tdm_private_display *private_display; \
+ tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
+ TDM_RETURN_VAL_IF_FAIL(module != NULL, TDM_ERROR_INVALID_PARAMETER); \
+ private_module = (tdm_private_module*)module; \
+ private_display = private_module->private_display;
EXTERN tdm_error
-tdm_display_get_pp_available_formats(tdm_display *dpy, const tbm_format **formats, int *count)
+tdm_display_get_capabilities(tdm_display *dpy,
+ tdm_display_capability *capabilities)
{
- DISPLAY_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
- TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
+ tdm_private_module *private_module = NULL;
- pthread_mutex_lock(&private_display->lock);
+ DISPLAY_FUNC_ENTRY();
- *formats = (const tbm_format*)private_display->caps_pp.formats;
- *count = private_display->caps_pp.format_count;
+ TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h,
- int *max_w, int *max_h, int *preferred_align)
-{
- DISPLAY_FUNC_ENTRY();
+ _pthread_mutex_lock(&private_display->lock);
- pthread_mutex_lock(&private_display->lock);
+ *capabilities = 0;
- if (min_w)
- *min_w = private_display->caps_pp.min_w;
- if (min_h)
- *min_h = private_display->caps_pp.min_h;
- if (max_w)
- *max_w = private_display->caps_pp.max_w;
- if (max_h)
- *max_h = private_display->caps_pp.max_h;
- if (preferred_align)
- *preferred_align = private_display->caps_pp.preferred_align;
+ LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+ *capabilities |= private_module->capabilities;
+ }
- pthread_mutex_unlock(&private_display->lock);
+ _pthread_mutex_unlock(&private_display->lock);
- return ret;
+ return ret;
}
EXTERN tdm_error
-tdm_display_get_capture_capabilities(tdm_display *dpy, tdm_capture_capability *capabilities)
+tdm_display_get_pp_capabilities(tdm_display *dpy,
+ tdm_pp_capability *capabilities)
{
- DISPLAY_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- pthread_mutex_lock(&private_display->lock);
+ tdm_private_module *pp_module;
- *capabilities = private_display->caps_capture.capabilities;
+ DISPLAY_FUNC_ENTRY();
- pthread_mutex_unlock(&private_display->lock);
+ TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
- return ret;
-}
-
-EXTERN tdm_error
-tdm_display_get_catpure_available_formats(tdm_display *dpy, const tbm_format **formats, int *count)
-{
- DISPLAY_FUNC_ENTRY();
+ _pthread_mutex_lock(&private_display->lock);
- TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
- TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
+ if (!private_display->pp_module) {
+ /* LCOV_EXCL_START */
+ TDM_ERR("no pp capability");
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_NO_CAPABILITY;
+ /* LCOV_EXCL_STOP */
+ }
- pthread_mutex_lock(&private_display->lock);
+ pp_module = private_display->pp_module;
- *formats = (const tbm_format*)private_display->caps_capture.formats;
- *count = private_display->caps_capture.format_count;
+ *capabilities = pp_module->caps_pp.capabilities;
- pthread_mutex_unlock(&private_display->lock);
+ _pthread_mutex_unlock(&private_display->lock);
- return ret;
+ return ret;
}
EXTERN tdm_error
-tdm_display_get_output_count(tdm_display *dpy, int *count)
-{
- tdm_private_output *private_output = NULL;
-
- DISPLAY_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- pthread_mutex_lock(&private_display->lock);
-
- *count = 0;
- LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link)
- (*count)++;
-
- if (*count == 0)
- {
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
-
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-
-EXTERN const tdm_output*
-tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error)
+tdm_display_get_pp_available_formats(tdm_display *dpy,
+ const tbm_format **formats, int *count)
{
- tdm_private_output *private_output = NULL;
- int i = 0;
-
- DISPLAY_FUNC_ENTRY_ERROR();
-
- pthread_mutex_lock(&private_display->lock);
-
- if (error)
- *error = TDM_ERROR_NONE;
+ tdm_private_module *pp_module;
- i = 0;
- LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link)
- {
- if (i == index)
- {
- pthread_mutex_unlock(&private_display->lock);
- return (const tdm_output*)private_output;
- }
- i++;
- }
+ DISPLAY_FUNC_ENTRY();
- pthread_mutex_unlock(&private_display->lock);
+ TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
+ TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
- return NULL;
-}
-
-EXTERN tdm_error
-tdm_display_get_fd(tdm_display *dpy, int *fd)
-{
- tdm_func_display *func_display;
- DISPLAY_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
+ _pthread_mutex_lock(&private_display->lock);
- pthread_mutex_lock(&private_display->lock);
+ if (!private_display->pp_module) {
+ /* LCOV_EXCL_START */
+ TDM_ERR("no pp capability");
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_NO_CAPABILITY;
+ /* LCOV_EXCL_STOP */
+ }
- func_display = &private_display->func_display;
+ pp_module = private_display->pp_module;
- if (!func_display->display_get_fd)
- {
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
+ *formats = (const tbm_format *)pp_module->caps_pp.formats;
+ *count = pp_module->caps_pp.format_count;
- ret = func_display->display_get_fd(private_display->bdata, fd);
+ _pthread_mutex_unlock(&private_display->lock);
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
+ return ret;
}
EXTERN tdm_error
-tdm_display_handle_events(tdm_display *dpy)
-{
- tdm_func_display *func_display;
- DISPLAY_FUNC_ENTRY();
-
- pthread_mutex_lock(&private_display->lock);
-
- func_display = &private_display->func_display;
-
- if (!func_display->display_handle_events)
- {
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
-
- ret = func_display->display_handle_events(private_display->bdata);
-
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_pp*
-tdm_display_create_pp(tdm_display *dpy, tdm_error *error)
-{
- tdm_pp *pp;
-
- DISPLAY_FUNC_ENTRY_ERROR();
-
- pthread_mutex_lock(&private_display->lock);
-
- pp = (tdm_pp*)tdm_pp_create_internal(private_display, error);
-
- pthread_mutex_unlock(&private_display->lock);
-
- return pp;
-}
-
-EXTERN tdm_error
-tdm_output_get_conn_status(tdm_output *output, tdm_output_conn_status *status)
-{
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- pthread_mutex_lock(&private_display->lock);
-
- *status = private_output->caps.status;
-
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_get_output_type(tdm_output *output, tdm_output_type *type)
-{
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(type != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- pthread_mutex_lock(&private_display->lock);
-
- *type = private_output->caps.type;
-
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_get_layer_count(tdm_output *output, int *count)
-{
- tdm_private_layer *private_layer = NULL;
-
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- pthread_mutex_lock(&private_display->lock);
-
- *count = 0;
- LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link)
- (*count)++;
- if (*count == 0)
- {
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
-
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-
-EXTERN const tdm_layer*
-tdm_output_get_layer(tdm_output *output, int index, tdm_error *error)
-{
- tdm_private_layer *private_layer = NULL;
- int i = 0;
-
- OUTPUT_FUNC_ENTRY_ERROR();
-
- pthread_mutex_lock(&private_display->lock);
-
- if (error)
- *error = TDM_ERROR_NONE;
-
- LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link)
- {
- if (i == index)
- {
- pthread_mutex_unlock(&private_display->lock);
- return private_layer;
- }
- i++;
- }
-
- pthread_mutex_unlock(&private_display->lock);
-
- return NULL;
-}
-
-EXTERN tdm_error
-tdm_output_get_available_properties(tdm_output *output, const tdm_prop **props, int *count)
-{
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
- TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- pthread_mutex_lock(&private_display->lock);
-
- *props = (const tdm_prop*)private_output->caps.props;
- *count = private_output->caps.prop_count;
-
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_get_available_modes(tdm_output *output, const tdm_output_mode **modes, int *count)
-{
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(modes != NULL, TDM_ERROR_INVALID_PARAMETER);
- TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- pthread_mutex_lock(&private_display->lock);
-
- *modes = (const tdm_output_mode*)private_output->caps.modes;
- *count = private_output->caps.mode_count;
-
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_get_available_size(tdm_output *output, int *min_w, int *min_h,
- int *max_w, int *max_h, int *preferred_align)
+tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h,
+ int *max_w, int *max_h, int *preferred_align)
{
- OUTPUT_FUNC_ENTRY();
-
- pthread_mutex_lock(&private_display->lock);
+ tdm_private_module *pp_module;
- if (min_w)
- *min_w = private_output->caps.min_w;
- if (min_h)
- *min_h = private_output->caps.min_h;
- if (max_w)
- *max_w = private_output->caps.max_w;
- if (max_h)
- *max_h = private_output->caps.max_h;
- if (preferred_align)
- *preferred_align = private_output->caps.preferred_align;
+ DISPLAY_FUNC_ENTRY();
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
+ _pthread_mutex_lock(&private_display->lock);
-EXTERN tdm_error
-tdm_output_get_physical_size(tdm_output *output, unsigned int *mmWidth, unsigned int *mmHeight)
-{
- OUTPUT_FUNC_ENTRY();
+ if (!private_display->pp_module) {
+ /* LCOV_EXCL_START */
+ TDM_ERR("no pp capability");
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_NO_CAPABILITY;
+ /* LCOV_EXCL_STOP */
+ }
- pthread_mutex_lock(&private_display->lock);
+ pp_module = private_display->pp_module;
- if (mmWidth)
- *mmWidth = private_output->caps.mmWidth;
- if (mmHeight)
- *mmHeight = private_output->caps.mmHeight;
+ if (min_w)
+ *min_w = TDM_FRONT_VALUE(pp_module->caps_pp.min_w);
+ if (min_h)
+ *min_h = TDM_FRONT_VALUE(pp_module->caps_pp.min_h);
+ if (max_w)
+ *max_w = TDM_FRONT_VALUE(pp_module->caps_pp.max_w);
+ if (max_h)
+ *max_h = TDM_FRONT_VALUE(pp_module->caps_pp.max_h);
+ if (preferred_align)
+ *preferred_align = TDM_FRONT_VALUE(pp_module->caps_pp.preferred_align);
- pthread_mutex_unlock(&private_display->lock);
+ _pthread_mutex_unlock(&private_display->lock);
- return ret;
+ return ret;
}
EXTERN tdm_error
-tdm_output_get_subpixel(tdm_output *output, unsigned int *subpixel)
+tdm_display_get_capture_capabilities(tdm_display *dpy,
+ tdm_capture_capability *capabilities)
{
- OUTPUT_FUNC_ENTRY();
- TDM_RETURN_VAL_IF_FAIL(subpixel != NULL, TDM_ERROR_INVALID_PARAMETER);
+ tdm_private_module *capture_module;
- pthread_mutex_lock(&private_display->lock);
+ DISPLAY_FUNC_ENTRY();
- *subpixel = private_output->caps.subpixel;
+ TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
+ _pthread_mutex_lock(&private_display->lock);
-EXTERN tdm_error
-tdm_output_get_pipe(tdm_output *output, unsigned int *pipe)
-{
- OUTPUT_FUNC_ENTRY();
- TDM_RETURN_VAL_IF_FAIL(pipe != NULL, TDM_ERROR_INVALID_PARAMETER);
+ if (!private_display->capture_module) {
+ /* LCOV_EXCL_START */
+ TDM_ERR("no capture capability");
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_NO_CAPABILITY;
+ /* LCOV_EXCL_STOP */
+ }
- pthread_mutex_lock(&private_display->lock);
+ capture_module = private_display->capture_module;
- *pipe = private_output->pipe;
+ *capabilities = capture_module->caps_capture.capabilities;
- pthread_mutex_unlock(&private_display->lock);
+ _pthread_mutex_unlock(&private_display->lock);
- return ret;
+ return ret;
}
-
EXTERN tdm_error
-tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value)
+tdm_display_get_capture_available_formats(tdm_display *dpy,
+ const tbm_format **formats, int *count)
{
- tdm_func_display *func_display;
- OUTPUT_FUNC_ENTRY();
-
- pthread_mutex_lock(&private_display->lock);
+ tdm_private_module *capture_module;
- func_display = &private_display->func_display;
+ DISPLAY_FUNC_ENTRY();
- if (!func_display->output_set_property)
- {
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
+ TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
+ TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
- ret = func_display->output_set_property(private_output->output_backend, id, value);
+ _pthread_mutex_lock(&private_display->lock);
- pthread_mutex_unlock(&private_display->lock);
+ if (!private_display->capture_module) {
+ /* LCOV_EXCL_START */
+ TDM_ERR("no capture capability");
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_NO_CAPABILITY;
+ /* LCOV_EXCL_STOP */
+ }
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value)
-{
- tdm_func_display *func_display;
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- pthread_mutex_lock(&private_display->lock);
-
- func_display = &private_display->func_display;
-
- if (!func_display->output_get_property)
- {
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
+ capture_module = private_display->capture_module;
- ret = func_display->output_get_property(private_output->output_backend, id, value);
+ *formats = (const tbm_format *)capture_module->caps_capture.formats;
+ *count = capture_module->caps_capture.format_count;
- pthread_mutex_unlock(&private_display->lock);
+ _pthread_mutex_unlock(&private_display->lock);
- return ret;
-}
-
-static void
-_tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence,
- unsigned int tv_sec, unsigned int tv_usec, void *user_data)
-{
- tdm_private_vblank_handler *vblank_handler = user_data;
- tdm_private_display *private_display;
-
- TDM_RETURN_IF_FAIL(vblank_handler);
-
- private_display = vblank_handler->private_output->private_display;
-
- pthread_mutex_unlock(&private_display->lock);
-
- if (vblank_handler->func)
- vblank_handler->func(vblank_handler->private_output, sequence,
- tv_sec, tv_usec, vblank_handler->user_data);
-
- pthread_mutex_lock(&private_display->lock);
-
- LIST_DEL(&vblank_handler->link);
- free(vblank_handler);
-}
-
-static void
-_tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
- unsigned int tv_sec, unsigned int tv_usec, void *user_data)
-{
- tdm_private_commit_handler *commit_handler = user_data;
- tdm_private_display *private_display;
-
- TDM_RETURN_IF_FAIL(commit_handler);
-
- private_display = commit_handler->private_output->private_display;
-
- pthread_mutex_unlock(&private_display->lock);
-
- if (commit_handler->func)
- commit_handler->func(commit_handler->private_output, sequence,
- tv_sec, tv_usec, commit_handler->user_data);
-
- pthread_mutex_lock(&private_display->lock);
-
- LIST_DEL(&commit_handler->link);
- free(commit_handler);
+ return ret;
}
EXTERN tdm_error
-tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
- tdm_output_vblank_handler func, void *user_data)
+tdm_display_get_capture_available_size(tdm_display *dpy, int *min_w, int *min_h,
+ int *max_w, int *max_h, int *preferred_align)
{
- tdm_func_display *func_display;
- tdm_private_vblank_handler *vblank_handler;
- OUTPUT_FUNC_ENTRY();
-
- pthread_mutex_lock(&private_display->lock);
-
- func_display = &private_display->func_display;
-
- if (!func_display->output_wait_vblank)
- {
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
-
- vblank_handler = calloc(1, sizeof(tdm_private_vblank_handler));
- if (!vblank_handler)
- {
- TDM_ERR("failed: alloc memory");
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_OUT_OF_MEMORY;
- }
-
- LIST_ADD(&vblank_handler->link, &private_output->vblank_handler_list);
- vblank_handler->private_output = private_output;
- vblank_handler->func = func;
- vblank_handler->user_data = user_data;
-
- ret = func_display->output_wait_vblank(private_output->output_backend, interval,
- sync, vblank_handler);
- if (ret != TDM_ERROR_NONE)
- {
- pthread_mutex_unlock(&private_display->lock);
- return ret;
- }
-
- if (!private_output->regist_vblank_cb)
- {
- private_output->regist_vblank_cb = 1;
- ret = func_display->output_set_vblank_handler(private_output->output_backend,
- _tdm_output_cb_vblank);
- }
-
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
+ tdm_private_module *capture_module;
-EXTERN tdm_error
-tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func, void *user_data)
-{
- tdm_func_display *func_display;
- tdm_private_commit_handler *commit_handler;
- OUTPUT_FUNC_ENTRY();
-
- pthread_mutex_lock(&private_display->lock);
-
- func_display = &private_display->func_display;
-
- if (!func_display->output_commit)
- {
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
-
- commit_handler = calloc(1, sizeof(tdm_private_commit_handler));
- if (!commit_handler)
- {
- TDM_ERR("failed: alloc memory");
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_OUT_OF_MEMORY;
- }
-
- LIST_ADD(&commit_handler->link, &private_output->commit_handler_list);
- commit_handler->private_output = private_output;
- commit_handler->func = func;
- commit_handler->user_data = user_data;
-
- ret = func_display->output_commit(private_output->output_backend, sync, commit_handler);
- if (ret != TDM_ERROR_NONE)
- {
- pthread_mutex_unlock(&private_display->lock);
- return ret;
- }
-
- if (!private_output->regist_commit_cb)
- {
- private_output->regist_commit_cb = 1;
- ret = func_display->output_set_commit_handler(private_output->output_backend,
- _tdm_output_cb_commit);
- }
-
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
+ DISPLAY_FUNC_ENTRY();
-EXTERN tdm_error
-tdm_output_set_mode(tdm_output *output, tdm_output_mode *mode)
-{
- tdm_func_display *func_display;
- OUTPUT_FUNC_ENTRY();
+ _pthread_mutex_lock(&private_display->lock);
- TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
+ if (!private_display->capture_module) {
+ /* LCOV_EXCL_START */
+ TDM_ERR("no capture capability");
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_NO_CAPABILITY;
+ /* LCOV_EXCL_STOP */
+ }
- pthread_mutex_lock(&private_display->lock);
+ capture_module = private_display->capture_module;
- func_display = &private_display->func_display;
+ if (min_w)
+ *min_w = TDM_FRONT_VALUE(capture_module->caps_capture.min_w);
+ if (min_h)
+ *min_h = TDM_FRONT_VALUE(capture_module->caps_capture.min_h);
+ if (max_w)
+ *max_w = TDM_FRONT_VALUE(capture_module->caps_capture.max_w);
+ if (max_h)
+ *max_h = TDM_FRONT_VALUE(capture_module->caps_capture.max_h);
+ if (preferred_align)
+ *preferred_align = TDM_FRONT_VALUE(capture_module->caps_capture.preferred_align);
- if (!func_display->output_set_mode)
- {
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
+ _pthread_mutex_unlock(&private_display->lock);
- ret = func_display->output_set_mode(private_output->output_backend, mode);
-
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
+ return ret;
}
EXTERN tdm_error
-tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode)
+tdm_display_get_max_layer_count(tdm_display *dpy, int *max_count)
{
- tdm_func_display *func_display;
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- pthread_mutex_lock(&private_display->lock);
-
- func_display = &private_display->func_display;
-
- if (!func_display->output_get_mode)
- {
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
-
- ret = func_display->output_get_mode(private_output->output_backend, mode);
-
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
-{
- tdm_func_display *func_display;
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(dpms_value >= TDM_OUTPUT_DPMS_ON, TDM_ERROR_INVALID_PARAMETER);
- TDM_RETURN_VAL_IF_FAIL(dpms_value < TDM_OUTPUT_DPMS_MAX, TDM_ERROR_INVALID_PARAMETER);
-
- pthread_mutex_lock(&private_display->lock);
+ TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER);
+ TDM_RETURN_VAL_IF_FAIL(max_count != NULL, TDM_ERROR_INVALID_PARAMETER);
- func_display = &private_display->func_display;
+ TDM_DEPRECATED(NULL);
- if (!func_display->output_set_dpms)
- {
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
+ *max_count = -1;
- ret = func_display->output_set_dpms(private_output->output_backend, dpms_value);
-
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
+ return TDM_ERROR_NONE;
}
EXTERN tdm_error
-tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value)
+tdm_display_get_output_count(tdm_display *dpy, int *count)
{
- tdm_func_display *func_display;
- OUTPUT_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(dpms_value != NULL, TDM_ERROR_INVALID_PARAMETER);
+ tdm_private_module *private_module = NULL;
+ tdm_private_output *private_output = NULL;
- pthread_mutex_lock(&private_display->lock);
+ DISPLAY_FUNC_ENTRY();
- func_display = &private_display->func_display;
+ TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
- if (!func_display->output_get_dpms)
- {
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
+ _pthread_mutex_lock(&private_display->lock);
- ret = func_display->output_get_dpms(private_output->output_backend, dpms_value);
+ *count = 0;
+ LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+ LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+ (*count)++;
+ }
+ }
- pthread_mutex_unlock(&private_display->lock);
+ _pthread_mutex_unlock(&private_display->lock);
- return ret;
+ return ret;
}
-EXTERN tdm_capture*
-tdm_output_create_capture(tdm_output *output, tdm_error *error)
-{
- tdm_capture *capture = NULL;
-
- OUTPUT_FUNC_ENTRY_ERROR();
-
- pthread_mutex_lock(&private_display->lock);
-
- capture = (tdm_capture*)tdm_capture_create_output_internal(private_output, error);
- pthread_mutex_unlock(&private_display->lock);
-
- return capture;
-}
-
-EXTERN tdm_error
-tdm_layer_get_capabilities(tdm_layer *layer, tdm_layer_capability *capabilities)
+EXTERN tdm_output *
+tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error)
{
- LAYER_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- pthread_mutex_lock(&private_display->lock);
-
- *capabilities = private_layer->caps.capabilities;
+ tdm_private_module *private_module = NULL;
+ tdm_private_output *private_output = NULL;
- pthread_mutex_unlock(&private_display->lock);
+ DISPLAY_FUNC_ENTRY_ERROR();
- return ret;
-}
-
-EXTERN tdm_error
-tdm_layer_get_available_formats(tdm_layer *layer, const tbm_format **formats, int *count)
-{
- LAYER_FUNC_ENTRY();
+ _pthread_mutex_lock(&private_display->lock);
- TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
- TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
+ if (error)
+ *error = TDM_ERROR_NONE;
- pthread_mutex_lock(&private_display->lock);
+ LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+ LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+ if (private_output->index == index) {
+ _pthread_mutex_unlock(&private_display->lock);
+ return private_output;
+ }
+ }
+ }
- *formats = (const tbm_format*)private_layer->caps.formats;
- *count = private_layer->caps.format_count;
+ _pthread_mutex_unlock(&private_display->lock);
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
+ return NULL;
}
-EXTERN tdm_error
-tdm_layer_get_available_properties(tdm_layer *layer, const tdm_prop **props, int *count)
+EXTERN tdm_output *
+tdm_display_find_output(tdm_display *dpy, const char *name, tdm_error *error)
{
- LAYER_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
- TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- pthread_mutex_lock(&private_display->lock);
+ tdm_private_module *private_module = NULL;
+ tdm_private_output *private_output = NULL;
- *props = (const tdm_prop*)private_layer->caps.props;
- *count = private_layer->caps.prop_count;
+ DISPLAY_FUNC_ENTRY_ERROR();
- pthread_mutex_unlock(&private_display->lock);
+ if (!strncasecmp(name, "primary", 7) || !strncasecmp(name, "default", 7)) {
+ return tdm_display_get_output(dpy, 0, error);
+ }
- return ret;
-}
-
-EXTERN tdm_error
-tdm_layer_get_zpos(tdm_layer *layer, unsigned int *zpos)
-{
- LAYER_FUNC_ENTRY();
+ _pthread_mutex_lock(&private_display->lock);
- TDM_RETURN_VAL_IF_FAIL(zpos != NULL, TDM_ERROR_INVALID_PARAMETER);
+ if (error)
+ *error = TDM_ERROR_NONE;
- pthread_mutex_lock(&private_display->lock);
+ LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+ LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+ if (strncmp(private_output->caps.model, name, TDM_NAME_LEN))
+ continue;
+ _pthread_mutex_unlock(&private_display->lock);
+ return private_output;
+ }
+ }
- *zpos = private_layer->caps.zpos;
+ _pthread_mutex_unlock(&private_display->lock);
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
+ return NULL;
}
EXTERN tdm_error
-tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
-{
- tdm_func_display *func_display;
- LAYER_FUNC_ENTRY();
-
- pthread_mutex_lock(&private_display->lock);
-
- func_display = &private_display->func_display;
-
- if (!func_display->layer_set_property)
- {
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
-
- ret = func_display->layer_set_property(private_layer->layer_backend, id, value);
-
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-EXTERN tdm_error
-tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
+tdm_display_get_fd(tdm_display *dpy, int *fd)
{
- tdm_func_display *func_display;
- LAYER_FUNC_ENTRY();
+ DISPLAY_FUNC_ENTRY();
- TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
+ TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
- pthread_mutex_lock(&private_display->lock);
+ _pthread_mutex_lock(&private_display->lock);
- func_display = &private_display->func_display;
+ if (tdm_thread_is_running())
+ *fd = tdm_thread_get_fd(private_display->private_loop);
+ else
+ *fd = tdm_event_loop_get_fd(private_display);
- if (!func_display->layer_get_property)
- {
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
+ _pthread_mutex_unlock(&private_display->lock);
- ret = func_display->layer_get_property(private_layer->layer_backend, id, value);
-
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
+ return ret;
}
EXTERN tdm_error
-tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
+tdm_display_handle_events(tdm_display *dpy)
{
- tdm_func_display *func_display;
- LAYER_FUNC_ENTRY();
+ struct pollfd fds;
+ int fd = -1;
- TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
+ DISPLAY_FUNC_ENTRY();
- pthread_mutex_lock(&private_display->lock);
+ ret = tdm_display_get_fd(dpy, &fd);
+ TDM_RETURN_VAL_IF_FAIL(fd >= 0, ret);
- func_display = &private_display->func_display;
+ fds.events = POLLIN;
+ fds.fd = fd;
+ fds.revents = 0;
- private_layer->usable = 0;
+ if (tdm_debug_module & TDM_DEBUG_EVENT)
+ TDM_INFO("fd(%d) polling in", fd);
- if (!func_display->layer_set_info)
- {
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
+ while (poll(&fds, 1, -1) < 0) {
+ /* LCOV_EXCL_START */
+ if (errno == EINTR || errno == EAGAIN) /* normal case */
+ continue;
+ else {
+ TDM_ERR("poll failed: %m");
+ return TDM_ERROR_OPERATION_FAILED;
+ }
+ /* LCOV_EXCL_STOP */
+ }
- ret = func_display->layer_set_info(private_layer->layer_backend, info);
+ if (tdm_debug_module & TDM_DEBUG_EVENT)
+ TDM_INFO("fd(%d) polling out", fd);
- pthread_mutex_unlock(&private_display->lock);
+ if (tdm_thread_is_running()) {
+ _pthread_mutex_lock(&private_display->lock);
+ ret = tdm_thread_handle_cb(private_display->private_loop);
+ _pthread_mutex_unlock(&private_display->lock);
+ } else {
+ ret = tdm_event_loop_dispatch(private_display);
+ }
- return ret;
+ return ret;
}
-EXTERN tdm_error
-tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
+EXTERN void
+tdm_display_flush(tdm_display *dpy)
{
- tdm_func_display *func_display;
- LAYER_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- pthread_mutex_lock(&private_display->lock);
-
- func_display = &private_display->func_display;
-
- if (!func_display->layer_get_info)
- {
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
+ tdm_private_display *private_display;
- ret = func_display->layer_get_info(private_layer->layer_backend, info);
+ TDM_RETURN_IF_FAIL(dpy != NULL);
+ private_display = (tdm_private_display*)dpy;
- pthread_mutex_unlock(&private_display->lock);
+ if (tdm_thread_is_running())
+ return;
- return ret;
+ tdm_event_loop_flush(private_display);
}
EXTERN tdm_error
-tdm_layer_set_buffer(tdm_layer *layer, tdm_buffer *buffer)
+tdm_display_get_backend_info(tdm_display *dpy, const char **name,
+ const char **vendor, int *major, int *minor)
{
- tdm_func_display *func_display;
- LAYER_FUNC_ENTRY();
+ tdm_private_module *private_module = NULL;
+ tdm_backend_module *module_data = NULL;
- TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER);
+ DISPLAY_FUNC_ENTRY();
- pthread_mutex_lock(&private_display->lock);
+ TDM_DEPRECATED("Use tdm_module_get_info");
- func_display = &private_display->func_display;
+ _pthread_mutex_lock(&private_display->lock);
- private_layer->usable = 0;
+ /* use first backend */
+ LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+ module_data = private_module->module_data;
+ break;
+ }
- if (!func_display->layer_set_buffer)
- {
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
+ assert(module_data != NULL);
- if (private_layer->current_buffer)
- {
- /* TODO: need to unref after next buffer is showing on screen */
- tdm_buffer_unref_backend(private_layer->current_buffer);
- tdm_buffer_unref(private_layer->current_buffer);
- }
+ if (name)
+ *name = module_data->name;
+ if (vendor)
+ *vendor = module_data->vendor;
+ if (major)
+ *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version);
+ if (minor)
+ *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version);
- private_layer->current_buffer = tdm_buffer_ref(buffer, NULL);
- tdm_buffer_ref_backend(buffer);
+ _pthread_mutex_unlock(&private_display->lock);
- ret = func_display->layer_set_buffer(private_layer->layer_backend,
- tdm_buffer_get_surface(buffer));
-
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
+ return ret;
}
EXTERN tdm_error
-tdm_layer_unset_buffer(tdm_layer *layer)
+tdm_module_get_info(tdm_module *module, const char **name,
+ const char **vendor, int *major, int *minor)
{
- tdm_func_display *func_display;
- LAYER_FUNC_ENTRY();
-
- pthread_mutex_lock(&private_display->lock);
-
- func_display = &private_display->func_display;
+ tdm_backend_module *module_data;
- if (private_layer->current_buffer)
- {
- tdm_buffer_unref(private_layer->current_buffer);
- tdm_buffer_unref_backend(private_layer->current_buffer);
- private_layer->current_buffer = NULL;
- }
+ BACKEND_FUNC_ENTRY();
- private_layer->usable = 1;
+ _pthread_mutex_lock(&private_display->lock);
- if (!func_display->layer_unset_buffer)
- {
- pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NONE;
- }
+ module_data = private_module->module_data;
- ret = func_display->layer_unset_buffer(private_layer->layer_backend);
+ if (name)
+ *name = module_data->name;
+ if (vendor)
+ *vendor = module_data->vendor;
+ if (major)
+ *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version);
+ if (minor)
+ *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version);
- pthread_mutex_unlock(&private_display->lock);
+ _pthread_mutex_unlock(&private_display->lock);
- return ret;
+ return ret;
}
-EXTERN tdm_error
-tdm_layer_is_usable(tdm_layer *layer, unsigned int *usable)
-{
- LAYER_FUNC_ENTRY();
-
- TDM_RETURN_VAL_IF_FAIL(usable != NULL, TDM_ERROR_INVALID_PARAMETER);
-
- pthread_mutex_lock(&private_display->lock);
-
- *usable = private_layer->usable;
-
- pthread_mutex_unlock(&private_display->lock);
-
- return ret;
-}
-
-
-EXTERN tdm_capture*
-tdm_layer_create_capture(tdm_layer *layer, tdm_error *error)
+EXTERN tdm_pp *
+tdm_display_create_pp(tdm_display *dpy, tdm_error *error)
{
- tdm_capture *capture = NULL;
+ tdm_pp *pp;
- LAYER_FUNC_ENTRY_ERROR();
+ DISPLAY_FUNC_ENTRY_ERROR();
- pthread_mutex_lock(&private_display->lock);
+ _pthread_mutex_lock(&private_display->lock);
- capture = (tdm_capture*)tdm_capture_create_layer_internal(private_layer, error);
+ pp = (tdm_pp *)tdm_pp_create_internal(private_display->pp_module, error);
- pthread_mutex_unlock(&private_display->lock);
+ _pthread_mutex_unlock(&private_display->lock);
- return capture;
+ return pp;
}