1 /* GStreamer
2 *
3 * Copyright (C) 2019 Matthew Waters <matthew@centricular.com>
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Library General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Library General Public License for more details.
14 *
15 * You should have received a copy of the GNU Library General Public
16 * License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 * Boston, MA 02111-1307, USA.
19 */
20
21 #ifdef HAVE_CONFIG_H
22 #include "config.h"
23 #endif
24
25 #include <gst/gst.h>
26 #include <gst/check/gstcheck.h>
27 #include <gst/check/gstharness.h>
28 #include <gst/vulkan/vulkan.h>
29
30 static GstVulkanInstance *instance;
31 static GstVulkanDevice *device;
32
33 static void
setup(void)34 setup (void)
35 {
36 instance = gst_vulkan_instance_new ();
37 fail_unless (gst_vulkan_instance_open (instance, NULL));
38 device = gst_vulkan_device_new_with_index (instance, 0);
39 fail_unless (gst_vulkan_device_open (device, NULL));
40 }
41
42 static void
teardown(void)43 teardown (void)
44 {
45 gst_object_unref (instance);
46 gst_object_unref (device);
47 }
48
49 static void
check_size(GstMemory * mem,gsize at_least)50 check_size (GstMemory * mem, gsize at_least)
51 {
52 gsize size, maxsize, offset;
53
54 size = gst_memory_get_sizes (mem, &offset, &maxsize);
55 fail_unless (size <= maxsize);
56 fail_unless (size >= at_least);
57 }
58
59 static GstVulkanImageMemory *
create_image_mem(GstVideoInfo * v_info)60 create_image_mem (GstVideoInfo * v_info)
61 {
62 GstVulkanImageMemory *vk_mem;
63 VkImageUsageFlags usage;
64 VkFormat vk_format;
65 GstMemory *mem;
66
67 vk_format = gst_vulkan_format_from_video_info (v_info, 0);
68
69 usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
70 mem =
71 gst_vulkan_image_memory_alloc (device, vk_format,
72 GST_VIDEO_INFO_COMP_WIDTH (v_info, 0),
73 GST_VIDEO_INFO_COMP_HEIGHT (v_info, 0), VK_IMAGE_TILING_LINEAR,
74 usage, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
75 fail_unless (gst_is_vulkan_image_memory (mem));
76 vk_mem = (GstVulkanImageMemory *) mem;
77 fail_unless (vk_mem->usage == usage);
78 return vk_mem;
79 }
80
GST_START_TEST(test_image_new)81 GST_START_TEST (test_image_new)
82 {
83 GstVulkanImageMemory *vk_mem;
84 GstVideoInfo v_info;
85 gsize offset, size;
86
87 gst_video_info_set_format (&v_info, GST_VIDEO_FORMAT_RGBA, 16, 16);
88 vk_mem = create_image_mem (&v_info);
89
90 fail_unless (vk_mem->device == device);
91 fail_unless (vk_mem->vk_mem != NULL);
92
93 size = gst_memory_get_sizes ((GstMemory *) vk_mem, &offset, NULL);
94 fail_unless (offset == 0);
95 check_size ((GstMemory *) vk_mem, v_info.size);
96 fail_unless (vk_mem->requirements.size >= size);
97
98 size = gst_memory_get_sizes ((GstMemory *) vk_mem->vk_mem, &offset, NULL);
99 fail_unless (offset == 0);
100 check_size ((GstMemory *) vk_mem->vk_mem, v_info.size);
101
102 gst_memory_unref ((GstMemory *) vk_mem);
103 }
104
105 GST_END_TEST;
106
GST_START_TEST(test_image_view_new)107 GST_START_TEST (test_image_view_new)
108 {
109 GstVulkanImageMemory *vk_mem;
110 GstVulkanImageView *view;
111 GstVideoInfo v_info;
112
113 gst_video_info_set_format (&v_info, GST_VIDEO_FORMAT_RGBA, 16, 16);
114 vk_mem = create_image_mem (&v_info);
115
116 view = gst_vulkan_get_or_create_image_view (vk_mem);
117
118 gst_vulkan_image_view_unref (view);
119 gst_memory_unref ((GstMemory *) vk_mem);
120 }
121
122 GST_END_TEST;
123
GST_START_TEST(test_image_view_get)124 GST_START_TEST (test_image_view_get)
125 {
126 GstVulkanImageMemory *vk_mem;
127 GstVulkanImageView *view;
128 GstVideoInfo v_info;
129
130 gst_video_info_set_format (&v_info, GST_VIDEO_FORMAT_RGBA, 16, 16);
131 vk_mem = create_image_mem (&v_info);
132
133 view = gst_vulkan_get_or_create_image_view (vk_mem);
134 gst_vulkan_image_view_unref (view);
135 view = gst_vulkan_get_or_create_image_view (vk_mem);
136 gst_vulkan_image_view_unref (view);
137
138 gst_memory_unref ((GstMemory *) vk_mem);
139 }
140
141 GST_END_TEST;
142
143 #define N_THREADS 2
144 #define N_MEMORY 4
145 #define N_OPS 512
146
147 struct view_stress
148 {
149 GMutex lock;
150 GCond cond;
151 gboolean ready;
152 int n_ops;
153 GQueue *memories;
154 GstHarnessThread *threads[N_THREADS];
155 };
156
157 static void
wait_for_ready(GstHarnessThread * thread,struct view_stress * stress)158 wait_for_ready (GstHarnessThread * thread, struct view_stress *stress)
159 {
160 g_mutex_lock (&stress->lock);
161 while (!stress->ready)
162 g_cond_wait (&stress->cond, &stress->lock);
163 g_mutex_unlock (&stress->lock);
164 }
165
166 static void
get_unref_image_view(GstHarnessThread * thread,struct view_stress * stress)167 get_unref_image_view (GstHarnessThread * thread, struct view_stress *stress)
168 {
169 int rand = g_random_int_range (0, N_MEMORY);
170 GstVulkanImageMemory *mem;
171 GstVulkanImageView *view;
172
173 mem = g_queue_peek_nth (stress->memories, rand);
174 view = gst_vulkan_get_or_create_image_view (mem);
175 gst_vulkan_image_view_unref (view);
176
177 g_atomic_int_inc (&stress->n_ops);
178 if (g_atomic_int_get (&stress->n_ops) > N_OPS)
179 g_usleep (100);
180 }
181
GST_START_TEST(test_image_view_stress)182 GST_START_TEST (test_image_view_stress)
183 {
184 GstHarness *h = gst_harness_new_empty ();
185 struct view_stress stress;
186 GstVideoInfo v_info;
187 int i;
188
189 g_mutex_init (&stress.lock);
190 g_cond_init (&stress.cond);
191 stress.ready = FALSE;
192 g_atomic_int_set (&stress.n_ops, 0);
193 stress.memories = g_queue_new ();
194
195 gst_video_info_set_format (&v_info, GST_VIDEO_FORMAT_RGBA, 16, 16);
196 for (i = 0; i < N_MEMORY; i++) {
197 g_queue_push_head (stress.memories, create_image_mem (&v_info));
198 }
199
200 g_mutex_lock (&stress.lock);
201 for (i = 0; i < N_THREADS; i++) {
202 stress.threads[i] = gst_harness_stress_custom_start (h,
203 (GFunc) wait_for_ready, (GFunc) get_unref_image_view, &stress, 10);
204 }
205 stress.ready = TRUE;
206 g_cond_broadcast (&stress.cond);
207 g_mutex_unlock (&stress.lock);
208
209 while (g_atomic_int_get (&stress.n_ops) < N_OPS)
210 g_usleep (10000);
211
212 for (i = 0; i < N_THREADS; i++) {
213 gst_harness_stress_thread_stop (stress.threads[i]);
214 }
215
216 g_mutex_clear (&stress.lock);
217 g_cond_clear (&stress.cond);
218 g_queue_free_full (stress.memories, (GDestroyNotify) gst_memory_unref);
219 gst_harness_teardown (h);
220 }
221
222 GST_END_TEST;
223
224 static Suite *
vkimage_suite(void)225 vkimage_suite (void)
226 {
227 Suite *s = suite_create ("vkimage");
228 TCase *tc_basic = tcase_create ("general");
229 gboolean have_instance;
230
231 suite_add_tcase (s, tc_basic);
232 tcase_add_checked_fixture (tc_basic, setup, teardown);
233
234 /* FIXME: CI doesn't have a software vulkan renderer (and none exists currently) */
235 instance = gst_vulkan_instance_new ();
236 have_instance = gst_vulkan_instance_open (instance, NULL);
237 gst_object_unref (instance);
238 if (have_instance) {
239 tcase_add_test (tc_basic, test_image_new);
240 tcase_add_test (tc_basic, test_image_view_new);
241 tcase_add_test (tc_basic, test_image_view_get);
242 tcase_add_test (tc_basic, test_image_view_stress);
243 }
244
245 return s;
246 }
247
248
249 GST_CHECK_MAIN (vkimage);
250