swapchain: use tpl with sync

	used new tpl funcs
	tpl_surface_dequeue_buffer_with_sync
	get sync_fd from tpl(release buffer) and set sync_fd to driver
	tpl_surface_enqueue_buffer_with_damage_and_sync
	get sync_fd from driver(draw done) and set sync_fd to tpl for use attach/commit
	not use damage

Change-Id: I438f6b722ba6e6f33ca45e8ed1c6867efc200996

diff --git a/include/vulkan/vk_tizen.h b/include/vulkan/vk_tizen.h
index 1c25b63..262cba0 100644 (file)
--- a/include/vulkan/vk_tizen.h
+++ b/include/vulkan/vk_tizen.h
@@ -8,6 +8,14 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateImageFromNativeBufferTIZEN)(VkDevice de
                                                                                                                                         surface, const
                                                                                                                                         VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage);
 
+typedef VkResult (VKAPI_PTR *PFN_vkQueueSignalReleaseImageTIZEN)
+       (VkQueue queue, uint32_t waitSemaphoreCount,
+        const VkSemaphore *pWaitSemaphores,
+        VkImage image, int *pNativeFenceFd);
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireImageTIZEN)
+       (VkDevice device, VkImage image, int nativeFenceFd,
+        VkSemaphore semaphore, VkFence fence);
+
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageFromNativeBufferTIZEN(
        VkDevice                                                                        device,
@@ -15,6 +23,12 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageFromNativeBufferTIZEN(
        const VkImageCreateInfo *                                       pCreateInfo,
        const VkAllocationCallbacks *                           pAllocator,
        VkImage *                                                                       pImage);
+VKAPI_PTR VkResult vkQueueSignalReleaseImageTIZEN(VkQueue queue, uint32_t waitSemaphoreCount,
+                                                                                                 const VkSemaphore *pWaitSemaphores,
+                                                                                                 VkImage image, int *pNativeFenceFd);
+VKAPI_PTR VkResult vkAcquireImageTIZEN(VkDevice device, VkImage image, int nativeFenceFd,
+                                                                          VkSemaphore semaphore, VkFence fence);
+
 #endif
 
 #endif /* VK_TIZEN_H */

diff --git a/src/wsi/icd.c b/src/wsi/icd.c
index d9e85cc..677ea28 100644 (file)
--- a/src/wsi/icd.c
+++ b/src/wsi/icd.c
@@ -69,6 +69,15 @@ module_init(void)
        /* Retrieve WSI-ICD interface functions. */
        icd.create_presentable_image =
                (void *)icd.get_proc_addr(NULL, "vkCreateImageFromNativeBufferTIZEN");
+       VK_DEBUG("icd.create_presentable_image: %p", icd.create_presentable_image);
+
+       icd.queue_signal_release_image =
+               (void *)icd.get_proc_addr(NULL, "vkQueueSignalReleaseImageTIZEN");
+       VK_DEBUG("icd.queue_signal_release_image: %p", icd.queue_signal_release_image);
+
+       icd.acquire_image =
+               (void *)icd.get_proc_addr(NULL, "vkAcquireImageTIZEN");
+       VK_DEBUG("icd.acquire_image: %p", icd.acquire_image);
 
        /* Initialize instance extensions. */
        enum_inst_exts = (void *)icd.get_proc_addr(NULL, "vkEnumerateInstanceExtensionProperties");

diff --git a/src/wsi/swapchain.c b/src/wsi/swapchain.c
index 89786bc..624ccab 100644 (file)
--- a/src/wsi/swapchain.c
+++ b/src/wsi/swapchain.c
@@ -24,6 +24,8 @@
 
 #include "wsi.h"
 #include <string.h>
+#include <unistd.h>
+#include <tbm_sync.h>
 
 #define TBM_FORMAT_0   0
 
@@ -244,16 +246,34 @@ vk_AcquireNextImageKHR(VkDevice                    device,
        uint32_t                 i;
        tbm_surface_h    next;
        vk_swapchain_t  *chain = (vk_swapchain_t *)(uintptr_t)swapchain;
-
-       /* TODO: timeout */
-
-       next = tpl_surface_dequeue_buffer(chain->tpl_surface);
-       VK_CHECK(next, return VK_ERROR_SURFACE_LOST_KHR, "tpl_surface_dequeue_buffers() failed\n.");
+       int sync_fd = -1;
+       tbm_sync_fence_h sync_fence = NULL;
+       tbm_sync_error_e sync_err;
+
+       if (icd->acquire_image) {
+               next = tpl_surface_dequeue_buffer_with_sync(chain->tpl_surface, timeout, &sync_fence);
+
+               if (next == NULL)
+                       return VK_TIMEOUT;
+
+               if (sync_fence) {
+                       sync_fd = tbm_sync_fence_export(sync_fence, &sync_err);
+                       VK_DEBUG("%s, tbm_surface: %p: fence_fd: %d\n", __func__, next, sync_fd);
+                       if (sync_err != TBM_SYNC_ERROR_NONE)
+                               sync_fd = -1;
+                       tbm_sync_fence_destroy(sync_fence);
+               }
+       } else {
+               next = tpl_surface_dequeue_buffer(chain->tpl_surface);
+               VK_CHECK(next, return VK_ERROR_SURFACE_LOST_KHR, "tpl_surface_dequeue_buffers() failed\n.");
+       }
 
        for (i = 0; i < chain->buffer_count; i++) {
                if (next == chain->buffers[i].tbm) {
                        VK_DEBUG("%s, tbm_surface: %p, index: %d\n", __func__, next, i);
                        *image_index = i;
+                       if (icd->acquire_image)
+                               icd->acquire_image(device, chain->buffers[i].image, sync_fd, semaphore, fence);
 
                        /* TODO: We can do optimization here by returning buffer index immediatly despite the
                         * buffer is not released yet. The fence or semaphore will be signaled when
@@ -274,11 +294,29 @@ vk_QueuePresentKHR(VkQueue                                         queue,
        uint32_t         i;
 
        for (i = 0; i < info->swapchainCount; i++) {
+               int sync_fd = -1;
                tpl_result_t res;
+               tbm_sync_fence_h sync_fence = NULL;
+               tbm_sync_error_e sync_err;
                vk_swapchain_t  *chain = (vk_swapchain_t *)(uintptr_t)info->pSwapchains[i];
 
-               res = tpl_surface_enqueue_buffer(chain->tpl_surface,
-                                                                                chain->buffers[info->pImageIndices[i]].tbm);
+               if (icd->queue_signal_release_image)
+                       icd->queue_signal_release_image(queue, info->waitSemaphoreCount, info->pWaitSemaphores,
+                                                                                       chain->buffers[info->pImageIndices[i]].image, &sync_fd);
+
+               if (sync_fd != -1) {
+                       sync_fence = tbm_sync_fence_import(sync_fd, &sync_err);
+                       close(sync_fd);
+               }
+
+               if (sync_fence)
+                       res = tpl_surface_enqueue_buffer_with_damage_and_sync(chain->tpl_surface,
+                                                                                                                                 chain->buffers[info->pImageIndices[i]].tbm,
+                                                                                                                                 0, NULL,
+                                                                                                                                 sync_fence);
+               else
+                       res = tpl_surface_enqueue_buffer(chain->tpl_surface,
+                                                                                        chain->buffers[info->pImageIndices[i]].tbm);
 
                if (info->pResults != NULL)
                        info->pResults[i] = res == TPL_ERROR_NONE ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;

diff --git a/src/wsi/wsi.h b/src/wsi/wsi.h
index 24bfdbc..4e52c39 100644 (file)
--- a/src/wsi/wsi.h
+++ b/src/wsi/wsi.h
@@ -49,6 +49,8 @@ struct vk_icd {
 
        /* WSI-ICD interface. */
        PFN_vkCreateImageFromNativeBufferTIZEN  create_presentable_image;
+       PFN_vkQueueSignalReleaseImageTIZEN              queue_signal_release_image;
+       PFN_vkAcquireImageTIZEN                                 acquire_image;
 };
 
 vk_icd_t *