Move tpl_surface's query_supported_buffer_count feature to tpl_display.

Change-Id: I2bab1fbd738a7c5c016dc3e1c79d4ec3fe438524

diff --git a/src/tpl.h b/src/tpl.h
index 38b5856..5b6f63b 100644 (file)
--- a/src/tpl.h
+++ b/src/tpl.h
@@ -590,17 +590,6 @@ tpl_surface_get_swapchain_buffers(tpl_surface_t *surface,
                                  tbm_surface_h **buffers, int *buffer_count);
 
 /**
- * Get the buffer count capability of the given TPL surface.
- *
- * @paran surface surface to get the buffer count capability
- * @paran min pointer to receive min buffer count value.
- * @paran max pointer to receive max buffer count value.
- */
-tpl_result_t
-tpl_surface_query_supported_buffer_count(tpl_surface_t *surface, int *min,
-               int *max);
-
-/**
  * Query information on the given native window.
  *
  * @param display display used for query.
@@ -629,6 +618,21 @@ tpl_result_t
 tpl_display_get_native_pixmap_info(tpl_display_t *display, tpl_handle_t pixmap,
                                   int *width, int *height, tbm_format *format);
 
+
+/**
+ * Get the buffer count capability of the given native window.
+ *
+ * @param display display used for query.
+ * @param window window used for query the buffer count capability
+ * @paran min pointer to receive min buffer count value.
+ * @paran max pointer to receive max buffer count value.
+ * @return TPL_ERROR_NONE if this function is supported and the window is valid, TPL_ERROR otherwise.
+ */
+tpl_result_t
+tpl_display_query_supported_buffer_count_from_native_window(tpl_display_t *display,
+                                                      tpl_handle_t window,
+                                                      int *min, int *max);
+
 /**
  * Get native buffer from the given native pixmap.
  *

diff --git a/src/tpl_display.c b/src/tpl_display.c
index d61bc0f..8d6c79b 100644 (file)
--- a/src/tpl_display.c
+++ b/src/tpl_display.c
@@ -159,6 +159,21 @@ tpl_display_get_native_pixmap_info(tpl_display_t *display, tpl_handle_t pixmap,
        return display->backend.get_pixmap_info(display, pixmap, width, height, format);
 }
 
+tpl_result_t
+tpl_display_query_supported_buffer_count_from_native_window(tpl_display_t *display,
+                                                      tpl_handle_t window,
+                                                      int *min, int *max)
+{
+       if (!display->backend.query_window_supported_buffer_count) {
+               TPL_ERR("Backend for display has not been initialized!");
+               return TPL_ERROR_INVALID_OPERATION;
+       }
+
+       return display->backend.query_window_supported_buffer_count(display,
+                                                                   window, min,
+                                                                   max);
+}
+
 tbm_surface_h
 tpl_display_get_buffer_from_native_pixmap(tpl_display_t *display,
                tpl_handle_t pixmap)

diff --git a/src/tpl_gbm.c b/src/tpl_gbm.c
index 18b134e..bb28718 100644 (file)
--- a/src/tpl_gbm.c
+++ b/src/tpl_gbm.c
@@ -270,11 +270,6 @@ __tpl_gbm_surface_init(tpl_surface_t *surface)
                        goto error;
                }
 
-               surface->capabilities.min_buffer =
-                       tbm_surface_queue_get_size(tpl_gbm_surface->tbm_queue);
-               surface->capabilities.max_buffer =
-                       tbm_surface_queue_get_size(tpl_gbm_surface->tbm_queue);
-
                TPL_LOG(3, "window(%p, %p) %dx%d", surface, surface->native_handle,
                        surface->width, surface->height);
                return TPL_ERROR_NONE;
@@ -285,7 +280,6 @@ __tpl_gbm_surface_init(tpl_surface_t *surface)
                        TPL_ERR("Failed to get native pixmap info.");
                        goto error;
                }
-               surface->capabilities.min_buffer = surface->capabilities.max_buffer = 1;
 
                return TPL_ERROR_NONE;
        }

diff --git a/src/tpl_internal.h b/src/tpl_internal.h
index 0e1c601..53703b3 100644 (file)
--- a/src/tpl_internal.h
+++ b/src/tpl_internal.h
@@ -47,6 +47,9 @@ struct _tpl_display_backend {
                                        tpl_handle_t pixmap, int *width,
                                        int *height, tbm_format *format);
        tbm_surface_h (*get_buffer_from_native_pixmap)(tpl_handle_t pixmap);
+       tpl_result_t (*query_window_supported_buffer_count)(tpl_display_t *display,
+                                                           tpl_handle_t window,
+                                                           int *min, int *max);
 };
 
 struct _tpl_surface_backend {
@@ -97,10 +100,6 @@ struct _tpl_surface {
        int width, height;
        int post_interval;
        int dump_count;
-       struct {
-               int min_buffer;
-               int max_buffer;
-       } capabilities;
        tpl_surface_backend_t backend;
 };
 

diff --git a/src/tpl_surface.c b/src/tpl_surface.c
index 336805b..35d263c 100644 (file)
--- a/src/tpl_surface.c
+++ b/src/tpl_surface.c
@@ -264,22 +264,6 @@ tpl_surface_enqueue_buffer_with_damage(tpl_surface_t *surface,
 }
 
 tpl_result_t
-tpl_surface_query_supported_buffer_count(tpl_surface_t *surface, int *min,
-               int *max)
-{
-       if (!surface || (surface->type != TPL_SURFACE_TYPE_WINDOW)) {
-               TPL_ERR("Invalid surface!");
-               return TPL_ERROR_INVALID_PARAMETER;
-       }
-
-       if (min) *min = surface->capabilities.min_buffer;
-       if (max) *max = surface->capabilities.max_buffer;
-
-       return TPL_ERROR_NONE;
-
-}
-
-tpl_result_t
 tpl_surface_get_swapchain_buffers(tpl_surface_t *surface,
                                  tbm_surface_h **buffers, int *buffer_count)
 {
@@ -325,12 +309,6 @@ tpl_surface_create_swapchain(tpl_surface_t *surface, tbm_format format,
                return TPL_ERROR_INVALID_PARAMETER;
        }
 
-       if ((buffer_count < surface->capabilities.min_buffer)
-           || (buffer_count > surface->capabilities.max_buffer)) {
-               TPL_ERR("Invalid buffer_count!");
-               return TPL_ERROR_INVALID_PARAMETER;
-       }
-
        if (!surface->backend.create_swapchain) {
                TPL_ERR("Backend does not support!");
                return TPL_ERROR_INVALID_OPERATION;

diff --git a/src/tpl_tbm.c b/src/tpl_tbm.c
index 552dead..9675559 100644 (file)
--- a/src/tpl_tbm.c
+++ b/src/tpl_tbm.c
@@ -183,11 +183,6 @@ __tpl_tbm_surface_init(tpl_surface_t *surface)
                        goto error;
                }
 
-               surface->capabilities.min_buffer =
-                       tbm_surface_queue_get_size((tbm_surface_queue_h)surface->native_handle);
-               surface->capabilities.max_buffer =
-                       tbm_surface_queue_get_size((tbm_surface_queue_h)surface->native_handle);
-
                tbm_surface_queue_add_destroy_cb((tbm_surface_queue_h)surface->native_handle,
                                                 __tpl_tbm_surface_queue_notify_cb,
                                                 surface);
@@ -205,7 +200,6 @@ __tpl_tbm_surface_init(tpl_surface_t *surface)
 
                        goto error;
                }
-               surface->capabilities.min_buffer = surface->capabilities.max_buffer = 1;
 
                tbm_surface_internal_ref((tbm_surface_h)surface->native_handle);
 

diff --git a/src/tpl_wayland_egl.c b/src/tpl_wayland_egl.c
index ff07210..4bc938d 100644 (file)
--- a/src/tpl_wayland_egl.c
+++ b/src/tpl_wayland_egl.c
@@ -389,10 +389,6 @@ __tpl_wayland_egl_surface_init(tpl_surface_t *surface)
 
        surface->width = wl_egl_window->width;
        surface->height = wl_egl_window->height;
-       surface->capabilities.min_buffer =
-               tbm_surface_queue_get_size(wayland_egl_surface->tbm_queue);
-       surface->capabilities.max_buffer =
-               tbm_surface_queue_get_size(wayland_egl_surface->tbm_queue);
 
        wl_egl_window->private = surface;
        wl_egl_window->resize_callback = (void *)__cb_client_window_resize_callback;

diff --git a/src/tpl_wayland_vk_wsi.c b/src/tpl_wayland_vk_wsi.c
index 7334d46..6ecdc7c 100644 (file)
--- a/src/tpl_wayland_vk_wsi.c
+++ b/src/tpl_wayland_vk_wsi.c
@@ -17,6 +17,10 @@ typedef struct _tpl_wayland_vk_wsi_buffer tpl_wayland_vk_wsi_buffer_t;
 
 struct _tpl_wayland_vk_wsi_display {
        struct wayland_tbm_client *wl_tbm_client;
+       struct {
+               int min_buffer;
+               int max_buffer;
+       } surface_capabilities;
 };
 
 struct _tpl_wayland_vk_wsi_surface {
@@ -129,6 +133,9 @@ __tpl_wayland_vk_wsi_display_init(tpl_display_t *display)
                return TPL_ERROR_INVALID_OPERATION;
        }
 
+       wayland_vk_wsi_display->surface_capabilities.min_buffer = 2;
+       wayland_vk_wsi_display->surface_capabilities.max_buffer = CLIENT_QUEUE_SIZE;;
+
        display->backend.data = wayland_vk_wsi_display;
 
        if (__tpl_wayland_vk_wsi_display_is_wl_display(display->native_handle)) {
@@ -211,6 +218,26 @@ __tpl_wayland_vk_wsi_display_filter_config(tpl_display_t *display,
 }
 
 static tpl_result_t
+__tpl_wayland_vk_wsi_display_query_window_supported_buffer_count(tpl_display_t *display,
+               tpl_handle_t window, int *min, int *max)
+{
+       tpl_wayland_vk_wsi_display_t *wayland_vk_wsi_display = NULL;
+
+       TPL_ASSERT(display);
+       TPL_ASSERT(window);
+
+       wayland_vk_wsi_display = (tpl_wayland_vk_wsi_display_t *)display->backend.data;
+
+       if (!wayland_vk_wsi_display) return TPL_ERROR_INVALID_OPERATION;
+
+       if (min) *min = wayland_vk_wsi_display->surface_capabilities.min_buffer;
+       if (max) *max = wayland_vk_wsi_display->surface_capabilities.max_buffer;
+
+       return TPL_ERROR_NONE;
+}
+
+
+static tpl_result_t
 __tpl_wayland_vk_wsi_surface_init(tpl_surface_t *surface)
 {
        tpl_wayland_vk_wsi_surface_t *wayland_vk_wsi_surface = NULL;
@@ -229,9 +256,6 @@ __tpl_wayland_vk_wsi_surface_init(tpl_surface_t *surface)
        surface->backend.data = (void *)wayland_vk_wsi_surface;
        wayland_vk_wsi_surface->tbm_queue = NULL;
 
-       surface->capabilities.min_buffer = 2;
-       surface->capabilities.max_buffer = CLIENT_QUEUE_SIZE;
-
        TPL_LOG(3, "window(%p, %p) %dx%d", surface, surface->native_handle,
                surface->width, surface->height);
 
@@ -480,6 +504,7 @@ __tpl_wayland_vk_wsi_surface_create_swapchain(tpl_surface_t *surface,
                int height, int buffer_count)
 {
        tpl_wayland_vk_wsi_surface_t *wayland_vk_wsi_surface = NULL;
+       tpl_wayland_vk_wsi_display_t *wayland_vk_wsi_display = NULL;
 
        TPL_ASSERT(surface);
        TPL_ASSERT(surface->backend.data);
@@ -488,6 +513,16 @@ __tpl_wayland_vk_wsi_surface_create_swapchain(tpl_surface_t *surface,
        wayland_vk_wsi_surface = (tpl_wayland_vk_wsi_surface_t *) surface->backend.data;
        TPL_ASSERT(wayland_vk_wsi_surface);
 
+       wayland_vk_wsi_display = (tpl_wayland_vk_wsi_display_t *)
+                                surface->display->backend.data;
+       TPL_ASSERT(wayland_vk_wsi_display);
+
+       if ((buffer_count < wayland_vk_wsi_display->surface_capabilities.min_buffer)
+               || (buffer_count > wayland_vk_wsi_display->surface_capabilities.max_buffer)) {
+               TPL_ERR("Invalid buffer_count!");
+               return TPL_ERROR_INVALID_PARAMETER;
+       }
+
        wayland_vk_wsi_surface->tbm_queue = tbm_surface_queue_create(buffer_count,
                                            width,
                                            height,
@@ -574,6 +609,7 @@ __tpl_display_init_backend_wayland_vk_wsi(tpl_display_backend_t *backend)
        backend->fini = __tpl_wayland_vk_wsi_display_fini;
        backend->query_config = __tpl_wayland_vk_wsi_display_query_config;
        backend->filter_config = __tpl_wayland_vk_wsi_display_filter_config;
+       backend->query_window_supported_buffer_count = __tpl_wayland_vk_wsi_display_query_window_supported_buffer_count;
 }
 
 void