change buffer type from tdm_buffer to tbm_surface

[platform/core/uifw/libtdm.git] / src / tdm_display.c

diff --git a/src/tdm_display.c b/src/tdm_display.c
index d0bcde2..862c3d4 100644 (file)
--- a/src/tdm_display.c
+++ b/src/tdm_display.c
@@ -108,7 +108,7 @@ tdm_display_get_capabilities(tdm_display *dpy, tdm_display_capability *capabilit
 }
 
 EXTERN tdm_error
-tdm_display_get_pp_capabilities(tdm_display *dpy, unsigned int *capabilities)
+tdm_display_get_pp_capabilities(tdm_display *dpy, tdm_pp_capability *capabilities)
 {
     DISPLAY_FUNC_ENTRY();
 
@@ -142,7 +142,8 @@ tdm_display_get_pp_available_formats(tdm_display *dpy, const tbm_format **format
 }
 
 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)
+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();
 
@@ -165,25 +166,7 @@ tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h, int
 }
 
 EXTERN tdm_error
-tdm_display_get_pp_available_properties(tdm_display *dpy, const tdm_prop **props, int *count)
-{
-    DISPLAY_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_display->caps_pp.props;
-    *count = private_display->caps_pp.format_count;
-
-    pthread_mutex_unlock(&private_display->lock);
-
-    return ret;
-}
-
-EXTERN tdm_error
-tdm_display_get_capture_capabilities(tdm_display *dpy, unsigned int *capabilities)
+tdm_display_get_capture_capabilities(tdm_display *dpy, tdm_capture_capability *capabilities)
 {
     DISPLAY_FUNC_ENTRY();
 
@@ -243,7 +226,7 @@ tdm_display_get_output_count(tdm_display *dpy, int *count)
 }
 
 
-EXTERN const tdm_output*
+EXTERN tdm_output*
 tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error)
 {
     tdm_private_output *private_output = NULL;
@@ -262,7 +245,7 @@ tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error)
         if (i == index)
         {
             pthread_mutex_unlock(&private_display->lock);
-            return (const tdm_output*)private_output;
+            return private_output;
         }
         i++;
     }
@@ -394,7 +377,7 @@ tdm_output_get_layer_count(tdm_output *output, int *count)
 }
 
 
-EXTERN const tdm_layer*
+EXTERN tdm_layer*
 tdm_output_get_layer(tdm_output *output, int index, tdm_error *error)
 {
     tdm_private_layer *private_layer = NULL;
@@ -459,7 +442,8 @@ tdm_output_get_available_modes(tdm_output *output, const tdm_output_mode **modes
 }
 
 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_output_get_available_size(tdm_output *output, int *min_w, int *min_h,
+                              int *max_w, int *max_h, int *preferred_align)
 {
     OUTPUT_FUNC_ENTRY();
 
@@ -502,11 +486,11 @@ EXTERN tdm_error
 tdm_output_get_subpixel(tdm_output *output, unsigned int *subpixel)
 {
     OUTPUT_FUNC_ENTRY();
+    TDM_RETURN_VAL_IF_FAIL(subpixel != NULL, TDM_ERROR_INVALID_PARAMETER);
 
     pthread_mutex_lock(&private_display->lock);
 
-    if (subpixel)
-        *subpixel = private_output->caps.subpixel;
+    *subpixel = private_output->caps.subpixel;
 
     pthread_mutex_unlock(&private_display->lock);
 
@@ -514,6 +498,22 @@ tdm_output_get_subpixel(tdm_output *output, unsigned int *subpixel)
 }
 
 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);
+
+    pthread_mutex_lock(&private_display->lock);
+
+    *pipe = private_output->pipe;
+
+    pthread_mutex_unlock(&private_display->lock);
+
+    return ret;
+}
+
+
+EXTERN tdm_error
 tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value)
 {
     tdm_func_display *func_display;
@@ -529,7 +529,7 @@ tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value)
         return TDM_ERROR_NONE;
     }
 
-    ret = func_display->output_set_property(private_output->output, id, value);
+    ret = func_display->output_set_property(private_output->output_backend, id, value);
 
     pthread_mutex_unlock(&private_display->lock);
 
@@ -554,7 +554,7 @@ tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value)
         return TDM_ERROR_NONE;
     }
 
-    ret = func_display->output_get_property(private_output->output, id, value);
+    ret = func_display->output_get_property(private_output->output_backend, id, value);
 
     pthread_mutex_unlock(&private_display->lock);
 
@@ -562,41 +562,73 @@ tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value)
 }
 
 static void
-_tdm_output_cb_vblank(tdm_output *output, unsigned int sequence,
+_tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence,
                       unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 {
-    tdm_private_output *private_output = output;
     tdm_private_vblank_handler *vblank_handler = user_data;
+    tdm_private_display *private_display;
 
-    TDM_RETURN_IF_FAIL(private_output);
     TDM_RETURN_IF_FAIL(vblank_handler);
 
+    private_display = vblank_handler->private_output->private_display;
+
     if (vblank_handler->func)
-        vblank_handler->func(private_output, sequence, tv_sec, tv_usec, vblank_handler->user_data);
+    {
+        pthread_mutex_unlock(&private_display->lock);
+        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, unsigned int sequence,
+_tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
                       unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 {
-    tdm_private_output *private_output = output;
     tdm_private_commit_handler *commit_handler = user_data;
+    tdm_private_display *private_display;
+    tdm_private_output *private_output;
+    tdm_private_layer *private_layer;
 
-    TDM_RETURN_IF_FAIL(private_output);
     TDM_RETURN_IF_FAIL(commit_handler);
 
+    private_output = commit_handler->private_output;
+    private_display = private_output->private_display;
+
     if (commit_handler->func)
-        commit_handler->func(private_output, sequence, tv_sec, tv_usec, commit_handler->user_data);
+    {
+        pthread_mutex_unlock(&private_display->lock);
+        commit_handler->func(private_output, sequence,
+                             tv_sec, tv_usec, commit_handler->user_data);
+        pthread_mutex_lock(&private_display->lock);
+    }
+
+    LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link)
+    {
+        if (!private_layer->waiting_buffer)
+            continue;
+
+        if (private_layer->showing_buffer)
+        {
+            pthread_mutex_unlock(&private_display->lock);
+            tdm_buffer_unref_backend(private_layer->showing_buffer);
+            pthread_mutex_lock(&private_display->lock);
+        }
+
+        private_layer->showing_buffer = private_layer->waiting_buffer;
+        private_layer->waiting_buffer = NULL;
+    }
 
     LIST_DEL(&commit_handler->link);
     free(commit_handler);
 }
 
 EXTERN tdm_error
-tdm_output_wait_vblank(tdm_output *output, int interval, int sync, tdm_output_vblank_handler func, void *user_data)
+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_private_vblank_handler *vblank_handler;
@@ -621,10 +653,12 @@ tdm_output_wait_vblank(tdm_output *output, int interval, int sync, tdm_output_vb
     }
 
     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, interval, sync, vblank_handler);
+    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);
@@ -634,7 +668,8 @@ tdm_output_wait_vblank(tdm_output *output, int interval, int sync, tdm_output_vb
     if (!private_output->regist_vblank_cb)
     {
         private_output->regist_vblank_cb = 1;
-        ret = func_display->output_set_vblank_handler(private_output->output, _tdm_output_cb_vblank);
+        ret = func_display->output_set_vblank_handler(private_output->output_backend,
+                                                      _tdm_output_cb_vblank);
     }
 
     pthread_mutex_unlock(&private_display->lock);
@@ -668,10 +703,11 @@ tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func,
     }
 
     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, sync, commit_handler);
+    ret = func_display->output_commit(private_output->output_backend, sync, commit_handler);
     if (ret != TDM_ERROR_NONE)
     {
         pthread_mutex_unlock(&private_display->lock);
@@ -681,7 +717,8 @@ 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, _tdm_output_cb_commit);
+        ret = func_display->output_set_commit_handler(private_output->output_backend,
+                                                      _tdm_output_cb_commit);
     }
 
     pthread_mutex_unlock(&private_display->lock);
@@ -690,7 +727,7 @@ tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func,
 }
 
 EXTERN tdm_error
-tdm_output_set_mode(tdm_output *output, tdm_output_mode *mode)
+tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode)
 {
     tdm_func_display *func_display;
     OUTPUT_FUNC_ENTRY();
@@ -707,7 +744,7 @@ tdm_output_set_mode(tdm_output *output, tdm_output_mode *mode)
         return TDM_ERROR_NONE;
     }
 
-    ret = func_display->output_set_mode(private_output->output, mode);
+    ret = func_display->output_set_mode(private_output->output_backend, mode);
 
     pthread_mutex_unlock(&private_display->lock);
 
@@ -732,7 +769,7 @@ tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode)
         return TDM_ERROR_NONE;
     }
 
-    ret = func_display->output_get_mode(private_output->output, mode);
+    ret = func_display->output_get_mode(private_output->output_backend, mode);
 
     pthread_mutex_unlock(&private_display->lock);
 
@@ -758,7 +795,7 @@ tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
         return TDM_ERROR_NONE;
     }
 
-    ret = func_display->output_set_dpms(private_output->output, dpms_value);
+    ret = func_display->output_set_dpms(private_output->output_backend, dpms_value);
 
     pthread_mutex_unlock(&private_display->lock);
 
@@ -783,7 +820,7 @@ tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value)
         return TDM_ERROR_NONE;
     }
 
-    ret = func_display->output_get_dpms(private_output->output, dpms_value);
+    ret = func_display->output_get_dpms(private_output->output_backend, dpms_value);
 
     pthread_mutex_unlock(&private_display->lock);
 
@@ -807,7 +844,7 @@ tdm_output_create_capture(tdm_output *output, tdm_error *error)
 }
 
 EXTERN tdm_error
-tdm_layer_get_capabilities(tdm_layer *layer, unsigned int *capabilities)
+tdm_layer_get_capabilities(tdm_layer *layer, tdm_layer_capability *capabilities)
 {
     LAYER_FUNC_ENTRY();
 
@@ -850,8 +887,8 @@ tdm_layer_get_available_properties(tdm_layer *layer, const tdm_prop **props, int
 
     pthread_mutex_lock(&private_display->lock);
 
-    *props = (const tdm_prop*)private_output->caps.props;
-    *count = private_output->caps.prop_count;
+    *props = (const tdm_prop*)private_layer->caps.props;
+    *count = private_layer->caps.prop_count;
 
     pthread_mutex_unlock(&private_display->lock);
 
@@ -890,7 +927,7 @@ tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
         return TDM_ERROR_NONE;
     }
 
-    ret = func_display->layer_set_property(private_layer->layer, id, value);
+    ret = func_display->layer_set_property(private_layer->layer_backend, id, value);
 
     pthread_mutex_unlock(&private_display->lock);
 
@@ -915,7 +952,7 @@ tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
         return TDM_ERROR_NONE;
     }
 
-    ret = func_display->layer_get_property(private_layer->layer, id, value);
+    ret = func_display->layer_get_property(private_layer->layer_backend, id, value);
 
     pthread_mutex_unlock(&private_display->lock);
 
@@ -934,13 +971,15 @@ tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
 
     func_display = &private_display->func_display;
 
+    private_layer->usable = 0;
+
     if (!func_display->layer_set_info)
     {
         pthread_mutex_unlock(&private_display->lock);
         return TDM_ERROR_NONE;
     }
 
-    ret = func_display->layer_set_info(private_layer->layer, info);
+    ret = func_display->layer_set_info(private_layer->layer_backend, info);
 
     pthread_mutex_unlock(&private_display->lock);
 
@@ -965,7 +1004,7 @@ tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
         return TDM_ERROR_NONE;
     }
 
-    ret = func_display->layer_get_info(private_layer->layer, info);
+    ret = func_display->layer_get_info(private_layer->layer_backend, info);
 
     pthread_mutex_unlock(&private_display->lock);
 
@@ -973,7 +1012,7 @@ tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
 }
 
 EXTERN tdm_error
-tdm_layer_set_buffer(tdm_layer *layer, tdm_buffer *buffer)
+tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
 {
     tdm_func_display *func_display;
     LAYER_FUNC_ENTRY();
@@ -984,17 +1023,24 @@ tdm_layer_set_buffer(tdm_layer *layer, tdm_buffer *buffer)
 
     func_display = &private_display->func_display;
 
+    private_layer->usable = 0;
+
     if (!func_display->layer_set_buffer)
     {
         pthread_mutex_unlock(&private_display->lock);
         return TDM_ERROR_NONE;
     }
 
-    //TODO
-    tdm_buffer_ref_backend(buffer);
-    ret = func_display->layer_set_buffer(private_layer->layer,
-                                         tdm_buffer_get_surface(buffer));
-    tdm_buffer_unref_backend(buffer);
+    if (private_layer->waiting_buffer)
+    {
+        pthread_mutex_unlock(&private_display->lock);
+        tdm_buffer_unref_backend(private_layer->waiting_buffer);
+        pthread_mutex_lock(&private_display->lock);
+    }
+
+    private_layer->waiting_buffer = tdm_buffer_ref_backend(buffer);
+
+    ret = func_display->layer_set_buffer(private_layer->layer_backend, buffer);
 
     pthread_mutex_unlock(&private_display->lock);
 
@@ -1011,13 +1057,77 @@ tdm_layer_unset_buffer(tdm_layer *layer)
 
     func_display = &private_display->func_display;
 
+    if (private_layer->waiting_buffer)
+    {
+        pthread_mutex_unlock(&private_display->lock);
+        tdm_buffer_unref_backend(private_layer->waiting_buffer);
+        pthread_mutex_lock(&private_display->lock);
+        private_layer->waiting_buffer = NULL;
+    }
+
+    if (private_layer->showing_buffer)
+    {
+        pthread_mutex_unlock(&private_display->lock);
+        tdm_buffer_unref_backend(private_layer->showing_buffer);
+        pthread_mutex_lock(&private_display->lock);
+        private_layer->showing_buffer = NULL;
+    }
+
+    private_layer->usable = 1;
+
     if (!func_display->layer_unset_buffer)
     {
         pthread_mutex_unlock(&private_display->lock);
         return TDM_ERROR_NONE;
     }
 
-    ret = func_display->layer_unset_buffer(private_layer->layer);
+    ret = func_display->layer_unset_buffer(private_layer->layer_backend);
+
+    pthread_mutex_unlock(&private_display->lock);
+
+    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_error
+tdm_layer_set_video_pos(tdm_layer *layer, int zpos)
+{
+    tdm_func_display *func_display;
+    LAYER_FUNC_ENTRY();
+
+    pthread_mutex_lock(&private_display->lock);
+
+    func_display = &private_display->func_display;
+
+    if (!(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO))
+    {
+        TDM_ERR("layer is not video layer");
+        pthread_mutex_unlock(&private_display->lock);
+        return TDM_ERROR_INVALID_PARAMETER;
+    }
+
+    if (!func_display->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);
 
     pthread_mutex_unlock(&private_display->lock);