[UTC][sdl2][Non-ACR][Fix to be executable on wearable]

Change-Id: I88796ccc2e9c5dcfe7e7ce28392c66cf49dff0bc
Signed-off-by: huiyu,eun <huiyu.eun@samsung.com>

diff --git a/packaging/utc/core-sdl2-tests.xml b/packaging/utc/core-sdl2-tests.xml
index e410148..945c919 100755 (executable)
--- a/packaging/utc/core-sdl2-tests.xml
+++ b/packaging/utc/core-sdl2-tests.xml
@@ -5,5 +5,4 @@
     <description>Core API test Application</description>
     <ui-application appid="core.sdl2-tests" exec="/usr/apps/core-sdl2-tests/bin/tct-sdl2-core" nodisplay="false" multiple="false" type="capp" taskmanage="true">
     </ui-application>
-    <feature name="http://tizen.org/feature/vulkan.version.1_0">true</feature>
 </manifest>

diff --git a/src/utc/sdl2/tct-sdl2-core_wearable.h b/src/utc/sdl2/tct-sdl2-core_wearable.h
index 17156e6..47d7a4b 100755 (executable)
--- a/src/utc/sdl2/tct-sdl2-core_wearable.h
+++ b/src/utc/sdl2/tct-sdl2-core_wearable.h
@@ -34,16 +34,16 @@ extern int utc_SDL_Vulkan_CreateSurface_n3(void);
 extern int utc_SDL_Vulkan_CreateSurface_n4(void);
 
 testcase tc_array[] = {
-       {"utc_SDL_Vulkan_GetInstanceExtensions_p",utc_SDL_Vulkan_GetInstanceExtensions_p,utc_sdl_startup,utc_sdl_cleanup},
-       {"utc_SDL_Vulkan_GetInstanceExtensions_p2",utc_SDL_Vulkan_GetInstanceExtensions_p2,utc_sdl_startup,utc_sdl_cleanup},
-       {"utc_SDL_Vulkan_GetInstanceExtensions_n",utc_SDL_Vulkan_GetInstanceExtensions_n,utc_sdl_startup,utc_sdl_cleanup},
-       {"utc_SDL_Vulkan_GetInstanceExtensions_n2",utc_SDL_Vulkan_GetInstanceExtensions_n2,utc_sdl_startup,utc_sdl_cleanup},
-       {"utc_SDL_Vulkan_GetInstanceExtensions_n3",utc_SDL_Vulkan_GetInstanceExtensions_n3,utc_sdl_startup,utc_sdl_cleanup},
-       {"utc_SDL_Vulkan_CreateSurface_p",utc_SDL_Vulkan_CreateSurface_p,utc_sdl_startup,utc_sdl_cleanup},
-       {"utc_SDL_Vulkan_CreateSurface_n",utc_SDL_Vulkan_CreateSurface_n,utc_sdl_startup,utc_sdl_cleanup},
-       {"utc_SDL_Vulkan_CreateSurface_n2",utc_SDL_Vulkan_CreateSurface_n2,utc_sdl_startup,utc_sdl_cleanup},
-       {"utc_SDL_Vulkan_CreateSurface_n3",utc_SDL_Vulkan_CreateSurface_n3,utc_sdl_startup,utc_sdl_cleanup},
-       {"utc_SDL_Vulkan_CreateSurface_n4",utc_SDL_Vulkan_CreateSurface_n4,utc_sdl_startup,utc_sdl_cleanup},
+       {"utc_SDL_Vulkan_GetInstanceExtensions_p", utc_SDL_Vulkan_GetInstanceExtensions_p, utc_sdl_startup, utc_sdl_cleanup},
+       {"utc_SDL_Vulkan_GetInstanceExtensions_p2", utc_SDL_Vulkan_GetInstanceExtensions_p2, utc_sdl_startup, utc_sdl_cleanup},
+       {"utc_SDL_Vulkan_GetInstanceExtensions_n", utc_SDL_Vulkan_GetInstanceExtensions_n, utc_sdl_startup, utc_sdl_cleanup},
+       {"utc_SDL_Vulkan_GetInstanceExtensions_n2", utc_SDL_Vulkan_GetInstanceExtensions_n2, utc_sdl_startup, utc_sdl_cleanup},
+       {"utc_SDL_Vulkan_GetInstanceExtensions_n3", utc_SDL_Vulkan_GetInstanceExtensions_n3, utc_sdl_startup, utc_sdl_cleanup},
+       {"utc_SDL_Vulkan_CreateSurface_p", utc_SDL_Vulkan_CreateSurface_p, utc_sdl_startup, utc_sdl_cleanup},
+       {"utc_SDL_Vulkan_CreateSurface_n", utc_SDL_Vulkan_CreateSurface_n, utc_sdl_startup, utc_sdl_cleanup},
+       {"utc_SDL_Vulkan_CreateSurface_n2", utc_SDL_Vulkan_CreateSurface_n2, utc_sdl_startup, utc_sdl_cleanup},
+       {"utc_SDL_Vulkan_CreateSurface_n3", utc_SDL_Vulkan_CreateSurface_n3, utc_sdl_startup, utc_sdl_cleanup},
+       {"utc_SDL_Vulkan_CreateSurface_n4", utc_SDL_Vulkan_CreateSurface_n4, utc_sdl_startup, utc_sdl_cleanup},
        {NULL, NULL}
 };
 

diff --git a/src/utc/sdl2/utc-sdl2.c b/src/utc/sdl2/utc-sdl2.c
index 45dbb51..44d8d83 100755 (executable)
--- a/src/utc/sdl2/utc-sdl2.c
+++ b/src/utc/sdl2/utc-sdl2.c
@@ -23,6 +23,20 @@
 #include <vulkan/vulkan.h>
 #include <sys/stat.h>
 #include <dlog.h>
+#include <dlfcn.h>
+
+void *vulkan_handle;
+
+PFN_vkGetInstanceProcAddr fn_vkGetInstanceProcAddr;
+PFN_vkGetDeviceProcAddr fn_vkGetDeviceProcAddr;
+PFN_vkEnumerateInstanceLayerProperties fn_vkEnumerateInstanceLayerProperties;
+PFN_vkCreateInstance fn_vkCreateInstance;
+PFN_vkEnumeratePhysicalDevices fn_vkEnumeratePhysicalDevices;
+PFN_vkEnumerateDeviceLayerProperties fn_vkEnumerateDeviceLayerProperties;
+PFN_vkEnumerateDeviceExtensionProperties fn_vkEnumerateDeviceExtensionProperties;
+PFN_vkGetPhysicalDeviceProperties fn_vkGetPhysicalDeviceProperties;
+PFN_vkGetPhysicalDeviceQueueFamilyProperties fn_vkGetPhysicalDeviceQueueFamilyProperties;
+PFN_vkGetPhysicalDeviceFeatures fn_vkGetPhysicalDeviceFeatures;
 
 #define VULKAN_FEATURE "tizen.org/feature/vulkan.version.1_0"
 #define DEMO_TEXTURE_COUNT 1
@@ -38,7 +52,7 @@
 #define GET_INSTANCE_PROC_ADDR(inst, entrypoint)                               \
     {                                                                          \
         demo->fp##entrypoint =                                                 \
-            (PFN_vk##entrypoint)vkGetInstanceProcAddr(inst, "vk" #entrypoint); \
+            (PFN_vk##entrypoint)fn_vkGetInstanceProcAddr(inst, "vk" #entrypoint); \
         if (demo->fp##entrypoint == NULL) {                                    \
             ERR_EXIT("[Line : %d]vkGetInstanceProcAddr failed to find vk" #entrypoint,    \
                      "vkGetInstanceProcAddr Failure");                         \
@@ -48,7 +62,7 @@
 #define GET_DEVICE_PROC_ADDR(dev, entrypoint)                                  \
     {                                                                          \
         demo->fp##entrypoint =                                                 \
-            (PFN_vk##entrypoint)vkGetDeviceProcAddr(dev, "vk" #entrypoint);    \
+            (PFN_vk##entrypoint)fn_vkGetDeviceProcAddr(dev, "vk" #entrypoint);    \
         if (demo->fp##entrypoint == NULL) {                                    \
             ERR_EXIT("[Line : %d]vkGetDeviceProcAddr failed to find vk" #entrypoint,      \
                      "vkGetDeviceProcAddr Failure");                           \
@@ -293,6 +307,20 @@ void utc_sdl_startup(void)
 
     is_supported = 1;
 
+    vulkan_handle = dlopen("libvulkan.so", RTLD_NOW);
+    if (vulkan_handle) {
+        fn_vkGetInstanceProcAddr = dlsym(vulkan_handle, "vkGetInstanceProcAddr");
+        fn_vkGetDeviceProcAddr = dlsym(vulkan_handle, "vkGetDeviceProcAddr");
+        fn_vkEnumerateInstanceLayerProperties = dlsym(vulkan_handle, "vkEnumerateInstanceLayerProperties");
+        fn_vkCreateInstance = dlsym(vulkan_handle, "vkCreateInstance");
+        fn_vkEnumeratePhysicalDevices = dlsym(vulkan_handle, "vkEnumeratePhysicalDevices");
+        fn_vkEnumerateDeviceLayerProperties = dlsym(vulkan_handle, "vkEnumerateDeviceLayerProperties");
+        fn_vkEnumerateDeviceExtensionProperties = dlsym(vulkan_handle, "vkEnumerateDeviceExtensionProperties");
+        fn_vkGetPhysicalDeviceProperties = dlsym(vulkan_handle, "vkGetPhysicalDeviceProperties");
+        fn_vkGetPhysicalDeviceQueueFamilyProperties = dlsym(vulkan_handle, "vkGetPhysicalDeviceQueueFamilyProperties");
+        fn_vkGetPhysicalDeviceFeatures = dlsym(vulkan_handle, "vkGetPhysicalDeviceFeatures");
+    }
+
     //Initialize SDL
     SDL_GetDisplayMode(0, 0, &(tcData.sdl_mode));
 
@@ -328,6 +356,9 @@ void utc_sdl_cleanup(void)
         SDL_DestroyWindow( tcData.sdl_window );
     }
 
+    if (vulkan_handle)
+        dlclose(vulkan_handle);
+
     //Quit SDL subsystems
 //    SDL_Quit();
 
@@ -380,13 +411,13 @@ void demo_init_vk(struct demo *demo)
     VkBool32 validation_found = 0;
     if (demo->validate) {
         /* Returns up to requested number of global layer properties */
-        err = vkEnumerateInstanceLayerProperties(&instance_layer_count, NULL);
+        err = fn_vkEnumerateInstanceLayerProperties(&instance_layer_count, NULL);
         printErrMessage(__FUNCTION__, err);
 
         instance_validation_layers = instance_validation_layers_alt1;
         if (instance_layer_count > 0) {
             VkLayerProperties *instance_layers = malloc(sizeof(VkLayerProperties) * instance_layer_count);
-            err = vkEnumerateInstanceLayerProperties(&instance_layer_count, instance_layers);
+            err = fn_vkEnumerateInstanceLayerProperties(&instance_layer_count, instance_layers);
             printErrMessage(__FUNCTION__, err);
 
             validation_found = demo_check_layers(ARRAY_SIZE(instance_validation_layers_alt1),
@@ -453,7 +484,7 @@ void demo_init_vk(struct demo *demo)
      * The instance is the connection between your application and the Vulkan library and.
      * creating it involves specifying some details about your application to the driver.
     */
-    err = vkCreateInstance(&inst_info, NULL, &demo->inst);
+    err = fn_vkCreateInstance(&inst_info, NULL, &demo->inst);
     if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
         ERR_EXIT("Cannot find a compatible Vulkan installable client driver "
                  "(ICD).\n\nPlease look at the Getting Started guide for "
@@ -471,12 +502,12 @@ void demo_init_vk(struct demo *demo)
     }
 
     /* Enumerates the physical devices accessible to a Vulkan instance */
-    err = vkEnumeratePhysicalDevices(demo->inst, &gpu_count, NULL);
+    err = fn_vkEnumeratePhysicalDevices(demo->inst, &gpu_count, NULL);
     printErrMessage(__FUNCTION__, err);
 
     if (gpu_count > 0) {
         VkPhysicalDevice *physical_devices = malloc(sizeof(VkPhysicalDevice) * gpu_count);
-        err = vkEnumeratePhysicalDevices(demo->inst, &gpu_count, physical_devices);
+        err = fn_vkEnumeratePhysicalDevices(demo->inst, &gpu_count, physical_devices);
         printErrMessage(__FUNCTION__, err);
         demo->gpu = physical_devices[0];
         free(physical_devices);
@@ -493,12 +524,12 @@ void demo_init_vk(struct demo *demo)
         demo->enabled_layer_count = 0;
         uint32_t device_layer_count = 0;
         /* Returns properties of available physical device layers */
-        err = vkEnumerateDeviceLayerProperties(demo->gpu, &device_layer_count, NULL);
+        err = fn_vkEnumerateDeviceLayerProperties(demo->gpu, &device_layer_count, NULL);
         printErrMessage(__FUNCTION__, err);
 
         if (device_layer_count > 0) {
             VkLayerProperties *device_layers = malloc(sizeof(VkLayerProperties) * device_layer_count);
-            err = vkEnumerateDeviceLayerProperties(demo->gpu, &device_layer_count, device_layers);
+            err = fn_vkEnumerateDeviceLayerProperties(demo->gpu, &device_layer_count, device_layers);
             printErrMessage(__FUNCTION__, err);
 
             validation_found = demo_check_layers(device_validation_layer_count,
@@ -525,13 +556,13 @@ void demo_init_vk(struct demo *demo)
     memset(demo->extension_names, 0, sizeof(demo->extension_names));
 
     /* Returns properties of available physical device extensions */
-    err = vkEnumerateDeviceExtensionProperties(demo->gpu, NULL, &device_extension_count, NULL);
+    err = fn_vkEnumerateDeviceExtensionProperties(demo->gpu, NULL, &device_extension_count, NULL);
     printErrMessage(__FUNCTION__, err);
 
     if (device_extension_count > 0) {
         uint32_t i;
         VkExtensionProperties *device_extensions = malloc(sizeof(VkExtensionProperties) * device_extension_count);
-        err = vkEnumerateDeviceExtensionProperties(demo->gpu, NULL, &device_extension_count, device_extensions);
+        err = fn_vkEnumerateDeviceExtensionProperties(demo->gpu, NULL, &device_extension_count, device_extensions);
         printErrMessage(__FUNCTION__, err);
 
         for (i = 0; i < device_extension_count; i++) {
@@ -557,15 +588,15 @@ void demo_init_vk(struct demo *demo)
     }
 
     if (demo->validate) {
-        demo->CreateDebugReportCallback = (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(demo->inst, "vkCreateDebugReportCallbackEXT");
-        demo->DestroyDebugReportCallback = (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(demo->inst, "vkDestroyDebugReportCallbackEXT");
+        demo->CreateDebugReportCallback = (PFN_vkCreateDebugReportCallbackEXT)fn_vkGetInstanceProcAddr(demo->inst, "vkCreateDebugReportCallbackEXT");
+        demo->DestroyDebugReportCallback = (PFN_vkDestroyDebugReportCallbackEXT)fn_vkGetInstanceProcAddr(demo->inst, "vkDestroyDebugReportCallbackEXT");
         if (!demo->CreateDebugReportCallback)
             ERR_EXIT("GetProcAddr: Unable to find vkCreateDebugReportCallbackEXT\n", "vkGetProcAddr Failure");
 
         if (!demo->DestroyDebugReportCallback)
             ERR_EXIT("GetProcAddr: Unable to find vkDestroyDebugReportCallbackEXT\n", "vkGetProcAddr Failure");
 
-        demo->DebugReportMessage = (PFN_vkDebugReportMessageEXT)vkGetInstanceProcAddr(demo->inst, "vkDebugReportMessageEXT");
+        demo->DebugReportMessage = (PFN_vkDebugReportMessageEXT)fn_vkGetInstanceProcAddr(demo->inst, "vkDebugReportMessageEXT");
         if (!demo->DebugReportMessage)
             ERR_EXIT("GetProcAddr: Unable to find vkDebugReportMessageEXT\n", "vkGetProcAddr Failure");
 
@@ -599,18 +630,18 @@ void demo_init_vk(struct demo *demo)
     GET_INSTANCE_PROC_ADDR(demo->inst, QueuePresentKHR);
 
     /* Returns properties of a physical device */
-    vkGetPhysicalDeviceProperties(demo->gpu, &demo->gpu_props);
+    fn_vkGetPhysicalDeviceProperties(demo->gpu, &demo->gpu_props);
 
     /* Reports properties of the queues of the specified physical device */
-    vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_count, NULL);
+    fn_vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_count, NULL);
 
     /* Reports properties of the queues of the specified physical device */
     demo->queue_props = (VkQueueFamilyProperties *)malloc(demo->queue_count * sizeof(VkQueueFamilyProperties));
-    vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_count, demo->queue_props);
+    fn_vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_count, demo->queue_props);
 
     /* Reports capabilities of a physical device */
     VkPhysicalDeviceFeatures features;
-    vkGetPhysicalDeviceFeatures(demo->gpu, &features);
+    fn_vkGetPhysicalDeviceFeatures(demo->gpu, &features);
 }
 
 /**
@@ -625,6 +656,10 @@ int utc_SDL_Vulkan_GetInstanceExtensions_p(void)
         ret = SDL_Vulkan_GetInstanceExtensions(tcData.sdl_window, &(tcData.enabled_extension_count), NULL);
         assert_eq(ret, SDL_TRUE);
     }
+    else {
+        FPRINTF("Vulkan is not supported.");
+        return 0;
+    }
 
    return 0;
 }
@@ -643,6 +678,10 @@ int utc_SDL_Vulkan_GetInstanceExtensions_p2(void)
         ret = SDL_Vulkan_GetInstanceExtensions(tcData.sdl_window, &(tcData.enabled_extension_count), tcData.extension_names);
         assert_eq(ret, SDL_TRUE);
     }
+    else {
+        FPRINTF("Vulkan is not supported.");
+        return 0;
+    }
 
    return 0;
 }
@@ -660,6 +699,10 @@ int utc_SDL_Vulkan_GetInstanceExtensions_n(void)
         ret = SDL_Vulkan_GetInstanceExtensions(NULL, NULL, NULL);
         assert_eq(ret, SDL_FALSE);
     }
+    else {
+        FPRINTF("Vulkan is not supported.");
+        return 0;
+    }
 
     return 0;
 }
@@ -677,6 +720,10 @@ int utc_SDL_Vulkan_GetInstanceExtensions_n2(void)
         ret = SDL_Vulkan_GetInstanceExtensions(tcData.sdl_window, NULL, NULL);
         assert_eq(ret, SDL_FALSE);
     }
+    else {
+        FPRINTF("Vulkan is not supported.");
+        return 0;
+    }
 
     return 0;
 }
@@ -694,6 +741,10 @@ int utc_SDL_Vulkan_GetInstanceExtensions_n3(void)
         ret = SDL_Vulkan_GetInstanceExtensions(tcData.sdl_window, NULL, tcData.extension_names);
         assert_eq(ret, SDL_FALSE);
     }
+    else {
+        FPRINTF("Vulkan is not supported.");
+        return 0;
+    }
 
     return 0;
 }
@@ -711,6 +762,10 @@ int utc_SDL_Vulkan_CreateSurface_p(void)
         ret = SDL_Vulkan_CreateSurface(tcData.sdl_window, (SDL_vulkanInstance)tcData.inst, (SDL_vulkanSurface*)&tcData.surface);
         assert_eq(ret, SDL_TRUE);
     }
+    else {
+        FPRINTF("Vulkan is not supported.");
+        return 0;
+    }
 
     return 0;
 }
@@ -729,6 +784,10 @@ int utc_SDL_Vulkan_CreateSurface_n(void)
         ret = SDL_Vulkan_CreateSurface(NULL, NULL, NULL);
         assert_eq(ret, SDL_FALSE);
     }
+    else {
+        FPRINTF("Vulkan is not supported.");
+        return 0;
+    }
 
     return 0;
 }
@@ -747,6 +806,10 @@ int utc_SDL_Vulkan_CreateSurface_n2(void)
         ret = SDL_Vulkan_CreateSurface(tcData.sdl_window, NULL, NULL);
         assert_eq(ret, SDL_FALSE);
     }
+    else {
+        FPRINTF("Vulkan is not supported.");
+        return 0;
+    }
 
     return 0;
 }
@@ -765,6 +828,10 @@ int utc_SDL_Vulkan_CreateSurface_n3(void)
         ret = SDL_Vulkan_CreateSurface(tcData.sdl_window, (SDL_vulkanInstance)tcData.inst, NULL);
         assert_eq(ret, SDL_FALSE);
     }
+    else {
+        FPRINTF("Vulkan is not supported.");
+        return 0;
+    }
 
     return 0;
 }
@@ -783,6 +850,10 @@ int utc_SDL_Vulkan_CreateSurface_n4(void)
         ret = SDL_Vulkan_CreateSurface(tcData.sdl_window, NULL, (SDL_vulkanSurface*)&tcData.surface);
         assert_eq(ret, SDL_FALSE);
     }
+    else {
+        FPRINTF("Vulkan is not supported.");
+        return 0;
+    }
 
     return 0;
 }