seperate tdm_func_ouput, tdm_func_layer from tdm_func_diplay

Change-Id: I1fd0ffab9fecbad43308ff54def71f3cb5b8452c

diff --git a/include/tdm_backend.h b/include/tdm_backend.h
index 645d0de..951746c 100644 (file)
--- a/include/tdm_backend.h
+++ b/include/tdm_backend.h
@@ -300,6 +300,21 @@ typedef struct _tdm_func_display
      */
     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
@@ -433,6 +448,21 @@ typedef struct _tdm_func_display
      */
     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
@@ -539,7 +569,16 @@ typedef struct _tdm_func_display
      * 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
@@ -603,6 +642,15 @@ typedef struct _tdm_func_pp
      * 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;
 
 /**
@@ -669,6 +717,15 @@ typedef struct _tdm_func_capture
      * 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;
 
 /*
@@ -724,13 +781,35 @@ typedef struct _tdm_backend_module
  * @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

diff --git a/src/tdm.c b/src/tdm.c
index 794540f..aaecef0 100644 (file)
--- a/src/tdm.c
+++ b/src/tdm.c
@@ -248,7 +248,7 @@ static tdm_error
 _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;
@@ -256,13 +256,13 @@ _tdm_display_update_caps_layer(tdm_private_display *private_display,
     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");
@@ -285,17 +285,17 @@ static tdm_error
 _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");
@@ -332,7 +332,6 @@ _tdm_display_update_layer(tdm_private_display *private_display,
         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;
@@ -358,7 +357,7 @@ static tdm_error
 _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;
@@ -371,7 +370,6 @@ _tdm_display_update_output(tdm_private_display *private_display,
         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;
@@ -388,7 +386,7 @@ _tdm_display_update_output(tdm_private_display *private_display,
     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;
 
@@ -531,6 +529,8 @@ static tdm_error
 _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 */
@@ -538,9 +538,9 @@ _tdm_display_check_backend_functions(tdm_private_display *private_display)
     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);
@@ -564,8 +564,8 @@ _tdm_display_check_backend_functions(tdm_private_display *private_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);

diff --git a/src/tdm_backend.c b/src/tdm_backend.c
index ae8224c..6f98b0f 100644 (file)
--- a/src/tdm_backend.c
+++ b/src/tdm_backend.c
@@ -61,6 +61,34 @@ tdm_backend_register_func_display(tdm_display *dpy, tdm_func_display *func_displ
 }
 
 EXTERN tdm_error
+tdm_backend_register_func_output(tdm_display *dpy, tdm_func_output *func_output)
+{
+    BACKEND_FUNC_ENTRY();
+
+    TDM_RETURN_VAL_IF_FAIL(func_output != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+    pthread_mutex_lock(&private_display->lock);
+    private_display->func_output = *func_output;
+    pthread_mutex_unlock(&private_display->lock);
+
+    return TDM_ERROR_NONE;
+}
+
+EXTERN tdm_error
+tdm_backend_register_func_layer(tdm_display *dpy, tdm_func_layer *func_layer)
+{
+    BACKEND_FUNC_ENTRY();
+
+    TDM_RETURN_VAL_IF_FAIL(func_layer != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+    pthread_mutex_lock(&private_display->lock);
+    private_display->func_layer = *func_layer;
+    pthread_mutex_unlock(&private_display->lock);
+
+    return TDM_ERROR_NONE;
+}
+
+EXTERN tdm_error
 tdm_backend_register_func_pp(tdm_display *dpy, tdm_func_pp *func_pp)
 {
     BACKEND_FUNC_ENTRY();

diff --git a/src/tdm_capture.c b/src/tdm_capture.c
index a1b91f3..75170bd 100644 (file)
--- a/src/tdm_capture.c
+++ b/src/tdm_capture.c
@@ -49,7 +49,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
     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)
@@ -77,17 +77,13 @@ _tdm_caputre_cb_done(tdm_capture *capture_backend, tbm_surface_h buffer, void *u
 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");
@@ -96,7 +92,7 @@ tdm_capture_create_output_internal(tdm_private_output *private_output, tdm_error
         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)
@@ -125,7 +121,6 @@ tdm_capture_create_output_internal(tdm_private_output *private_output, tdm_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;
@@ -141,19 +136,14 @@ tdm_capture_create_output_internal(tdm_private_output *private_output, tdm_error
 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");
@@ -162,7 +152,7 @@ tdm_capture_create_layer_internal(tdm_private_layer *private_layer, tdm_error *e
         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;
 
@@ -178,7 +168,6 @@ tdm_capture_create_layer_internal(tdm_private_layer *private_layer, tdm_error *e
 
     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;
@@ -200,7 +189,7 @@ tdm_capture_destroy_internal(tdm_private_capture *private_capture)
 
     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);

diff --git a/src/tdm_display.c b/src/tdm_display.c
index 72d69ad..e8c6484 100644 (file)
--- a/src/tdm_display.c
+++ b/src/tdm_display.c
@@ -561,20 +561,20 @@ tdm_output_get_pipe(tdm_output *output, unsigned int *pipe)
 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);
 
@@ -584,22 +584,22 @@ tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value)
 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);
 
@@ -683,15 +683,15 @@ EXTERN tdm_error
 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;
@@ -710,7 +710,7 @@ tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
     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)
     {
@@ -721,7 +721,7 @@ tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
     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);
     }
 
@@ -733,13 +733,13 @@ tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
 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;
     }
@@ -756,7 +756,7 @@ _tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func,
     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;
@@ -765,7 +765,7 @@ _tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func,
     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);
     }
 
@@ -789,22 +789,22 @@ tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func,
 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);
 
@@ -814,22 +814,22 @@ tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode)
 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);
 
@@ -839,7 +839,7 @@ tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode)
 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)
@@ -849,15 +849,15 @@ tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
 
     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);
 
@@ -867,22 +867,22 @@ tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
 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);
 
@@ -976,20 +976,20 @@ tdm_layer_get_zpos(tdm_layer *layer, unsigned int *zpos)
 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);
 
@@ -999,22 +999,22 @@ tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
 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);
 
@@ -1024,24 +1024,24 @@ tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
 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);
 
@@ -1051,22 +1051,22 @@ tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
 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);
 
@@ -1076,18 +1076,18 @@ tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
 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;
@@ -1102,7 +1102,7 @@ tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
 
     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);
 
@@ -1112,12 +1112,12 @@ tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
 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)
     {
@@ -1137,13 +1137,13 @@ tdm_layer_unset_buffer(tdm_layer *layer)
 
     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);
 
@@ -1155,14 +1155,14 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
 {
     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;
@@ -1186,7 +1186,7 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
 
     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)
@@ -1221,18 +1221,18 @@ _tbm_layer_queue_destroy_cb(tbm_surface_queue_h surface_queue, void *data)
 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;
@@ -1268,12 +1268,12 @@ tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
 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)
     {
@@ -1298,13 +1298,13 @@ tdm_layer_unset_buffer_queue(tdm_layer *layer)
     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);
 
@@ -1330,12 +1330,12 @@ tdm_layer_is_usable(tdm_layer *layer, unsigned int *usable)
 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))
     {
@@ -1344,13 +1344,13 @@ tdm_layer_set_video_pos(tdm_layer *layer, int zpos)
         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);
 

diff --git a/src/tdm_pp.c b/src/tdm_pp.c
index bf83342..d51ff66 100644 (file)
--- a/src/tdm_pp.c
+++ b/src/tdm_pp.c
@@ -49,7 +49,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
     TDM_RETURN_VAL_IF_FAIL(pp != NULL, TDM_ERROR_INVALID_PARAMETER); \
     private_pp = (tdm_private_pp*)pp; \
     private_display = private_pp->private_display; \
-    func_pp = private_pp->func_pp
+    func_pp = &private_display->func_pp
 
 static void
 _tdm_pp_cb_done(tdm_pp *pp_backend, tbm_surface_h src, tbm_surface_h dst, void *user_data)
@@ -124,7 +124,6 @@ tdm_pp_create_internal(tdm_private_display *private_display, tdm_error *error)
     }
 
     LIST_ADD(&private_pp->link, &private_display->pp_list);
-    private_pp->func_pp = func_pp;
     private_pp->private_display = private_display;
     private_pp->pp_backend = pp_backend;
 
@@ -142,7 +141,7 @@ tdm_pp_destroy_internal(tdm_private_pp *private_pp)
     if (!private_pp)
         return;
 
-    func_pp = private_pp->func_pp;
+    func_pp = &private_pp->private_display->func_pp;
 
     LIST_DEL(&private_pp->link);
 

diff --git a/src/tdm_private.h b/src/tdm_private.h
index 966edec..2425059 100644 (file)
--- a/src/tdm_private.h
+++ b/src/tdm_private.h
@@ -165,6 +165,8 @@ struct _tdm_private_display
     /* backend function */
     tdm_display_capability capabilities;
     tdm_func_display func_display;
+    tdm_func_output func_output;
+    tdm_func_layer func_layer;
     tdm_func_pp func_pp;
     tdm_func_capture func_capture;
 
@@ -184,7 +186,6 @@ struct _tdm_private_output
 {
     struct list_head link;
 
-    tdm_func_display *func_display;
     tdm_private_display *private_display;
 
     tdm_caps_output caps;
@@ -207,7 +208,6 @@ struct _tdm_private_layer
 {
     struct list_head link;
 
-    tdm_func_display *func_display;
     tdm_private_display *private_display;
     tdm_private_output *private_output;
 
@@ -227,7 +227,6 @@ struct _tdm_private_pp
 {
     struct list_head link;
 
-    tdm_func_pp *func_pp;
     tdm_private_display *private_display;
 
     tdm_pp *pp_backend;
@@ -239,7 +238,6 @@ struct _tdm_private_capture
 
     tdm_capture_target target;
 
-    tdm_func_capture *func_capture;
     tdm_private_display *private_display;
     tdm_private_output *private_output;
     tdm_private_layer *private_layer;