Update for CTS test:

- Upgrade wsi vulkan version to sync with vulkan loader & vulkan header
- Implement vkCreateWaylandSurfaceKHR & vkDestroySurfaceKHR for TPL display management
- Fix issues of CTS wsi cases

Change-Id: I96a4e0bc9e36a8aa71819f886a293a4994629e6e
Signed-off-by: Tianhao Ni <tianhao.ni@samsung.com>

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 818a75639c157f5316132a26b485c0fa6e655f00..ef5fb5957dc77fd47f5c2c96da115478cc77c7fb 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -163,6 +163,7 @@ if(BUILD_WSI_WAYLAND)
    target_link_libraries(wayland_wsi drm_utils ${WAYLAND_CLIENT_LDFLAGS})
    list(APPEND LINK_WSI_LIBS wayland_wsi)
 elseif(BUILD_WSI_TIZEN)
+   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVK_USE_PLATFORM_WAYLAND_KHR")
    add_library(tizen_wsi STATIC
       wsi/tizen/surface_properties.cpp
       wsi/tizen/swapchain.cpp)

diff --git a/layer/private_data.hpp b/layer/private_data.hpp
index a3598e7c96f83870f314468c67d6b4a5609deb4e..11fa5ce8c02a2458176fe78ab9cbd31b252437b2 100644 (file)
--- a/layer/private_data.hpp
+++ b/layer/private_data.hpp
@@ -138,7 +138,6 @@ struct instance_dispatch_table
    OPTIONAL(AcquireNextImage2KHR)                   \
    OPTIONAL(GetFenceFdKHR)
 
-
 struct device_dispatch_table
 {
    /**

diff --git a/layer/surface_api.hpp b/layer/surface_api.hpp
index b155b39373e8cfedcd794a1b49eb1e246bddbb2c..8fb570d67b4b48868a460de20341c27c2da3b057 100644 (file)
--- a/layer/surface_api.hpp
+++ b/layer/surface_api.hpp
@@ -32,6 +32,11 @@
 #include <vulkan/vulkan.h>
 #include "util/macros.hpp"
 
+VKAPI_ATTR VkResult wsi_layer_vkCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+                                                              const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+VKAPI_ATTR void wsi_layer_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
+
 /**
  * @brief Implements vkGetPhysicalDeviceSurfaceCapabilitiesKHR Vulkan entrypoint.
  */

diff --git a/layer/swapchain_api.cpp b/layer/swapchain_api.cpp
index 096bbb6a123ac716b03dba08fbc11dbaf54f1088..906f6df3344d8660896cddd1de285836417add67 100644 (file)
--- a/layer/swapchain_api.cpp
+++ b/layer/swapchain_api.cpp
@@ -38,10 +38,16 @@
 #include "swapchain_api.hpp"
 #include <util/helpers.hpp>
 
+static bool swapchain_on_prensent = false;
 VWL_VKAPI_CALL(VkResult)
 wsi_layer_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pSwapchainCreateInfo,
                                const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) VWL_API_POST
 {
+   if (swapchain_on_prensent) {
+      wsi_error("Already created other swapchain");
+      return VK_ERROR_INITIALIZATION_FAILED;
+   }
+
    assert(pSwapchain != nullptr);
    layer::device_private_data &device_data = layer::device_private_data::get(device);
    VkSurfaceKHR surface = pSwapchainCreateInfo->surface;
@@ -58,12 +64,15 @@ wsi_layer_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *
    auto sc = wsi::allocate_surface_swapchain(surface, device_data, pAllocator);
    if (sc == nullptr)
    {
+      wsi_error("Alloc swapchain failed.");
       return VK_ERROR_OUT_OF_HOST_MEMORY;
    }
+   wsi_info("Created new swapchain [%p], VkSurface [%p].", sc, surface);
 
    VkResult result = sc->init(device, pSwapchainCreateInfo);
    if (result != VK_SUCCESS)
    {
+      wsi_error("Init swapchain failed, ret [%d].", result);
       return result;
    }
 
@@ -74,6 +83,7 @@ wsi_layer_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *
    }
 
    *pSwapchain = reinterpret_cast<VkSwapchainKHR>(sc.release());
+   swapchain_on_prensent = true;
    return result;
 }
 
@@ -82,15 +92,20 @@ wsi_layer_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapc,
                                 const VkAllocationCallbacks *pAllocator) VWL_API_POST
 {
    layer::device_private_data &device_data = layer::device_private_data::get(device);
+   if (!swapc)
+      return;
 
    if (!device_data.layer_owns_swapchain(swapc))
    {
       return device_data.disp.DestroySwapchainKHR(device_data.device, swapc, pAllocator);
    }
 
+   wsi_info("Destroy swapchain [%p], VkSurface [%p].", swapc);
+
    assert(swapc != VK_NULL_HANDLE);
    auto *sc = reinterpret_cast<wsi::swapchain_base *>(swapc);
    wsi::destroy_surface_swapchain(sc, device_data, pAllocator);
+   swapchain_on_prensent = false;
 }
 
 VWL_VKAPI_CALL(VkResult)

diff --git a/wsi/swapchain_base_tizen.cpp b/wsi/swapchain_base_tizen.cpp
index d74b7e9545f97a5e0a1025774664038e465fcb88..1f81fa08ffcd2eb8092915b799565194238b4c30 100644 (file)
--- a/wsi/swapchain_base_tizen.cpp
+++ b/wsi/swapchain_base_tizen.cpp
@@ -46,6 +46,7 @@ VkResult swapchain_base::init(VkDevice device, const VkSwapchainCreateInfoKHR *s
    result = init_platform(device, swapchain_create_info);
    if (result != VK_SUCCESS)
    {
+      wsi_error("Init platform for VkSurface[%p] failed", m_surface);
       return result;
    }
 
@@ -69,6 +70,7 @@ VkResult swapchain_base::init(VkDevice device, const VkSwapchainCreateInfoKHR *s
    result = create_image(image_create_info);
    if (result != VK_SUCCESS)
    {
+      wsi_error("Create image for VkSurface[%p] failed", m_surface);
       return result;
    }
 
@@ -77,7 +79,7 @@ VkResult swapchain_base::init(VkDevice device, const VkSwapchainCreateInfoKHR *s
    if (swapchain_create_info->oldSwapchain != VK_NULL_HANDLE)
    {
       /* TO BE DONE - How to reuse the old swapchain */
-         /*
+      /*
       m_ancestor = swapchain_create_info->oldSwapchain;
 
       auto *ancestor = reinterpret_cast<swapchain_base *>(m_ancestor);

diff --git a/wsi/swapchain_base_tizen.hpp b/wsi/swapchain_base_tizen.hpp
index 9e62bf4683504f0227d56ad2b46c53e0d7a18d73..308384ac214d434c242d29b0c696918e67f13cd0 100644 (file)
--- a/wsi/swapchain_base_tizen.hpp
+++ b/wsi/swapchain_base_tizen.hpp
@@ -6,6 +6,12 @@
 #include <util/timed_semaphore.hpp>
 #include <util/custom_allocator.hpp>
 
+#define LOG_TAG "WSI"
+#include <dlog/dlog.h>
+
+#define wsi_info(f, x...)    LOGI(f, ##x)
+#define wsi_error(f, x...)   LOGE(f, ##x)
+
 namespace wsi
 {
 struct swapchain_image

diff --git a/wsi/tizen/surface_properties.cpp b/wsi/tizen/surface_properties.cpp
index fceb584c370364c6d812ecd7984b19fb2e41aca1..cfdae9b9df396bc55c87bb0ebed837fe7fa718a2 100644 (file)
--- a/wsi/tizen/surface_properties.cpp
+++ b/wsi/tizen/surface_properties.cpp
@@ -21,7 +21,6 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-#define VK_USE_PLATFORM_WAYLAND_KHR 1
 
 extern "C" {
 #include <vulkan/vk_icd.h>
@@ -58,9 +57,9 @@ VkResult surface_properties::get_surface_capabilities(VkPhysicalDevice physical_
    if (vk_surf == NULL || vk_surf->display == NULL || vk_surf->surface == NULL)
       return VK_ERROR_SURFACE_LOST_KHR;
 
-   tpl_display_t *tpl_display = tpl_display_create(TPL_BACKEND_WAYLAND_VULKAN_WSI_THREAD, vk_surf->display);
-   if (tpl_display == NULL) {
-      return VK_ERROR_OUT_OF_HOST_MEMORY;
+   tpl_display_t *tpl_display = tpl_display_get(reinterpret_cast<tpl_handle_t>(vk_surf->display));
+   if (!tpl_display) {
+      return VK_ERROR_SURFACE_LOST_KHR;
    }
 
    int cnt_min = 0, cnt_max = 0;
@@ -143,9 +142,9 @@ VkResult surface_properties::get_surface_present_modes(VkPhysicalDevice physical
    if (vk_surf == NULL || vk_surf->display == NULL || vk_surf->surface == NULL)
       return VK_ERROR_SURFACE_LOST_KHR;
 
-   tpl_display_t *tpl_display = tpl_display_create(TPL_BACKEND_WAYLAND_VULKAN_WSI_THREAD, vk_surf->display);
-   if (tpl_display == NULL) {
-      return VK_ERROR_OUT_OF_HOST_MEMORY;
+   tpl_display_t *tpl_display = tpl_display_get(reinterpret_cast<tpl_handle_t>(vk_surf->display));
+   if (!tpl_display) {
+      return VK_ERROR_SURFACE_LOST_KHR;
    }
 
    int tplModes;

diff --git a/wsi/tizen/swapchain.cpp b/wsi/tizen/swapchain.cpp
index 3785caf71a1396156f4dc526c479317e90bfb389..62294333218071e90728577f468238574fb8e5c8 100644 (file)
--- a/wsi/tizen/swapchain.cpp
+++ b/wsi/tizen/swapchain.cpp
@@ -22,8 +22,6 @@
  * SOFTWARE.
  */
 
-#define VK_USE_PLATFORM_WAYLAND_KHR 1
-
 #include "swapchain.hpp"
 
 #include <cstring>
@@ -35,17 +33,10 @@
 #include <climits>
 #include <drm_fourcc.h>
 
-#if VULKAN_WSI_DEBUG > 0
-#define WSI_PRINT_ERROR(fmt, ...) fprintf(stderr, "[%s:%d - %s]" fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__)
-#else
-#define WSI_PRINT_ERROR(...) (void)0
-#endif
-
 namespace wsi
 {
 namespace tizen
 {
-
 struct swapchain::tizen_image_data
 {
    int buffer_fd;
@@ -60,7 +51,6 @@ struct swapchain::tizen_image_data
 swapchain::swapchain(layer::device_private_data &dev_data, const VkAllocationCallbacks *pAllocator)
    : swapchain_base(dev_data, pAllocator)
    , m_tpl_surface(nullptr)
-   , m_tpl_display(nullptr)
 {
 }
 
@@ -68,9 +58,10 @@ swapchain::~swapchain()
 {
    teardown();
    destroy_image();
-   tpl_surface_destroy_swapchain(m_tpl_surface);
-   tpl_object_unreference((tpl_object_t *)m_tpl_surface);
-   tpl_object_unreference((tpl_object_t *)m_tpl_display);
+   if (m_tpl_surface) {
+      tpl_surface_destroy_swapchain(m_tpl_surface);
+      tpl_object_unreference((tpl_object_t *)m_tpl_surface);
+   }
 }
 
 #define TBM_FORMAT_0   0
@@ -129,7 +120,7 @@ wsi_tizen_get_tbm_format(VkFormat format, VkCompositeAlphaFlagBitsKHR comp)
       break;
    }
 
-       return 0;
+   return 0;
 }
 
 VkResult swapchain::init_platform(VkDevice device, const VkSwapchainCreateInfoKHR *pSwapchainCreateInfo)
@@ -139,23 +130,26 @@ VkResult swapchain::init_platform(VkDevice device, const VkSwapchainCreateInfoKH
    int tpl_present_mode;
    tpl_result_t res;
 
-   m_tpl_display = tpl_display_create(TPL_BACKEND_WAYLAND_VULKAN_WSI_THREAD, vk_surf->display);
-   if (m_tpl_display == NULL) {
-      WSI_PRINT_ERROR("create tpl display failed\n");
-         return VK_ERROR_INITIALIZATION_FAILED;
+   tpl_display_t *tpl_display = tpl_display_get(reinterpret_cast<tpl_handle_t>(vk_surf->display));
+   if (!tpl_display) {
+      wsi_error("Get tpl display failed\n");
+      return VK_ERROR_SURFACE_LOST_KHR;
    }
-   tpl_object_reference((tpl_object_t *)m_tpl_display);
 
-   format = wsi_tizen_get_tbm_format(pSwapchainCreateInfo->imageFormat, pSwapchainCreateInfo->compositeAlpha);
-   m_tpl_surface = tpl_surface_get(m_tpl_display, vk_surf->surface);
-   if (m_tpl_surface == NULL)
-      m_tpl_surface = tpl_surface_create(m_tpl_display, vk_surf->surface, TPL_SURFACE_TYPE_WINDOW, format);
+   m_tpl_surface = tpl_surface_get(tpl_display, vk_surf->surface);
+   wsi_info("Get tpl_surface[%p] from tpl_display[%p]", m_tpl_surface, tpl_display);
+   if (m_tpl_surface == NULL) {
+      format = wsi_tizen_get_tbm_format(pSwapchainCreateInfo->imageFormat, pSwapchainCreateInfo->compositeAlpha);
+      m_tpl_surface = tpl_surface_create(tpl_display, vk_surf->surface, TPL_SURFACE_TYPE_WINDOW, format);
+   } else {
+      wsi_error("tpl_surface[%p] already in use", m_tpl_surface);
+      return VK_ERROR_INITIALIZATION_FAILED;
+   }
 
    if (m_tpl_surface == NULL) {
-      WSI_PRINT_ERROR("create tpl surface failed\n");
-         return VK_ERROR_INITIALIZATION_FAILED;
+      wsi_error("create tpl surface failed\n");
+      return VK_ERROR_INITIALIZATION_FAILED;
    }
-   tpl_object_reference((tpl_object_t *)m_tpl_surface);
 
    switch(pSwapchainCreateInfo->presentMode) {
       case VK_PRESENT_MODE_IMMEDIATE_KHR:
@@ -171,16 +165,16 @@ VkResult swapchain::init_platform(VkDevice device, const VkSwapchainCreateInfoKH
          tpl_present_mode = TPL_DISPLAY_PRESENT_MODE_FIFO_RELAXED;
          break;
       default:
-         WSI_PRINT_ERROR("unsupported present mode, presentMode[%d].", pSwapchainCreateInfo->presentMode);
+         wsi_error("unsupported present mode, presentMode[%d].", pSwapchainCreateInfo->presentMode);
          return VK_ERROR_INITIALIZATION_FAILED;
    }
 
    res = tpl_surface_create_swapchain(m_tpl_surface, format,
-                                                                          pSwapchainCreateInfo->imageExtent.width, pSwapchainCreateInfo->imageExtent.height,
-                                                                          pSwapchainCreateInfo->minImageCount, tpl_present_mode);
+                                      pSwapchainCreateInfo->imageExtent.width, pSwapchainCreateInfo->imageExtent.height,
+                                      pSwapchainCreateInfo->minImageCount, tpl_present_mode);
    if (res != TPL_ERROR_NONE) {
-          WSI_PRINT_ERROR("create swapchain failed, ret[%d].\n", res);
-          return VK_ERROR_INITIALIZATION_FAILED;
+      wsi_error("create swapchain failed, ret[%d].\n", res);
+      return VK_ERROR_INITIALIZATION_FAILED;
    }
 
    return VK_SUCCESS;
@@ -212,7 +206,7 @@ VkResult swapchain::allocate_image(const VkImageCreateInfo &image_create_info, t
    result = m_device_data.disp.CreateImage(m_device, &image_info, get_allocation_callbacks(), image);
    if (result != VK_SUCCESS)
    {
-      WSI_PRINT_ERROR("Image creation failed.\n");
+      wsi_error("Image creation failed.\n");
       return result;
    }
 
@@ -223,7 +217,7 @@ VkResult swapchain::allocate_image(const VkImageCreateInfo &image_create_info, t
                                                      image_data->buffer_fd, &mem_props);
    if (result != VK_SUCCESS)
    {
-      WSI_PRINT_ERROR("Error querying Fd properties.\n");
+      wsi_error("Error querying Fd properties.\n");
       return result;
    }
 
@@ -238,7 +232,7 @@ VkResult swapchain::allocate_image(const VkImageCreateInfo &image_create_info, t
    off_t dma_buf_size = lseek(image_data->buffer_fd, 0, SEEK_END);
    if (dma_buf_size < 0)
    {
-      WSI_PRINT_ERROR("Failed to get DMA Buf size.\n");
+      wsi_error("Failed to get DMA Buf size.\n");
       return VK_ERROR_OUT_OF_HOST_MEMORY;
    }
 
@@ -257,7 +251,7 @@ VkResult swapchain::allocate_image(const VkImageCreateInfo &image_create_info, t
 
    if (result != VK_SUCCESS)
    {
-      WSI_PRINT_ERROR("Failed to import memory.\n");
+      wsi_error("Failed to import memory.\n");
       return result;
    }
    result = m_device_data.disp.BindImageMemory(m_device, *image, image_data->memory, 0);
@@ -278,22 +272,30 @@ VkResult swapchain::create_image(const VkImageCreateInfo &image_create_info)
    else if (res != TPL_ERROR_NONE)
       return VK_ERROR_INITIALIZATION_FAILED;
 
+   wsi_info("Get swapchain buffer numbers [%d], swapchain [%p], tpl_surface [%p]", tbm_buf_cnt, this, m_tpl_surface);
+
    if (tbm_buf_cnt < 2)
       return VK_ERROR_OUT_OF_HOST_MEMORY;
 
    res = tpl_surface_get_swapchain_buffers(m_tpl_surface, &buffers, &tbm_buf_cnt);
-   if (res == TPL_ERROR_OUT_OF_MEMORY)
-      return VK_ERROR_OUT_OF_HOST_MEMORY;
-   else if (res != TPL_ERROR_NONE)
+   if (res != TPL_ERROR_NONE) {
+      wsi_error("Get TPL swapchain buffers failed, ret[%d], swapchain [%p], tpl_surface [%p]", res, this, m_tpl_surface);
+      if (res == TPL_ERROR_OUT_OF_MEMORY)
+         return VK_ERROR_OUT_OF_HOST_MEMORY;
+
       return VK_ERROR_INITIALIZATION_FAILED;
+   }
 
-   if (!m_swapchain_images.try_resize(tbm_buf_cnt))
+   if (!m_swapchain_images.try_resize(tbm_buf_cnt)) {
+      wsi_error("Resize m_swapchain_images failed");
       return VK_ERROR_OUT_OF_HOST_MEMORY;
+   }
 
+   wsi_info("Create swapchain images [%p], swapchain [%p], tpl_surface [%p]", &m_swapchain_images, this, m_tpl_surface);
    i = 0;
    for (auto &image: m_swapchain_images) {
       tizen_image_data *image_data = nullptr;
-         if (get_allocation_callbacks() != nullptr)
+      if (get_allocation_callbacks() != nullptr)
       {
          image_data = static_cast<tizen_image_data *>(
             get_allocation_callbacks()->pfnAllocation(get_allocation_callbacks()->pUserData, sizeof(tizen_image_data),
@@ -301,32 +303,38 @@ VkResult swapchain::create_image(const VkImageCreateInfo &image_create_info)
       } else {
          image_data = static_cast<tizen_image_data *>(malloc(sizeof(tizen_image_data)));
       }
+      if (!image_data) {
+         wsi_error("Allocate image data failed");
+         result = VK_ERROR_OUT_OF_HOST_MEMORY;
+         goto out;
+      }
 
       tbm_surface_info_s info;
       tbm_bo bo = tbm_surface_internal_get_bo(buffers[i], 0);
       tbm_bo_handle bo_handle = tbm_bo_get_handle(bo, TBM_DEVICE_3D);
       tbm_surface_get_info(buffers[i], &info);
 
-         image_data->tbm_buffer = buffers[i];
-      image_data->buffer_fd = bo_handle.u32;
+      image_data->tbm_buffer = buffers[i];
+      image_data->buffer_fd = bo_handle.u32;//tbm_bo_export_fd(bo);
       image_data->stride = info.planes[0].stride;
       image_data->offset = info.planes[0].offset;
-         image_data->memory = VK_NULL_HANDLE;
+      image_data->memory = VK_NULL_HANDLE;
+
+      wsi_info("New image[%d] - tbm_buffer [%p], buffer fd [%d]", i, image_data->tbm_buffer, image_data->buffer_fd);
 
-         image.data = static_cast<void *>(image_data);
+      image.data = static_cast<void *>(image_data);
 
       result = allocate_image(image_create_info, image_data, &image.image);
       if (result != VK_SUCCESS)
       {
-         WSI_PRINT_ERROR("Failed to allocate image.\n");
+         wsi_error("Failed to allocate image, ret [%d].", result);
          goto out;
       }
 
-         /* Initialize presentation fence. */
-         VkFenceCreateInfo fenceInfo = { VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, nullptr, 0 };
+      /* Initialize presentation fence. */
+      VkFenceCreateInfo fenceInfo = { VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, nullptr, 0 };
       result = m_device_data.disp.CreateFence(m_device, &fenceInfo, get_allocation_callbacks(), &image.present_fence);
-
-         i++;
+      i++;
    }
 
    return VK_SUCCESS;
@@ -342,17 +350,22 @@ VkResult swapchain::acquire_image(uint32_t *image_index)
 {
    tbm_surface_h tbm_buf = tpl_surface_dequeue_buffer_with_sync(m_tpl_surface, UINT64_MAX, NULL);
 
-   if (tbm_buf == NULL)
+   if (tbm_buf == NULL) {
+      wsi_error("Dequeue buffer failed, swapchain [%p], tpl_surface [%p]", this, m_tpl_surface);
       return VK_ERROR_SURFACE_LOST_KHR;
+   }
+
 
    for (unsigned int i = 0; i < m_swapchain_images.size(); i++) {
       tizen_image_data *image_data = reinterpret_cast<tizen_image_data *>(m_swapchain_images[i].data);
       if (image_data->tbm_buffer == tbm_buf) {
          *image_index = i;
+         //wsi_error("Acquire image [%d], tbm_buffer [%p], swapchain [%p], tpl_surface [%p]", i, tbm_buf, this, m_tpl_surface);
          return VK_SUCCESS;
       }
    }
 
+   wsi_error("Invalid swapchain buffer [%p], swapchain [%p], tpl_surface [%p]", tbm_buf, this, m_tpl_surface);
    return VK_ERROR_SURFACE_LOST_KHR;
 }
 

diff --git a/wsi/tizen/swapchain.hpp b/wsi/tizen/swapchain.hpp
index d2c277c70e6f068ecbcb23d8221f0f9572cb5b70..b6424271e965d4d583a6b8e1f56957c357ed8d2b 100644 (file)
--- a/wsi/tizen/swapchain.hpp
+++ b/wsi/tizen/swapchain.hpp
@@ -83,7 +83,7 @@ private:
    struct tizen_image_data;
    VkResult allocate_image(const VkImageCreateInfo &image_create_info, tizen_image_data *image_data, VkImage *image);
 
-   tpl_display_t *m_tpl_display;
+   //tpl_display_t *m_tpl_display;
    tpl_surface_t *m_tpl_surface;
 
 };