*/
tdm_pp* (*display_create_pp)(tdm_backend_data *bdata, tdm_error *error);
+ void (*reserved1)(void);
+ void (*reserved2)(void);
+ void (*reserved3)(void);
+ void (*reserved4)(void);
+ void (*reserved5)(void);
+ void (*reserved6)(void);
+ void (*reserved7)(void);
+ void (*reserved8)(void);
+} tdm_func_display;
+
+/**
+ * @brief The output functions for a backend module.
+ */
+typedef struct _tdm_func_output
+{
/**
* @brief Get the capabilities of a output object
* @param[in] output A output object
*/
tdm_capture *(*output_create_capture)(tdm_output *output, tdm_error *error);
+ void (*reserved1)(void);
+ void (*reserved2)(void);
+ void (*reserved3)(void);
+ void (*reserved4)(void);
+ void (*reserved5)(void);
+ void (*reserved6)(void);
+ void (*reserved7)(void);
+ void (*reserved8)(void);
+} tdm_func_output;
+
+/**
+ * @brief The layer functions for a backend module.
+ */
+typedef struct _tdm_func_layer
+{
/**
* @brief Get the capabilities of a layer object
* @param[in] layer A layer object
* doesn't have the capture device.
*/
tdm_capture *(*layer_create_capture)(tdm_layer *layer, tdm_error *error);
-} tdm_func_display;
+
+ void (*reserved1)(void);
+ void (*reserved2)(void);
+ void (*reserved3)(void);
+ void (*reserved4)(void);
+ void (*reserved5)(void);
+ void (*reserved6)(void);
+ void (*reserved7)(void);
+ void (*reserved8)(void);
+} tdm_func_layer;
/**
* @brief The done handler of a pp object
* A backend module @b SHOULD call #tdm_pp_done_handler when converintg a image is done.
*/
tdm_error (*pp_set_done_handler)(tdm_pp *pp, tdm_pp_done_handler func, void *user_data);
+
+ void (*reserved1)(void);
+ void (*reserved2)(void);
+ void (*reserved3)(void);
+ void (*reserved4)(void);
+ void (*reserved5)(void);
+ void (*reserved6)(void);
+ void (*reserved7)(void);
+ void (*reserved8)(void);
} tdm_func_pp;
/**
* A backend module @b SHOULD call #tdm_capture_done_handler when capture operation is done.
*/
tdm_error (*capture_set_done_handler)(tdm_capture *capture, tdm_capture_done_handler func, void *user_data);
+
+ void (*reserved1)(void);
+ void (*reserved2)(void);
+ void (*reserved3)(void);
+ void (*reserved4)(void);
+ void (*reserved5)(void);
+ void (*reserved6)(void);
+ void (*reserved7)(void);
+ void (*reserved8)(void);
} tdm_func_capture;
/*
* @param[in] dpy A display object
* @param[in] func_display display functions
* @return #TDM_ERROR_NONE if success. Otherwise, error value.
- * @see tdm_backend_register_func_pp, tdm_backend_register_func_capture
+ * @see tdm_backend_register_func_output, tdm_backend_register_func_layer
* @remarks
* A backend module @b SHOULD set the backend display functions at least.
*/
tdm_error tdm_backend_register_func_display(tdm_display *dpy, tdm_func_display *func_display);
/**
+ * @brief Register the backend output functions to a display
+ * @param[in] dpy A display object
+ * @param[in] func_output output functions
+ * @return #TDM_ERROR_NONE if success. Otherwise, error value.
+ * @see tdm_backend_register_func_display, tdm_backend_register_func_layer
+ * @remarks
+ * A backend module @b SHOULD set the backend output functions at least.
+ */
+tdm_error tdm_backend_register_func_output(tdm_display *dpy, tdm_func_output *func_output);
+
+/**
+ * @brief Register the backend layer functions to a display
+ * @param[in] dpy A display object
+ * @param[in] func_layer layer functions
+ * @return #TDM_ERROR_NONE if success. Otherwise, error value.
+ * @see tdm_backend_register_func_display, tdm_backend_register_func_output
+ * @remarks
+ * A backend module @b SHOULD set the backend layer functions at least.
+ */
+tdm_error tdm_backend_register_func_layer(tdm_display *dpy, tdm_func_layer *func_layer);
+
+/**
* @brief Register the backend pp functions to a display
* @param[in] dpy A display object
* @param[in] func_pp pp functions
_tdm_display_update_caps_layer(tdm_private_display *private_display,
tdm_layer *layer_backend, tdm_caps_layer *caps)
{
- tdm_func_display *func_display = &private_display->func_display;
+ tdm_func_layer *func_layer = &private_display->func_layer;
char buf[1024];
int bufsize = sizeof(buf);
char *str_buf = buf;
int i;
tdm_error ret;
- if (!func_display->layer_get_capability)
+ if (!func_layer->layer_get_capability)
{
TDM_ERR("no layer_get_capability()");
return TDM_ERROR_BAD_MODULE;
}
- ret = func_display->layer_get_capability(layer_backend, caps);
+ ret = func_layer->layer_get_capability(layer_backend, caps);
if (ret != TDM_ERROR_NONE)
{
TDM_ERR("layer_get_capability() failed");
_tdm_display_update_caps_output(tdm_private_display *private_display,
tdm_output *output_backend, tdm_caps_output *caps)
{
- tdm_func_display *func_display = &private_display->func_display;
+ tdm_func_output *func_output = &private_display->func_output;
int i;
tdm_error ret;
- if (!func_display->output_get_capability)
+ if (!func_output->output_get_capability)
{
TDM_ERR("no output_get_capability()");
return TDM_ERROR_BAD_MODULE;
}
- ret = func_display->output_get_capability(output_backend, caps);
+ ret = func_output->output_get_capability(output_backend, caps);
if (ret != TDM_ERROR_NONE)
{
TDM_ERR("output_get_capability() failed");
TDM_RETURN_VAL_IF_FAIL(private_layer != NULL, TDM_ERROR_OUT_OF_MEMORY);
LIST_ADD(&private_layer->link, &private_output->layer_list);
- private_layer->func_display = &private_display->func_display;
private_layer->private_display = private_display;
private_layer->private_output = private_output;
private_layer->layer_backend = layer_backend;
_tdm_display_update_output(tdm_private_display *private_display,
tdm_output *output_backend, int pipe)
{
- tdm_func_display *func_display = &private_display->func_display;
+ tdm_func_output *func_output = &private_display->func_output;
tdm_private_output *private_output = NULL;
tdm_layer **layers = NULL;
int layer_count = 0, i;
TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_OUT_OF_MEMORY);
LIST_ADD(&private_output->link, &private_display->output_list);
- private_output->func_display = func_display;
private_output->private_display = private_display;
private_output->output_backend = output_backend;
private_output->pipe = pipe;
if (ret != TDM_ERROR_NONE)
return ret;
- layers = func_display->output_get_layers(output_backend, &layer_count, &ret);
+ layers = func_output->output_get_layers(output_backend, &layer_count, &ret);
if (ret != TDM_ERROR_NONE)
goto failed_update;
_tdm_display_check_backend_functions(tdm_private_display *private_display)
{
tdm_func_display *func_display = &private_display->func_display;
+ tdm_func_output *func_output = &private_display->func_output;
+ tdm_func_layer *func_layer = &private_display->func_layer;
tdm_error ret;
/* below functions should be implemented in backend side */
TDM_RETURN_VAL_IF_FAIL(func_display != NULL, TDM_ERROR_BAD_MODULE);
TDM_RETURN_VAL_IF_FAIL(func_display->display_get_capabilitiy, TDM_ERROR_BAD_MODULE);
TDM_RETURN_VAL_IF_FAIL(func_display->display_get_outputs, TDM_ERROR_BAD_MODULE);
- TDM_RETURN_VAL_IF_FAIL(func_display->output_get_capability, TDM_ERROR_BAD_MODULE);
- TDM_RETURN_VAL_IF_FAIL(func_display->output_get_layers, TDM_ERROR_BAD_MODULE);
- TDM_RETURN_VAL_IF_FAIL(func_display->layer_get_capability, TDM_ERROR_BAD_MODULE);
+ TDM_RETURN_VAL_IF_FAIL(func_output->output_get_capability, TDM_ERROR_BAD_MODULE);
+ TDM_RETURN_VAL_IF_FAIL(func_output->output_get_layers, TDM_ERROR_BAD_MODULE);
+ TDM_RETURN_VAL_IF_FAIL(func_layer->layer_get_capability, TDM_ERROR_BAD_MODULE);
ret = func_display->display_get_capabilitiy(private_display->bdata,
&private_display->caps_display);
{
tdm_func_capture *func_capture = &private_display->func_capture;
TDM_RETURN_VAL_IF_FAIL(func_display->display_get_capture_capability, TDM_ERROR_BAD_MODULE);
- TDM_RETURN_VAL_IF_FAIL(func_display->output_create_capture, TDM_ERROR_BAD_MODULE);
- TDM_RETURN_VAL_IF_FAIL(func_display->layer_create_capture, TDM_ERROR_BAD_MODULE);
+ TDM_RETURN_VAL_IF_FAIL(func_output->output_create_capture, TDM_ERROR_BAD_MODULE);
+ TDM_RETURN_VAL_IF_FAIL(func_layer->layer_create_capture, TDM_ERROR_BAD_MODULE);
TDM_RETURN_VAL_IF_FAIL(func_capture->capture_destroy, TDM_ERROR_BAD_MODULE);
TDM_RETURN_VAL_IF_FAIL(func_capture->capture_commit, TDM_ERROR_BAD_MODULE);
TDM_RETURN_VAL_IF_FAIL(func_capture->capture_set_done_handler, TDM_ERROR_BAD_MODULE);
TDM_RETURN_VAL_IF_FAIL(capture != NULL, TDM_ERROR_INVALID_PARAMETER); \
private_capture = (tdm_private_capture*)capture; \
private_display = private_capture->private_display; \
- func_capture = private_capture->func_capture
+ func_capture = &private_display->func_capture
static void
_tdm_caputre_cb_done(tdm_capture *capture_backend, tbm_surface_h buffer, void *user_data)
INTERN tdm_private_capture*
tdm_capture_create_output_internal(tdm_private_output *private_output, tdm_error *error)
{
- tdm_private_display *private_display;
- tdm_func_display *func_display;
- tdm_func_capture *func_capture;
+ tdm_private_display *private_display = private_output->private_display;
+ tdm_func_output *func_output = &private_display->func_output;
+ tdm_func_capture *func_capture = &private_display->func_capture;
tdm_private_capture *private_capture = NULL;
tdm_capture *capture_backend = NULL;
tdm_error ret = TDM_ERROR_NONE;
- private_display = private_output->private_display;
- func_display = &private_display->func_display;
- func_capture = &private_display->func_capture;
-
if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE))
{
TDM_ERR("no capture capability");
return NULL;
}
- capture_backend = func_display->output_create_capture(private_output->output_backend, &ret);
+ capture_backend = func_output->output_create_capture(private_output->output_backend, &ret);
if (ret != TDM_ERROR_NONE)
{
if (error)
}
LIST_ADD(&private_capture->link, &private_output->capture_list);
- private_capture->func_capture = func_capture;
private_capture->target = TDM_CAPTURE_TARGET_OUTPUT;
private_capture->private_display = private_display;
private_capture->private_output = private_output;
INTERN tdm_private_capture*
tdm_capture_create_layer_internal(tdm_private_layer *private_layer, tdm_error *error)
{
- tdm_private_display *private_display;
- tdm_private_output *private_output;
- tdm_func_display *func_display;
- tdm_func_capture *func_capture;
+ tdm_private_output *private_output = private_layer->private_output;
+ tdm_private_display *private_display = private_output->private_display;
+ tdm_func_layer *func_layer = &private_display->func_layer;
+ tdm_func_capture *func_capture = &private_display->func_capture;
tdm_private_capture *private_capture = NULL;
tdm_capture *capture_backend = NULL;
tdm_error ret = TDM_ERROR_NONE;
- private_output = private_layer->private_output;
- private_display = private_output->private_display;
- func_display = &private_display->func_display;
- func_capture = &private_display->func_capture;
-
if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE))
{
TDM_ERR("no capture capability");
return NULL;
}
- capture_backend = func_display->layer_create_capture(private_layer->layer_backend, &ret);
+ capture_backend = func_layer->layer_create_capture(private_layer->layer_backend, &ret);
if (ret != TDM_ERROR_NONE)
return NULL;
LIST_ADD(&private_capture->link, &private_output->capture_list);
private_capture->target = TDM_CAPTURE_TARGET_LAYER;
- private_capture->func_capture = func_capture;
private_capture->private_display = private_display;
private_capture->private_output = private_output;
private_capture->private_layer = private_layer;
LIST_DEL(&private_capture->link);
- func_capture = private_capture->func_capture;
+ func_capture = &private_capture->private_display->func_capture;
func_capture->capture_destroy(private_capture->capture_backend);
free(private_capture);
EXTERN tdm_error
tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value)
{
- tdm_func_display *func_display;
+ tdm_func_output *func_output;
OUTPUT_FUNC_ENTRY();
pthread_mutex_lock(&private_display->lock);
- func_display = &private_display->func_display;
+ func_output = &private_display->func_output;
- if (!func_display->output_set_property)
+ if (!func_output->output_set_property)
{
pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NONE;
}
- ret = func_display->output_set_property(private_output->output_backend, id, value);
+ ret = func_output->output_set_property(private_output->output_backend, id, value);
pthread_mutex_unlock(&private_display->lock);
EXTERN tdm_error
tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value)
{
- tdm_func_display *func_display;
+ tdm_func_output *func_output;
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;
+ func_output = &private_display->func_output;
- if (!func_display->output_get_property)
+ if (!func_output->output_get_property)
{
pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NONE;
}
- ret = func_display->output_get_property(private_output->output_backend, id, value);
+ ret = func_output->output_get_property(private_output->output_backend, id, value);
pthread_mutex_unlock(&private_display->lock);
tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
tdm_output_vblank_handler func, void *user_data)
{
- tdm_func_display *func_display;
+ tdm_func_output *func_output;
tdm_private_vblank_handler *vblank_handler;
OUTPUT_FUNC_ENTRY();
pthread_mutex_lock(&private_display->lock);
- func_display = &private_display->func_display;
+ func_output = &private_display->func_output;
- if (!func_display->output_wait_vblank)
+ if (!func_output->output_wait_vblank)
{
pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NONE;
vblank_handler->func = func;
vblank_handler->user_data = user_data;
- ret = func_display->output_wait_vblank(private_output->output_backend, interval,
+ ret = func_output->output_wait_vblank(private_output->output_backend, interval,
sync, vblank_handler);
if (ret != TDM_ERROR_NONE)
{
if (!private_output->regist_vblank_cb)
{
private_output->regist_vblank_cb = 1;
- ret = func_display->output_set_vblank_handler(private_output->output_backend,
+ ret = func_output->output_set_vblank_handler(private_output->output_backend,
_tdm_output_cb_vblank);
}
static tdm_error
_tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func, void *user_data)
{
- tdm_func_display *func_display;
+ tdm_func_output *func_output;
tdm_private_commit_handler *commit_handler;
OUTPUT_FUNC_ENTRY();
- func_display = &private_display->func_display;
+ func_output = &private_display->func_output;
- if (!func_display->output_commit)
+ if (!func_output->output_commit)
{
return TDM_ERROR_NONE;
}
commit_handler->func = func;
commit_handler->user_data = user_data;
- ret = func_display->output_commit(private_output->output_backend, sync, commit_handler);
+ ret = func_output->output_commit(private_output->output_backend, sync, commit_handler);
if (ret != TDM_ERROR_NONE)
{
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,
+ ret = func_output->output_set_commit_handler(private_output->output_backend,
_tdm_output_cb_commit);
}
EXTERN tdm_error
tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode)
{
- tdm_func_display *func_display;
+ tdm_func_output *func_output;
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;
+ func_output = &private_display->func_output;
- if (!func_display->output_set_mode)
+ if (!func_output->output_set_mode)
{
pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NONE;
}
- ret = func_display->output_set_mode(private_output->output_backend, mode);
+ ret = func_output->output_set_mode(private_output->output_backend, mode);
pthread_mutex_unlock(&private_display->lock);
EXTERN tdm_error
tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode)
{
- tdm_func_display *func_display;
+ tdm_func_output *func_output;
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;
+ func_output = &private_display->func_output;
- if (!func_display->output_get_mode)
+ if (!func_output->output_get_mode)
{
pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NONE;
}
- ret = func_display->output_get_mode(private_output->output_backend, mode);
+ ret = func_output->output_get_mode(private_output->output_backend, mode);
pthread_mutex_unlock(&private_display->lock);
EXTERN tdm_error
tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
{
- tdm_func_display *func_display;
+ tdm_func_output *func_output;
OUTPUT_FUNC_ENTRY();
if (dpms_value < TDM_OUTPUT_DPMS_ON)
pthread_mutex_lock(&private_display->lock);
- func_display = &private_display->func_display;
+ func_output = &private_display->func_output;
- if (!func_display->output_set_dpms)
+ if (!func_output->output_set_dpms)
{
pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NONE;
}
- ret = func_display->output_set_dpms(private_output->output_backend, dpms_value);
+ ret = func_output->output_set_dpms(private_output->output_backend, dpms_value);
pthread_mutex_unlock(&private_display->lock);
EXTERN tdm_error
tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value)
{
- tdm_func_display *func_display;
+ tdm_func_output *func_output;
OUTPUT_FUNC_ENTRY();
TDM_RETURN_VAL_IF_FAIL(dpms_value != NULL, TDM_ERROR_INVALID_PARAMETER);
pthread_mutex_lock(&private_display->lock);
- func_display = &private_display->func_display;
+ func_output = &private_display->func_output;
- if (!func_display->output_get_dpms)
+ if (!func_output->output_get_dpms)
{
pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NONE;
}
- ret = func_display->output_get_dpms(private_output->output_backend, dpms_value);
+ ret = func_output->output_get_dpms(private_output->output_backend, dpms_value);
pthread_mutex_unlock(&private_display->lock);
EXTERN tdm_error
tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
{
- tdm_func_display *func_display;
+ tdm_func_layer *func_layer;
LAYER_FUNC_ENTRY();
pthread_mutex_lock(&private_display->lock);
- func_display = &private_display->func_display;
+ func_layer = &private_display->func_layer;
- if (!func_display->layer_set_property)
+ if (!func_layer->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);
+ ret = func_layer->layer_set_property(private_layer->layer_backend, id, value);
pthread_mutex_unlock(&private_display->lock);
EXTERN tdm_error
tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
{
- tdm_func_display *func_display;
+ tdm_func_layer *func_layer;
LAYER_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;
+ func_layer = &private_display->func_layer;
- if (!func_display->layer_get_property)
+ if (!func_layer->layer_get_property)
{
pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NONE;
}
- ret = func_display->layer_get_property(private_layer->layer_backend, id, value);
+ ret = func_layer->layer_get_property(private_layer->layer_backend, id, value);
pthread_mutex_unlock(&private_display->lock);
EXTERN tdm_error
tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
{
- tdm_func_display *func_display;
+ tdm_func_layer *func_layer;
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;
+ func_layer = &private_display->func_layer;
private_layer->usable = 0;
- if (!func_display->layer_set_info)
+ if (!func_layer->layer_set_info)
{
pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NONE;
}
- ret = func_display->layer_set_info(private_layer->layer_backend, info);
+ ret = func_layer->layer_set_info(private_layer->layer_backend, info);
pthread_mutex_unlock(&private_display->lock);
EXTERN tdm_error
tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
{
- tdm_func_display *func_display;
+ tdm_func_layer *func_layer;
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;
+ func_layer = &private_display->func_layer;
- if (!func_display->layer_get_info)
+ if (!func_layer->layer_get_info)
{
pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NONE;
}
- ret = func_display->layer_get_info(private_layer->layer_backend, info);
+ ret = func_layer->layer_get_info(private_layer->layer_backend, info);
pthread_mutex_unlock(&private_display->lock);
EXTERN tdm_error
tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
{
- tdm_func_display *func_display;
+ tdm_func_layer *func_layer;
LAYER_FUNC_ENTRY();
TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER);
pthread_mutex_lock(&private_display->lock);
- func_display = &private_display->func_display;
+ func_layer = &private_display->func_layer;
private_layer->usable = 0;
- if (!func_display->layer_set_buffer)
+ if (!func_layer->layer_set_buffer)
{
pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NONE;
private_layer->waiting_buffer = tdm_buffer_ref_backend(buffer);
- ret = func_display->layer_set_buffer(private_layer->layer_backend, buffer);
+ ret = func_layer->layer_set_buffer(private_layer->layer_backend, buffer);
pthread_mutex_unlock(&private_display->lock);
EXTERN tdm_error
tdm_layer_unset_buffer(tdm_layer *layer)
{
- tdm_func_display *func_display;
+ tdm_func_layer *func_layer;
LAYER_FUNC_ENTRY();
pthread_mutex_lock(&private_display->lock);
- func_display = &private_display->func_display;
+ func_layer = &private_display->func_layer;
if (private_layer->waiting_buffer)
{
private_layer->usable = 1;
- if (!func_display->layer_unset_buffer)
+ if (!func_layer->layer_unset_buffer)
{
pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NONE;
}
- ret = func_display->layer_unset_buffer(private_layer->layer_backend);
+ ret = func_layer->layer_unset_buffer(private_layer->layer_backend);
pthread_mutex_unlock(&private_display->lock);
{
TDM_RETURN_IF_FAIL(data != NULL);
tdm_layer *layer = data;
- tdm_func_display *func_display;
+ tdm_func_layer *func_layer;
tbm_surface_h surface = NULL;
LAYER_FUNC_ENTRY_VOID_RETURN();
pthread_mutex_lock(&private_display->lock);
- func_display = &private_display->func_display;
- if (!func_display->layer_set_buffer)
+ func_layer = &private_display->func_layer;
+ if (!func_layer->layer_set_buffer)
{
pthread_mutex_unlock(&private_display->lock);
return;
private_layer->waiting_buffer = tdm_buffer_ref_backend(surface);
- func_display->layer_set_buffer(private_layer->layer_backend, surface);
+ func_layer->layer_set_buffer(private_layer->layer_backend, surface);
ret = _tdm_output_commit(private_layer->private_output, 0, NULL, NULL);
if (ret != TDM_ERROR_NONE)
EXTERN tdm_error
tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
{
- tdm_func_display *func_display;
+ tdm_func_layer *func_layer;
LAYER_FUNC_ENTRY();
TDM_RETURN_VAL_IF_FAIL(buffer_queue != NULL, TDM_ERROR_INVALID_PARAMETER);
pthread_mutex_lock(&private_display->lock);
- func_display = &private_display->func_display;
+ func_layer = &private_display->func_layer;
private_layer->usable = 0;
- if (!func_display->layer_set_buffer)
+ if (!func_layer->layer_set_buffer)
{
pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NONE;
EXTERN tdm_error
tdm_layer_unset_buffer_queue(tdm_layer *layer)
{
- tdm_func_display *func_display;
+ tdm_func_layer *func_layer;
LAYER_FUNC_ENTRY();
pthread_mutex_lock(&private_display->lock);
- func_display = &private_display->func_display;
+ func_layer = &private_display->func_layer;
if (private_layer->waiting_buffer)
{
private_layer->buffer_queue = NULL;
private_layer->usable = 1;
- if (!func_display->layer_unset_buffer)
+ if (!func_layer->layer_unset_buffer)
{
pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NONE;
}
- ret = func_display->layer_unset_buffer(private_layer->layer_backend);
+ ret = func_layer->layer_unset_buffer(private_layer->layer_backend);
pthread_mutex_unlock(&private_display->lock);
EXTERN tdm_error
tdm_layer_set_video_pos(tdm_layer *layer, int zpos)
{
- tdm_func_display *func_display;
+ tdm_func_layer *func_layer;
LAYER_FUNC_ENTRY();
pthread_mutex_lock(&private_display->lock);
- func_display = &private_display->func_display;
+ func_layer = &private_display->func_layer;
if (!(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO))
{
return TDM_ERROR_INVALID_PARAMETER;
}
- if (!func_display->layer_set_video_pos)
+ if (!func_layer->layer_set_video_pos)
{
pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NONE;
}
- ret = func_display->layer_set_video_pos(private_layer->layer_backend, zpos);
+ ret = func_layer->layer_set_video_pos(private_layer->layer_backend, zpos);
pthread_mutex_unlock(&private_display->lock);