3 * Copyright (C) 2016 Matthew Waters <matthew@centricular.com>
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.
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.
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., 51 Franklin St, Fifth Floor,
18 * Boston, MA 02110-1301, USA.
22 * SECTION:element-vulkanupload
23 * @title: vulkanupload
25 * vulkanupload uploads data into Vulkan memory objects.
36 GST_DEBUG_CATEGORY (gst_debug_vulkan_upload);
37 #define GST_CAT_DEFAULT gst_debug_vulkan_upload
40 _set_caps_features_with_passthrough (const GstCaps * caps,
41 const gchar * feature_name, GstCapsFeatures * passthrough)
46 tmp = gst_caps_copy (caps);
48 n = gst_caps_get_size (caps);
49 for (i = 0; i < n; i++) {
50 GstCapsFeatures *features, *orig_features;
52 orig_features = gst_caps_get_features (caps, i);
53 features = gst_caps_features_new (feature_name, NULL);
55 m = gst_caps_features_get_size (orig_features);
56 for (j = 0; j < m; j++) {
57 const gchar *feature = gst_caps_features_get_nth (orig_features, j);
59 /* if we already have the features */
60 if (gst_caps_features_contains (features, feature))
63 if (g_strcmp0 (feature, GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY) == 0)
66 if (passthrough && gst_caps_features_contains (passthrough, feature)) {
67 gst_caps_features_add (features, feature);
71 gst_caps_set_features (tmp, i, features);
79 GstVulkanUpload *upload;
83 _buffer_new_impl (GstVulkanUpload * upload)
85 struct BufferUpload *raw = g_new0 (struct BufferUpload, 1);
93 _buffer_transform_caps (gpointer impl, GstPadDirection direction,
96 return gst_caps_ref (caps);
100 _buffer_set_caps (gpointer impl, GstCaps * in_caps, GstCaps * out_caps)
106 _buffer_propose_allocation (gpointer impl, GstQuery * decide_query,
109 struct BufferUpload *raw = impl;
114 GstBufferPool *pool = NULL;
116 gst_query_parse_allocation (query, &caps, &need_pool);
121 if (!gst_video_info_from_caps (&info, caps))
124 /* the normal size of a frame */
128 GstStructure *config;
130 pool = gst_vulkan_buffer_pool_new (raw->upload->device);
132 config = gst_buffer_pool_get_config (pool);
133 gst_buffer_pool_config_set_params (config, caps, size, 0, 0);
135 if (!gst_buffer_pool_set_config (pool, config)) {
136 g_object_unref (pool);
141 gst_query_add_allocation_pool (query, pool, size, 1, 0);
143 g_object_unref (pool);
149 _buffer_perform (gpointer impl, GstBuffer * inbuf, GstBuffer ** outbuf)
151 if (!gst_is_vulkan_buffer_memory (gst_buffer_peek_memory (inbuf, 0)))
152 return GST_FLOW_ERROR;
160 _buffer_free (gpointer impl)
165 static GstStaticCaps _buffer_in_templ =
166 GST_STATIC_CAPS ("video/x-raw(" GST_CAPS_FEATURE_MEMORY_VULKAN_BUFFER ") ;"
168 static GstStaticCaps _buffer_out_templ =
169 GST_STATIC_CAPS ("video/x-raw(" GST_CAPS_FEATURE_MEMORY_VULKAN_BUFFER ")");
171 static const struct UploadMethod buffer_upload = {
176 _buffer_transform_caps,
178 _buffer_propose_allocation,
183 struct RawToBufferUpload
185 GstVulkanUpload *upload;
187 GstVideoInfo in_info;
188 GstVideoInfo out_info;
191 gboolean pool_active;
193 gsize alloc_sizes[GST_VIDEO_MAX_PLANES];
197 _raw_to_buffer_new_impl (GstVulkanUpload * upload)
199 struct RawToBufferUpload *raw = g_new0 (struct RawToBufferUpload, 1);
201 raw->upload = upload;
207 _raw_to_buffer_transform_caps (gpointer impl, GstPadDirection direction,
212 if (direction == GST_PAD_SINK) {
214 _set_caps_features_with_passthrough (caps,
215 GST_CAPS_FEATURE_MEMORY_VULKAN_BUFFER, NULL);
218 _set_caps_features_with_passthrough (caps,
219 GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY, NULL);
226 _raw_to_buffer_set_caps (gpointer impl, GstCaps * in_caps, GstCaps * out_caps)
228 struct RawToBufferUpload *raw = impl;
229 guint out_width, out_height;
232 if (!gst_video_info_from_caps (&raw->in_info, in_caps))
235 if (!gst_video_info_from_caps (&raw->out_info, out_caps))
238 out_width = GST_VIDEO_INFO_WIDTH (&raw->out_info);
239 out_height = GST_VIDEO_INFO_HEIGHT (&raw->out_info);
241 for (i = 0; i < GST_VIDEO_INFO_N_PLANES (&raw->out_info); i++) {
242 GstVideoFormat v_format = GST_VIDEO_INFO_FORMAT (&raw->out_info);
243 GstVulkanImageMemory *img_mem;
246 vk_format = gst_vulkan_format_from_video_format (v_format, i);
248 img_mem = (GstVulkanImageMemory *)
249 gst_vulkan_image_memory_alloc (raw->upload->device, vk_format,
250 out_width, out_height, VK_IMAGE_TILING_OPTIMAL,
251 VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
252 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
254 raw->alloc_sizes[i] = img_mem->requirements.size;
256 gst_memory_unref (GST_MEMORY_CAST (img_mem));
263 _raw_to_buffer_propose_allocation (gpointer impl, GstQuery * decide_query,
266 /* a little trickery with the impl pointer */
267 _buffer_propose_allocation (impl, decide_query, query);
271 _raw_to_buffer_perform (gpointer impl, GstBuffer * inbuf, GstBuffer ** outbuf)
273 struct RawToBufferUpload *raw = impl;
274 GstVideoFrame v_frame;
279 GstStructure *config;
280 guint min = 0, max = 0;
283 raw->pool = gst_vulkan_buffer_pool_new (raw->upload->device);
284 config = gst_buffer_pool_get_config (raw->pool);
285 gst_buffer_pool_config_set_params (config, raw->upload->out_caps, size, min,
287 gst_buffer_pool_set_config (raw->pool, config);
289 if (!raw->pool_active) {
290 gst_buffer_pool_set_active (raw->pool, TRUE);
291 raw->pool_active = TRUE;
295 gst_buffer_pool_acquire_buffer (raw->pool, outbuf,
296 NULL)) != GST_FLOW_OK)
299 if (!gst_video_frame_map (&v_frame, &raw->in_info, inbuf, GST_MAP_READ)) {
300 GST_ELEMENT_ERROR (raw->upload, RESOURCE, NOT_FOUND,
301 ("%s", "Failed to map input buffer"), NULL);
302 return GST_FLOW_ERROR;
305 for (i = 0; i < GST_VIDEO_INFO_N_PLANES (&raw->out_info); i++) {
310 mem = gst_buffer_peek_memory (*outbuf, i);
311 if (!gst_memory_map (GST_MEMORY_CAST (mem), &map_info, GST_MAP_WRITE)) {
312 GST_ELEMENT_ERROR (raw->upload, RESOURCE, NOT_FOUND,
313 ("%s", "Failed to map output memory"), NULL);
314 gst_buffer_unref (*outbuf);
316 ret = GST_FLOW_ERROR;
321 GST_VIDEO_INFO_PLANE_STRIDE (&raw->out_info,
322 i) * GST_VIDEO_INFO_COMP_HEIGHT (&raw->out_info, i);
323 g_assert (plane_size < map_info.size);
324 memcpy (map_info.data, v_frame.data[i], plane_size);
326 gst_memory_unmap (GST_MEMORY_CAST (mem), &map_info);
329 gst_video_frame_unmap (&v_frame);
338 _raw_to_buffer_free (gpointer impl)
340 struct RawToBufferUpload *raw = impl;
343 if (raw->pool_active) {
344 gst_buffer_pool_set_active (raw->pool, FALSE);
346 raw->pool_active = FALSE;
347 gst_object_unref (raw->pool);
354 static GstStaticCaps _raw_to_buffer_in_templ = GST_STATIC_CAPS ("video/x-raw");
355 static GstStaticCaps _raw_to_buffer_out_templ =
356 GST_STATIC_CAPS ("video/x-raw(" GST_CAPS_FEATURE_MEMORY_VULKAN_BUFFER ")");
358 static const struct UploadMethod raw_to_buffer_upload = {
360 &_raw_to_buffer_in_templ,
361 &_raw_to_buffer_out_templ,
362 _raw_to_buffer_new_impl,
363 _raw_to_buffer_transform_caps,
364 _raw_to_buffer_set_caps,
365 _raw_to_buffer_propose_allocation,
366 _raw_to_buffer_perform,
370 struct BufferToImageUpload
372 GstVulkanUpload *upload;
374 GstVideoInfo in_info;
375 GstVideoInfo out_info;
378 gboolean pool_active;
380 GstVulkanCommandPool *cmd_pool;
381 GstVulkanTrashList *trash_list;
385 _buffer_to_image_new_impl (GstVulkanUpload * upload)
387 struct BufferToImageUpload *raw = g_new0 (struct BufferToImageUpload, 1);
389 raw->upload = upload;
390 raw->trash_list = gst_vulkan_trash_fence_list_new ();
396 _buffer_to_image_transform_caps (gpointer impl, GstPadDirection direction,
401 if (direction == GST_PAD_SINK) {
403 _set_caps_features_with_passthrough (caps,
404 GST_CAPS_FEATURE_MEMORY_VULKAN_IMAGE, NULL);
407 _set_caps_features_with_passthrough (caps,
408 GST_CAPS_FEATURE_MEMORY_VULKAN_BUFFER, NULL);
415 _buffer_to_image_set_caps (gpointer impl, GstCaps * in_caps, GstCaps * out_caps)
417 struct BufferToImageUpload *raw = impl;
419 if (!gst_video_info_from_caps (&raw->in_info, in_caps))
422 if (!gst_video_info_from_caps (&raw->out_info, out_caps))
429 _buffer_to_image_propose_allocation (gpointer impl, GstQuery * decide_query,
432 /* a little trickery with the impl pointer */
433 _buffer_propose_allocation (impl, decide_query, query);
437 _buffer_to_image_perform (gpointer impl, GstBuffer * inbuf, GstBuffer ** outbuf)
439 struct BufferToImageUpload *raw = impl;
441 GError *error = NULL;
443 GstVulkanCommandBuffer *cmd_buf;
446 if (!raw->cmd_pool) {
447 if (!(raw->cmd_pool =
448 gst_vulkan_queue_create_command_pool (raw->upload->queue,
454 if (!(cmd_buf = gst_vulkan_command_pool_create (raw->cmd_pool, &error)))
458 GstStructure *config;
459 guint min = 0, max = 0;
462 raw->pool = gst_vulkan_image_buffer_pool_new (raw->upload->device);
463 config = gst_buffer_pool_get_config (raw->pool);
464 gst_buffer_pool_config_set_params (config, raw->upload->out_caps, size, min,
466 gst_buffer_pool_set_config (raw->pool, config);
468 if (!raw->pool_active) {
469 gst_buffer_pool_set_active (raw->pool, TRUE);
470 raw->pool_active = TRUE;
474 gst_buffer_pool_acquire_buffer (raw->pool, outbuf,
475 NULL)) != GST_FLOW_OK)
480 VkCommandBufferBeginInfo cmd_buf_info = {
481 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
483 .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
484 .pInheritanceInfo = NULL
488 gst_vulkan_command_buffer_lock (cmd_buf);
489 err = vkBeginCommandBuffer (cmd_buf->cmd, &cmd_buf_info);
490 if (gst_vulkan_error_to_g_error (err, &error, "vkBeginCommandBuffer") < 0)
494 for (i = 0; i < GST_VIDEO_INFO_N_PLANES (&raw->out_info); i++) {
495 VkBufferImageCopy region;
496 GstMemory *in_mem, *out_mem;
497 GstVulkanBufferMemory *buf_mem;
498 GstVulkanImageMemory *img_mem;
499 VkImageMemoryBarrier image_memory_barrier;
500 VkBufferMemoryBarrier buffer_memory_barrier;
502 in_mem = gst_buffer_peek_memory (inbuf, i);
503 if (!gst_is_vulkan_buffer_memory (in_mem)) {
504 GST_WARNING_OBJECT (raw->upload, "Input is not a GstVulkanBufferMemory");
507 buf_mem = (GstVulkanBufferMemory *) in_mem;
509 out_mem = gst_buffer_peek_memory (*outbuf, i);
510 if (!gst_is_vulkan_image_memory (out_mem)) {
511 GST_WARNING_OBJECT (raw->upload, "Output is not a GstVulkanImageMemory");
514 img_mem = (GstVulkanImageMemory *) out_mem;
517 region = (VkBufferImageCopy) {
519 .bufferRowLength = GST_VIDEO_INFO_COMP_WIDTH (&raw->in_info, i),
520 .bufferImageHeight = GST_VIDEO_INFO_COMP_HEIGHT (&raw->in_info, i),
521 .imageSubresource = {
522 .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
527 .imageOffset = { .x = 0, .y = 0, .z = 0, },
529 .width = GST_VIDEO_INFO_COMP_WIDTH (&raw->out_info, i),
530 .height = GST_VIDEO_INFO_COMP_HEIGHT (&raw->out_info, i),
535 image_memory_barrier = (VkImageMemoryBarrier) {
536 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
538 .srcAccessMask = img_mem->barrier.parent.access_flags,
539 .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
540 .oldLayout = img_mem->barrier.image_layout,
541 .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
542 /* FIXME: implement exclusive transfers */
543 .srcQueueFamilyIndex = 0,
544 .dstQueueFamilyIndex = 0,
545 .image = img_mem->image,
546 .subresourceRange = img_mem->barrier.subresource_range
549 buffer_memory_barrier = (VkBufferMemoryBarrier) {
550 .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
552 .srcAccessMask = buf_mem->barrier.parent.access_flags,
553 .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
554 /* FIXME: implement exclusive transfers */
555 .srcQueueFamilyIndex = 0,
556 .dstQueueFamilyIndex = 0,
557 .buffer = buf_mem->buffer,
558 .offset = region.bufferOffset,
559 .size = region.bufferRowLength * region.bufferImageHeight
563 vkCmdPipelineBarrier (cmd_buf->cmd,
564 buf_mem->barrier.parent.pipeline_stages | img_mem->barrier.
565 parent.pipeline_stages, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 1,
566 &buffer_memory_barrier, 1, &image_memory_barrier);
568 buf_mem->barrier.parent.pipeline_stages = VK_PIPELINE_STAGE_TRANSFER_BIT;
569 buf_mem->barrier.parent.access_flags = buffer_memory_barrier.dstAccessMask;
571 img_mem->barrier.parent.pipeline_stages = VK_PIPELINE_STAGE_TRANSFER_BIT;
572 img_mem->barrier.parent.access_flags = image_memory_barrier.dstAccessMask;
573 img_mem->barrier.image_layout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
575 vkCmdCopyBufferToImage (cmd_buf->cmd, buf_mem->buffer, img_mem->image,
576 img_mem->barrier.image_layout, 1, ®ion);
579 err = vkEndCommandBuffer (cmd_buf->cmd);
580 gst_vulkan_command_buffer_unlock (cmd_buf);
581 if (gst_vulkan_error_to_g_error (err, &error, "vkEndCommandBuffer") < 0)
585 VkSubmitInfo submit_info = { 0, };
586 VkPipelineStageFlags stages = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
587 GstVulkanFence *fence;
590 submit_info = (VkSubmitInfo) {
591 .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
593 .waitSemaphoreCount = 0,
594 .pWaitSemaphores = NULL,
595 .pWaitDstStageMask = &stages,
596 .commandBufferCount = 1,
597 .pCommandBuffers = &cmd_buf->cmd,
598 .signalSemaphoreCount = 0,
599 .pSignalSemaphores = NULL
603 fence = gst_vulkan_fence_new (raw->upload->device, 0, &error);
608 vkQueueSubmit (raw->upload->queue->queue, 1, &submit_info,
609 GST_VULKAN_FENCE_FENCE (fence));
610 if (gst_vulkan_error_to_g_error (err, &error, "vkQueueSubmit") < 0)
613 gst_vulkan_trash_list_add (raw->trash_list,
614 gst_vulkan_trash_new_mini_object_unref (fence,
615 GST_MINI_OBJECT_CAST (cmd_buf)));
618 gst_vulkan_trash_list_gc (raw->trash_list);
627 gst_vulkan_command_buffer_unlock (cmd_buf);
628 gst_vulkan_command_buffer_unref (cmd_buf);
632 GST_WARNING_OBJECT (raw->upload, "Error: %s", error->message);
633 g_clear_error (&error);
635 gst_clear_buffer (outbuf);
636 ret = GST_FLOW_ERROR;
641 _buffer_to_image_free (gpointer impl)
643 struct BufferToImageUpload *raw = impl;
646 if (raw->pool_active) {
647 gst_buffer_pool_set_active (raw->pool, FALSE);
649 raw->pool_active = FALSE;
650 gst_object_unref (raw->pool);
655 gst_object_unref (raw->cmd_pool);
656 raw->cmd_pool = NULL;
658 if (!gst_vulkan_trash_list_wait (raw->trash_list, -1))
659 GST_WARNING_OBJECT (raw->upload,
660 "Failed to wait for all fences to complete " "before shutting down");
661 gst_object_unref (raw->trash_list);
662 raw->trash_list = NULL;
667 static GstStaticCaps _buffer_to_image_in_templ =
668 GST_STATIC_CAPS ("video/x-raw(" GST_CAPS_FEATURE_MEMORY_VULKAN_BUFFER ")");
669 static GstStaticCaps _buffer_to_image_out_templ =
670 GST_STATIC_CAPS ("video/x-raw(" GST_CAPS_FEATURE_MEMORY_VULKAN_IMAGE ")");
672 static const struct UploadMethod buffer_to_image_upload = {
673 "BufferToVulkanImage",
674 &_buffer_to_image_in_templ,
675 &_buffer_to_image_out_templ,
676 _buffer_to_image_new_impl,
677 _buffer_to_image_transform_caps,
678 _buffer_to_image_set_caps,
679 _buffer_to_image_propose_allocation,
680 _buffer_to_image_perform,
681 _buffer_to_image_free,
684 struct RawToImageUpload
686 GstVulkanUpload *upload;
688 GstVideoInfo in_info;
689 GstVideoInfo out_info;
692 gboolean pool_active;
694 GstBufferPool *in_pool;
695 gboolean in_pool_active;
697 GstVulkanCommandPool *cmd_pool;
698 GstVulkanTrashList *trash_list;
702 _raw_to_image_new_impl (GstVulkanUpload * upload)
704 struct RawToImageUpload *raw = g_new0 (struct RawToImageUpload, 1);
706 raw->upload = upload;
707 raw->trash_list = gst_vulkan_trash_fence_list_new ();
713 _raw_to_image_transform_caps (gpointer impl, GstPadDirection direction,
718 if (direction == GST_PAD_SINK) {
720 _set_caps_features_with_passthrough (caps,
721 GST_CAPS_FEATURE_MEMORY_VULKAN_IMAGE, NULL);
724 _set_caps_features_with_passthrough (caps,
725 GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY, NULL);
732 _raw_to_image_set_caps (gpointer impl, GstCaps * in_caps, GstCaps * out_caps)
734 struct RawToImageUpload *raw = impl;
736 if (!gst_video_info_from_caps (&raw->in_info, in_caps))
739 if (!gst_video_info_from_caps (&raw->out_info, out_caps))
743 if (raw->in_pool_active) {
744 gst_buffer_pool_set_active (raw->in_pool, FALSE);
746 raw->in_pool_active = FALSE;
747 gst_object_unref (raw->in_pool);
755 _raw_to_image_propose_allocation (gpointer impl, GstQuery * decide_query,
758 /* a little trickery with the impl pointer */
759 _buffer_propose_allocation (impl, decide_query, query);
763 _raw_to_image_perform (gpointer impl, GstBuffer * inbuf, GstBuffer ** outbuf)
765 struct RawToImageUpload *raw = impl;
767 GstBuffer *in_vk_copy = NULL;
768 GstVulkanCommandBuffer *cmd_buf;
769 GError *error = NULL;
773 if (!raw->cmd_pool) {
774 if (!(raw->cmd_pool =
775 gst_vulkan_queue_create_command_pool (raw->upload->queue,
781 if (!(cmd_buf = gst_vulkan_command_pool_create (raw->cmd_pool, &error)))
785 GstStructure *config;
786 guint min = 0, max = 0;
789 raw->pool = gst_vulkan_image_buffer_pool_new (raw->upload->device);
790 config = gst_buffer_pool_get_config (raw->pool);
791 gst_buffer_pool_config_set_params (config, raw->upload->out_caps, size, min,
793 gst_buffer_pool_set_config (raw->pool, config);
795 if (!raw->pool_active) {
796 gst_buffer_pool_set_active (raw->pool, TRUE);
797 raw->pool_active = TRUE;
801 gst_buffer_pool_acquire_buffer (raw->pool, outbuf,
802 NULL)) != GST_FLOW_OK)
807 VkCommandBufferBeginInfo cmd_buf_info = {
808 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
810 .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
811 .pInheritanceInfo = NULL
815 gst_vulkan_command_buffer_lock (cmd_buf);
816 err = vkBeginCommandBuffer (cmd_buf->cmd, &cmd_buf_info);
817 if (gst_vulkan_error_to_g_error (err, &error, "vkBeginCommandBuffer") < 0)
821 for (i = 0; i < GST_VIDEO_INFO_N_PLANES (&raw->out_info); i++) {
822 VkBufferImageCopy region;
823 GstMemory *in_mem, *out_mem;
824 GstVulkanBufferMemory *buf_mem;
825 GstVulkanImageMemory *img_mem;
826 VkImageMemoryBarrier image_memory_barrier;
827 VkBufferMemoryBarrier buffer_memory_barrier;
829 in_mem = gst_buffer_peek_memory (inbuf, i);
830 if (gst_is_vulkan_buffer_memory (in_mem)) {
831 GST_TRACE_OBJECT (raw->upload, "Input is a GstVulkanBufferMemory");
832 buf_mem = (GstVulkanBufferMemory *) in_mem;
833 } else if (in_vk_copy) {
834 GST_TRACE_OBJECT (raw->upload,
835 "Have buffer copy of GstVulkanBufferMemory");
836 in_mem = gst_buffer_peek_memory (in_vk_copy, i);
837 g_assert (gst_is_vulkan_buffer_memory (in_mem));
838 buf_mem = (GstVulkanBufferMemory *) in_mem;
840 GstVideoFrame in_frame, out_frame;
842 GST_TRACE_OBJECT (raw->upload,
843 "Copying input to a new GstVulkanBufferMemory");
845 GstStructure *config;
846 guint min = 0, max = 0;
849 raw->in_pool = gst_vulkan_buffer_pool_new (raw->upload->device);
850 config = gst_buffer_pool_get_config (raw->pool);
851 gst_buffer_pool_config_set_params (config, raw->upload->in_caps, size,
853 gst_buffer_pool_set_config (raw->in_pool, config);
855 if (!raw->in_pool_active) {
856 gst_buffer_pool_set_active (raw->in_pool, TRUE);
857 raw->in_pool_active = TRUE;
861 gst_buffer_pool_acquire_buffer (raw->in_pool, &in_vk_copy,
862 NULL)) != GST_FLOW_OK) {
866 if (!gst_video_frame_map (&in_frame, &raw->in_info, inbuf, GST_MAP_READ)) {
867 GST_WARNING_OBJECT (raw->upload, "Failed to map input buffer");
871 if (!gst_video_frame_map (&out_frame, &raw->in_info, in_vk_copy,
873 gst_video_frame_unmap (&in_frame);
874 GST_WARNING_OBJECT (raw->upload, "Failed to map input buffer");
878 if (!gst_video_frame_copy (&out_frame, &in_frame)) {
879 gst_video_frame_unmap (&in_frame);
880 gst_video_frame_unmap (&out_frame);
881 GST_WARNING_OBJECT (raw->upload, "Failed to copy input buffer");
885 gst_video_frame_unmap (&in_frame);
886 gst_video_frame_unmap (&out_frame);
888 in_mem = gst_buffer_peek_memory (in_vk_copy, i);
889 buf_mem = (GstVulkanBufferMemory *) in_mem;
892 out_mem = gst_buffer_peek_memory (*outbuf, i);
893 if (!gst_is_vulkan_image_memory (out_mem)) {
894 GST_WARNING_OBJECT (raw->upload, "Output is not a GstVulkanImageMemory");
897 img_mem = (GstVulkanImageMemory *) out_mem;
900 region = (VkBufferImageCopy) {
902 .bufferRowLength = GST_VIDEO_INFO_COMP_WIDTH (&raw->in_info, i),
903 .bufferImageHeight = GST_VIDEO_INFO_COMP_HEIGHT (&raw->in_info, i),
904 .imageSubresource = {
905 .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
910 .imageOffset = { .x = 0, .y = 0, .z = 0, },
912 .width = GST_VIDEO_INFO_COMP_WIDTH (&raw->out_info, i),
913 .height = GST_VIDEO_INFO_COMP_HEIGHT (&raw->out_info, i),
918 buffer_memory_barrier = (VkBufferMemoryBarrier) {
919 .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
921 .srcAccessMask = buf_mem->barrier.parent.access_flags,
922 .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
923 /* FIXME: implement exclusive transfers */
924 .srcQueueFamilyIndex = 0,
925 .dstQueueFamilyIndex = 0,
926 .buffer = buf_mem->buffer,
927 .offset = region.bufferOffset,
928 .size = region.bufferRowLength * region.bufferImageHeight,
931 image_memory_barrier = (VkImageMemoryBarrier) {
932 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
934 .srcAccessMask = img_mem->barrier.parent.access_flags,
935 .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
936 .oldLayout = img_mem->barrier.image_layout,
937 .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
938 /* FIXME: implement exclusive transfers */
939 .srcQueueFamilyIndex = 0,
940 .dstQueueFamilyIndex = 0,
941 .image = img_mem->image,
942 .subresourceRange = img_mem->barrier.subresource_range,
946 vkCmdPipelineBarrier (cmd_buf->cmd,
947 buf_mem->barrier.parent.pipeline_stages | img_mem->barrier.
948 parent.pipeline_stages, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 1,
949 &buffer_memory_barrier, 1, &image_memory_barrier);
951 buf_mem->barrier.parent.pipeline_stages = VK_PIPELINE_STAGE_TRANSFER_BIT;
952 buf_mem->barrier.parent.access_flags = buffer_memory_barrier.dstAccessMask;
954 img_mem->barrier.parent.pipeline_stages = VK_PIPELINE_STAGE_TRANSFER_BIT;
955 img_mem->barrier.parent.access_flags = image_memory_barrier.dstAccessMask;
956 img_mem->barrier.image_layout = image_memory_barrier.newLayout;
958 vkCmdCopyBufferToImage (cmd_buf->cmd, buf_mem->buffer, img_mem->image,
959 img_mem->barrier.image_layout, 1, ®ion);
962 err = vkEndCommandBuffer (cmd_buf->cmd);
963 gst_vulkan_command_buffer_unlock (cmd_buf);
964 if (gst_vulkan_error_to_g_error (err, &error, "vkEndCommandBuffer") < 0) {
969 VkSubmitInfo submit_info = { 0, };
970 GstVulkanFence *fence;
973 submit_info = (VkSubmitInfo) {
974 .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
976 .waitSemaphoreCount = 0,
977 .pWaitSemaphores = NULL,
978 .pWaitDstStageMask = NULL,
979 .commandBufferCount = 1,
980 .pCommandBuffers = &cmd_buf->cmd,
981 .signalSemaphoreCount = 0,
982 .pSignalSemaphores = NULL,
986 fence = gst_vulkan_fence_new (raw->upload->device, 0, &error);
991 vkQueueSubmit (raw->upload->queue->queue, 1, &submit_info,
992 GST_VULKAN_FENCE_FENCE (fence));
993 if (gst_vulkan_error_to_g_error (err, &error, "vkQueueSubmit") < 0)
996 gst_vulkan_trash_list_add (raw->trash_list,
997 gst_vulkan_trash_new_mini_object_unref (fence,
998 GST_MINI_OBJECT_CAST (cmd_buf)));
1001 gst_vulkan_trash_list_gc (raw->trash_list);
1007 gst_buffer_unref (in_vk_copy);
1013 gst_vulkan_command_buffer_lock (cmd_buf);
1014 gst_vulkan_command_buffer_unref (cmd_buf);
1018 GST_WARNING_OBJECT (raw->upload, "Error: %s", error->message);
1019 g_clear_error (&error);
1021 gst_clear_buffer (outbuf);
1022 ret = GST_FLOW_ERROR;
1027 _raw_to_image_free (gpointer impl)
1029 struct RawToImageUpload *raw = impl;
1032 if (raw->pool_active) {
1033 gst_buffer_pool_set_active (raw->pool, FALSE);
1035 raw->pool_active = FALSE;
1036 gst_object_unref (raw->pool);
1041 if (raw->in_pool_active) {
1042 gst_buffer_pool_set_active (raw->in_pool, FALSE);
1044 raw->in_pool_active = FALSE;
1045 gst_object_unref (raw->in_pool);
1046 raw->in_pool = NULL;
1050 gst_object_unref (raw->cmd_pool);
1051 raw->cmd_pool = NULL;
1053 if (!gst_vulkan_trash_list_wait (raw->trash_list, -1))
1054 GST_WARNING_OBJECT (raw->upload,
1055 "Failed to wait for all fences to complete " "before shutting down");
1056 gst_object_unref (raw->trash_list);
1057 raw->trash_list = NULL;
1062 static GstStaticCaps _raw_to_image_in_templ = GST_STATIC_CAPS ("video/x-raw");
1063 static GstStaticCaps _raw_to_image_out_templ =
1064 GST_STATIC_CAPS ("video/x-raw(" GST_CAPS_FEATURE_MEMORY_VULKAN_IMAGE ")");
1066 static const struct UploadMethod raw_to_image_upload = {
1068 &_raw_to_image_in_templ,
1069 &_raw_to_image_out_templ,
1070 _raw_to_image_new_impl,
1071 _raw_to_image_transform_caps,
1072 _raw_to_image_set_caps,
1073 _raw_to_image_propose_allocation,
1074 _raw_to_image_perform,
1078 static const struct UploadMethod *upload_methods[] = {
1080 &raw_to_buffer_upload,
1081 &raw_to_image_upload,
1082 &buffer_to_image_upload,
1086 _get_input_template_caps (void)
1088 GstCaps *ret = NULL;
1091 /* FIXME: cache this and invalidate on changes to upload_methods */
1092 for (i = 0; i < G_N_ELEMENTS (upload_methods); i++) {
1093 GstCaps *template = gst_static_caps_get (upload_methods[i]->in_template);
1094 ret = ret == NULL ? template : gst_caps_merge (ret, template);
1097 ret = gst_caps_simplify (ret);
1103 _get_output_template_caps (void)
1105 GstCaps *ret = NULL;
1108 /* FIXME: cache this and invalidate on changes to upload_methods */
1109 for (i = 0; i < G_N_ELEMENTS (upload_methods); i++) {
1110 GstCaps *template = gst_static_caps_get (upload_methods[i]->out_template);
1111 ret = ret == NULL ? template : gst_caps_merge (ret, template);
1114 ret = gst_caps_simplify (ret);
1119 static void gst_vulkan_upload_finalize (GObject * object);
1120 static void gst_vulkan_upload_set_property (GObject * object, guint prop_id,
1121 const GValue * value, GParamSpec * param_spec);
1122 static void gst_vulkan_upload_get_property (GObject * object, guint prop_id,
1123 GValue * value, GParamSpec * param_spec);
1125 static gboolean gst_vulkan_upload_query (GstBaseTransform * bt,
1126 GstPadDirection direction, GstQuery * query);
1127 static void gst_vulkan_upload_set_context (GstElement * element,
1128 GstContext * context);
1129 static GstStateChangeReturn gst_vulkan_upload_change_state (GstElement *
1130 element, GstStateChange transition);
1132 static gboolean gst_vulkan_upload_set_caps (GstBaseTransform * bt,
1133 GstCaps * in_caps, GstCaps * out_caps);
1134 static GstCaps *gst_vulkan_upload_transform_caps (GstBaseTransform * bt,
1135 GstPadDirection direction, GstCaps * caps, GstCaps * filter);
1136 static gboolean gst_vulkan_upload_propose_allocation (GstBaseTransform * bt,
1137 GstQuery * decide_query, GstQuery * query);
1138 static gboolean gst_vulkan_upload_decide_allocation (GstBaseTransform * bt,
1140 static GstFlowReturn gst_vulkan_upload_transform (GstBaseTransform * bt,
1141 GstBuffer * inbuf, GstBuffer * outbuf);
1142 static GstFlowReturn gst_vulkan_upload_prepare_output_buffer (GstBaseTransform *
1143 bt, GstBuffer * inbuf, GstBuffer ** outbuf);
1156 /* static guint gst_vulkan_upload_signals[LAST_SIGNAL] = { 0 }; */
1158 #define gst_vulkan_upload_parent_class parent_class
1159 G_DEFINE_TYPE_WITH_CODE (GstVulkanUpload, gst_vulkan_upload,
1160 GST_TYPE_BASE_TRANSFORM, GST_DEBUG_CATEGORY_INIT (gst_debug_vulkan_upload,
1161 "vulkanupload", 0, "Vulkan Uploader"));
1164 gst_vulkan_upload_class_init (GstVulkanUploadClass * klass)
1166 GObjectClass *gobject_class;
1167 GstElementClass *gstelement_class;
1168 GstBaseTransformClass *gstbasetransform_class;
1170 gobject_class = (GObjectClass *) klass;
1171 gstelement_class = (GstElementClass *) klass;
1172 gstbasetransform_class = (GstBaseTransformClass *) klass;
1174 gobject_class->set_property = gst_vulkan_upload_set_property;
1175 gobject_class->get_property = gst_vulkan_upload_get_property;
1177 gst_element_class_set_metadata (gstelement_class, "Vulkan Uploader",
1178 "Filter/Video", "A Vulkan data uploader",
1179 "Matthew Waters <matthew@centricular.com>");
1184 caps = _get_input_template_caps ();
1185 gst_element_class_add_pad_template (gstelement_class,
1186 gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, caps));
1187 gst_caps_unref (caps);
1189 caps = _get_output_template_caps ();
1190 gst_element_class_add_pad_template (gstelement_class,
1191 gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS, caps));
1192 gst_caps_unref (caps);
1195 gobject_class->finalize = gst_vulkan_upload_finalize;
1197 gstelement_class->change_state = gst_vulkan_upload_change_state;
1198 gstelement_class->set_context = gst_vulkan_upload_set_context;
1199 gstbasetransform_class->query = GST_DEBUG_FUNCPTR (gst_vulkan_upload_query);
1200 gstbasetransform_class->set_caps = gst_vulkan_upload_set_caps;
1201 gstbasetransform_class->transform_caps = gst_vulkan_upload_transform_caps;
1202 gstbasetransform_class->propose_allocation =
1203 gst_vulkan_upload_propose_allocation;
1204 gstbasetransform_class->decide_allocation =
1205 gst_vulkan_upload_decide_allocation;
1206 gstbasetransform_class->transform = gst_vulkan_upload_transform;
1207 gstbasetransform_class->prepare_output_buffer =
1208 gst_vulkan_upload_prepare_output_buffer;
1212 gst_vulkan_upload_init (GstVulkanUpload * vk_upload)
1216 n = G_N_ELEMENTS (upload_methods);
1217 vk_upload->upload_impls = g_malloc (sizeof (gpointer) * n);
1218 for (i = 0; i < n; i++) {
1219 vk_upload->upload_impls[i] = upload_methods[i]->new_impl (vk_upload);
1224 gst_vulkan_upload_finalize (GObject * object)
1226 GstVulkanUpload *vk_upload = GST_VULKAN_UPLOAD (object);
1229 gst_caps_replace (&vk_upload->in_caps, NULL);
1230 gst_caps_replace (&vk_upload->out_caps, NULL);
1232 for (i = 0; i < G_N_ELEMENTS (upload_methods); i++) {
1233 upload_methods[i]->free (vk_upload->upload_impls[i]);
1235 g_free (vk_upload->upload_impls);
1236 vk_upload->upload_impls = NULL;
1238 G_OBJECT_CLASS (parent_class)->finalize (object);
1242 gst_vulkan_upload_set_property (GObject * object, guint prop_id,
1243 const GValue * value, GParamSpec * pspec)
1245 // GstVulkanUpload *vk_upload = GST_VULKAN_UPLOAD (object);
1249 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1255 gst_vulkan_upload_get_property (GObject * object, guint prop_id,
1256 GValue * value, GParamSpec * pspec)
1258 // GstVulkanUpload *vk_upload = GST_VULKAN_UPLOAD (object);
1262 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1268 gst_vulkan_upload_query (GstBaseTransform * bt, GstPadDirection direction,
1271 GstVulkanUpload *vk_upload = GST_VULKAN_UPLOAD (bt);
1273 switch (GST_QUERY_TYPE (query)) {
1274 case GST_QUERY_CONTEXT:{
1275 if (gst_vulkan_handle_context_query (GST_ELEMENT (vk_upload), query,
1276 NULL, vk_upload->instance, vk_upload->device))
1279 if (gst_vulkan_queue_handle_context_query (GST_ELEMENT (vk_upload), query,
1289 return GST_BASE_TRANSFORM_CLASS (parent_class)->query (bt, direction, query);
1293 gst_vulkan_upload_set_context (GstElement * element, GstContext * context)
1295 GstVulkanUpload *vk_upload = GST_VULKAN_UPLOAD (element);
1297 gst_vulkan_handle_set_context (element, context, NULL, &vk_upload->instance);
1299 GST_ELEMENT_CLASS (parent_class)->set_context (element, context);
1304 GstVulkanUpload *upload;
1305 GstVulkanQueue *queue;
1309 _choose_queue (GstVulkanDevice * device, GstVulkanQueue * queue,
1310 struct choose_data *data)
1313 device->physical_device->queue_family_props[queue->family].queueFlags;
1315 if ((flags & VK_QUEUE_GRAPHICS_BIT) != 0) {
1317 gst_object_unref (data->queue);
1318 data->queue = gst_object_ref (queue);
1325 static GstVulkanQueue *
1326 _find_graphics_queue (GstVulkanUpload * upload)
1328 struct choose_data data;
1330 data.upload = upload;
1333 gst_vulkan_device_foreach_queue (upload->device,
1334 (GstVulkanDeviceForEachQueueFunc) _choose_queue, &data);
1339 static GstStateChangeReturn
1340 gst_vulkan_upload_change_state (GstElement * element, GstStateChange transition)
1342 GstVulkanUpload *vk_upload = GST_VULKAN_UPLOAD (element);
1343 GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
1345 GST_DEBUG ("changing state: %s => %s",
1346 gst_element_state_get_name (GST_STATE_TRANSITION_CURRENT (transition)),
1347 gst_element_state_get_name (GST_STATE_TRANSITION_NEXT (transition)));
1349 switch (transition) {
1350 case GST_STATE_CHANGE_NULL_TO_READY:
1352 case GST_STATE_CHANGE_READY_TO_PAUSED:
1353 if (!gst_vulkan_ensure_element_data (element, NULL, &vk_upload->instance)) {
1354 GST_ELEMENT_ERROR (vk_upload, RESOURCE, NOT_FOUND,
1355 ("Failed to retreive vulkan instance"), (NULL));
1356 return GST_STATE_CHANGE_FAILURE;
1358 if (!gst_vulkan_device_run_context_query (GST_ELEMENT (vk_upload),
1359 &vk_upload->device)) {
1360 GError *error = NULL;
1361 GST_DEBUG_OBJECT (vk_upload, "No device retrieved from peer elements");
1362 if (!(vk_upload->device =
1363 gst_vulkan_instance_create_device (vk_upload->instance,
1365 GST_ELEMENT_ERROR (vk_upload, RESOURCE, NOT_FOUND,
1366 ("Failed to create vulkan device"), ("%s",
1367 error ? error->message : ""));
1368 g_clear_error (&error);
1369 return GST_STATE_CHANGE_FAILURE;
1373 if (!gst_vulkan_queue_run_context_query (GST_ELEMENT (vk_upload),
1374 &vk_upload->queue)) {
1375 GST_DEBUG_OBJECT (vk_upload, "No queue retrieved from peer elements");
1376 vk_upload->queue = _find_graphics_queue (vk_upload);
1378 if (!vk_upload->queue) {
1379 GST_ELEMENT_ERROR (vk_upload, RESOURCE, NOT_FOUND,
1380 ("Failed to create/retrieve vulkan queue"), (NULL));
1381 return GST_STATE_CHANGE_FAILURE;
1384 case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
1390 ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1391 if (ret == GST_STATE_CHANGE_FAILURE)
1394 switch (transition) {
1395 case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
1397 case GST_STATE_CHANGE_PAUSED_TO_READY:
1398 if (vk_upload->queue)
1399 gst_object_unref (vk_upload->queue);
1400 vk_upload->queue = NULL;
1401 if (vk_upload->device)
1402 gst_object_unref (vk_upload->device);
1403 vk_upload->device = NULL;
1404 if (vk_upload->instance)
1405 gst_object_unref (vk_upload->instance);
1406 vk_upload->instance = NULL;
1408 case GST_STATE_CHANGE_READY_TO_NULL:
1418 gst_vulkan_upload_transform_caps (GstBaseTransform * bt,
1419 GstPadDirection direction, GstCaps * caps, GstCaps * filter)
1421 GstVulkanUpload *vk_upload = GST_VULKAN_UPLOAD (bt);
1422 GstCaps *result, *tmp;
1425 tmp = gst_caps_new_empty ();
1427 for (i = 0; i < G_N_ELEMENTS (upload_methods); i++) {
1431 if (direction == GST_PAD_SINK) {
1432 templ = gst_static_caps_get (upload_methods[i]->in_template);
1434 templ = gst_static_caps_get (upload_methods[i]->out_template);
1436 if (!gst_caps_can_intersect (caps, templ)) {
1437 gst_caps_unref (templ);
1440 gst_caps_unref (templ);
1442 tmp2 = upload_methods[i]->transform_caps (vk_upload->upload_impls[i],
1446 tmp = gst_caps_merge (tmp, tmp2);
1450 result = gst_caps_intersect_full (filter, tmp, GST_CAPS_INTERSECT_FIRST);
1451 gst_caps_unref (tmp);
1460 gst_vulkan_upload_set_caps (GstBaseTransform * bt, GstCaps * in_caps,
1463 GstVulkanUpload *vk_upload = GST_VULKAN_UPLOAD (bt);
1464 gboolean found_method = FALSE;
1467 gst_caps_replace (&vk_upload->in_caps, in_caps);
1468 gst_caps_replace (&vk_upload->out_caps, out_caps);
1470 for (i = 0; i < G_N_ELEMENTS (upload_methods); i++) {
1473 templ = gst_static_caps_get (upload_methods[i]->in_template);
1474 if (!gst_caps_can_intersect (in_caps, templ)) {
1475 gst_caps_unref (templ);
1478 gst_caps_unref (templ);
1480 templ = gst_static_caps_get (upload_methods[i]->out_template);
1481 if (!gst_caps_can_intersect (out_caps, templ)) {
1482 gst_caps_unref (templ);
1485 gst_caps_unref (templ);
1487 if (!upload_methods[i]->set_caps (vk_upload->upload_impls[i], in_caps,
1491 GST_LOG_OBJECT (bt, "uploader %s accepted caps in: %" GST_PTR_FORMAT
1492 " out: %" GST_PTR_FORMAT, upload_methods[i]->name, in_caps, out_caps);
1494 vk_upload->current_impl = i;
1495 found_method = TRUE;
1499 GST_DEBUG_OBJECT (bt,
1500 "set caps in: %" GST_PTR_FORMAT " out: %" GST_PTR_FORMAT, in_caps,
1503 return found_method;
1507 gst_vulkan_upload_propose_allocation (GstBaseTransform * bt,
1508 GstQuery * decide_query, GstQuery * query)
1510 GstVulkanUpload *vk_upload = GST_VULKAN_UPLOAD (bt);
1513 for (i = 0; i < G_N_ELEMENTS (upload_methods); i++) {
1516 templ = gst_static_caps_get (upload_methods[i]->in_template);
1517 if (!gst_caps_can_intersect (vk_upload->in_caps, templ)) {
1518 gst_caps_unref (templ);
1521 gst_caps_unref (templ);
1523 templ = gst_static_caps_get (upload_methods[i]->out_template);
1524 if (!gst_caps_can_intersect (vk_upload->out_caps, templ)) {
1525 gst_caps_unref (templ);
1528 gst_caps_unref (templ);
1530 upload_methods[i]->propose_allocation (vk_upload->upload_impls[i],
1531 decide_query, query);
1538 gst_vulkan_upload_decide_allocation (GstBaseTransform * bt, GstQuery * query)
1544 _upload_find_method (GstVulkanUpload * vk_upload)
1546 vk_upload->current_impl++;
1548 if (vk_upload->current_impl >= G_N_ELEMENTS (upload_methods))
1551 GST_DEBUG_OBJECT (vk_upload, "attempting upload with uploader %s",
1552 upload_methods[vk_upload->current_impl]->name);
1557 static GstFlowReturn
1558 gst_vulkan_upload_prepare_output_buffer (GstBaseTransform * bt,
1559 GstBuffer * inbuf, GstBuffer ** outbuf)
1561 GstBaseTransformClass *bclass = GST_BASE_TRANSFORM_GET_CLASS (bt);
1562 GstVulkanUpload *vk_upload = GST_VULKAN_UPLOAD (bt);
1567 gpointer method_impl;
1568 const struct UploadMethod *method;
1570 method = upload_methods[vk_upload->current_impl];
1571 method_impl = vk_upload->upload_impls[vk_upload->current_impl];
1573 ret = method->perform (method_impl, inbuf, outbuf);
1574 if (ret != GST_FLOW_OK) {
1576 if (!_upload_find_method (vk_upload)) {
1577 GST_ELEMENT_ERROR (bt, RESOURCE, NOT_FOUND,
1578 ("Could not find suitable uploader"), (NULL));
1579 return GST_FLOW_ERROR;
1582 method = upload_methods[vk_upload->current_impl];
1583 method_impl = vk_upload->upload_impls[vk_upload->current_impl];
1584 if (!method->set_caps (method_impl, vk_upload->in_caps,
1585 vk_upload->out_caps))
1586 /* try the next method */
1589 /* try the uploading with the next method */
1594 if (ret == GST_FLOW_OK) {
1595 /* basetransform doesn't unref if they're the same */
1596 if (inbuf != *outbuf)
1597 bclass->copy_metadata (bt, inbuf, *outbuf);
1603 static GstFlowReturn
1604 gst_vulkan_upload_transform (GstBaseTransform * bt, GstBuffer * inbuf,