vulkan_image.h 7.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199
  1. // Copyright 2020 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #ifndef GPU_VULKAN_VULKAN_IMAGE_H_
  5. #define GPU_VULKAN_VULKAN_IMAGE_H_
  6. #include <vulkan/vulkan_core.h>
  7. #include <array>
  8. #include <vector>
  9. #include "base/component_export.h"
  10. #include "base/files/scoped_file.h"
  11. #include "base/memory/raw_ptr.h"
  12. #include "base/types/pass_key.h"
  13. #include "build/build_config.h"
  14. #include "gpu/ipc/common/vulkan_ycbcr_info.h"
  15. #include "third_party/abseil-cpp/absl/types/optional.h"
  16. #include "ui/gfx/geometry/size.h"
  17. #include "ui/gfx/gpu_memory_buffer.h"
  18. #include "ui/gfx/native_pixmap.h"
  19. #if BUILDFLAG(IS_WIN)
  20. #include "base/win/scoped_handle.h"
  21. #endif
  22. #if BUILDFLAG(IS_FUCHSIA)
  23. #include <lib/zx/vmo.h>
  24. #endif
  25. namespace gpu {
  26. class VulkanDeviceQueue;
  27. class COMPONENT_EXPORT(VULKAN) VulkanImage {
  28. public:
  29. explicit VulkanImage(base::PassKey<VulkanImage> pass_key);
  30. ~VulkanImage();
  31. VulkanImage(VulkanImage&) = delete;
  32. VulkanImage& operator=(VulkanImage&) = delete;
  33. static std::unique_ptr<VulkanImage> Create(
  34. VulkanDeviceQueue* device_queue,
  35. const gfx::Size& size,
  36. VkFormat format,
  37. VkImageUsageFlags usage,
  38. VkImageCreateFlags flags = 0,
  39. VkImageTiling image_tiling = VK_IMAGE_TILING_OPTIMAL,
  40. void* vk_image_create_info_next = nullptr,
  41. void* vk_memory_allocation_info_next = nullptr);
  42. // Create VulkanImage with external memory, it can be exported and used by
  43. // foreign API
  44. static std::unique_ptr<VulkanImage> CreateWithExternalMemory(
  45. VulkanDeviceQueue* device_queue,
  46. const gfx::Size& size,
  47. VkFormat format,
  48. VkImageUsageFlags usage,
  49. VkImageCreateFlags flags = 0,
  50. VkImageTiling image_tiling = VK_IMAGE_TILING_OPTIMAL,
  51. void* image_create_info_next = nullptr,
  52. void* memory_allocation_info_next = nullptr);
  53. static std::unique_ptr<VulkanImage> CreateFromGpuMemoryBufferHandle(
  54. VulkanDeviceQueue* device_queue,
  55. gfx::GpuMemoryBufferHandle gmb_handle,
  56. const gfx::Size& size,
  57. VkFormat format,
  58. VkImageUsageFlags usage,
  59. VkImageCreateFlags flags,
  60. VkImageTiling image_tiling,
  61. uint32_t queue_family_index);
  62. static std::unique_ptr<VulkanImage> Create(
  63. VulkanDeviceQueue* device_queue,
  64. VkImage image,
  65. VkDeviceMemory device_memory,
  66. const gfx::Size& size,
  67. VkFormat format,
  68. VkImageTiling image_tiling,
  69. VkDeviceSize device_size,
  70. uint32_t memory_type_index,
  71. absl::optional<VulkanYCbCrInfo>& ycbcr_info,
  72. VkImageUsageFlags usage,
  73. VkImageCreateFlags flags);
  74. #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
  75. static std::unique_ptr<VulkanImage> CreateWithExternalMemoryAndModifiers(
  76. VulkanDeviceQueue* device_queue,
  77. const gfx::Size& size,
  78. VkFormat format,
  79. std::vector<uint64_t> modifiers,
  80. VkImageUsageFlags usage,
  81. VkImageCreateFlags flags);
  82. #endif
  83. void Destroy();
  84. #if BUILDFLAG(IS_POSIX)
  85. base::ScopedFD GetMemoryFd(VkExternalMemoryHandleTypeFlagBits handle_type =
  86. VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT);
  87. #endif
  88. #if BUILDFLAG(IS_WIN)
  89. base::win::ScopedHandle GetMemoryHandle(
  90. VkExternalMemoryHandleTypeFlagBits handle_type =
  91. VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT);
  92. #endif
  93. #if BUILDFLAG(IS_FUCHSIA)
  94. zx::vmo GetMemoryZirconHandle();
  95. #endif
  96. VulkanDeviceQueue* device_queue() const { return device_queue_; }
  97. const VkImageCreateInfo& create_info() const { return create_info_; }
  98. gfx::Size size() const {
  99. return gfx::Size(create_info_.extent.width, create_info_.extent.height);
  100. }
  101. VkFormat format() const { return create_info_.format; }
  102. VkImageCreateFlags flags() const { return create_info_.flags; }
  103. VkImageUsageFlags usage() const { return create_info_.usage; }
  104. VkDeviceSize device_size() const { return device_size_; }
  105. uint32_t memory_type_index() const { return memory_type_index_; }
  106. VkImageTiling image_tiling() const { return create_info_.tiling; }
  107. uint32_t queue_family_index() const { return queue_family_index_; }
  108. void set_queue_family_index(uint32_t index) { queue_family_index_ = index; }
  109. const absl::optional<VulkanYCbCrInfo>& ycbcr_info() const {
  110. return ycbcr_info_;
  111. }
  112. VkImage image() const { return image_; }
  113. VkDeviceMemory device_memory() const { return device_memory_; }
  114. VkExternalMemoryHandleTypeFlags handle_types() const { return handle_types_; }
  115. void set_native_pixmap(scoped_refptr<gfx::NativePixmap> pixmap) {
  116. native_pixmap_ = std::move(pixmap);
  117. }
  118. const scoped_refptr<gfx::NativePixmap>& native_pixmap() const {
  119. return native_pixmap_;
  120. }
  121. uint64_t modifier() const { return modifier_; }
  122. size_t plane_count() const { return plane_count_; }
  123. const std::array<VkSubresourceLayout, 4>& layouts() const { return layouts_; }
  124. private:
  125. bool Initialize(VulkanDeviceQueue* device_queue,
  126. const gfx::Size& size,
  127. VkFormat format,
  128. VkImageUsageFlags usage,
  129. VkImageCreateFlags flags,
  130. VkImageTiling image_tiling,
  131. void* image_create_info_next,
  132. void* memory_allocation_info_next,
  133. const VkMemoryRequirements* requirements);
  134. bool InitializeWithExternalMemory(VulkanDeviceQueue* device_queue,
  135. const gfx::Size& size,
  136. VkFormat format,
  137. VkImageUsageFlags usage,
  138. VkImageCreateFlags flags,
  139. VkImageTiling image_tiling,
  140. void* image_create_info_next,
  141. void* memory_allocation_info_next);
  142. bool InitializeFromGpuMemoryBufferHandle(
  143. VulkanDeviceQueue* device_queue,
  144. gfx::GpuMemoryBufferHandle gmb_handle,
  145. const gfx::Size& size,
  146. VkFormat format,
  147. VkImageUsageFlags usage,
  148. VkImageCreateFlags flags,
  149. VkImageTiling image_tiling,
  150. uint32_t queue_family_index);
  151. #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
  152. bool InitializeWithExternalMemoryAndModifiers(VulkanDeviceQueue* device_queue,
  153. const gfx::Size& size,
  154. VkFormat format,
  155. std::vector<uint64_t> modifiers,
  156. VkImageUsageFlags usage,
  157. VkImageCreateFlags flags);
  158. #endif
  159. raw_ptr<VulkanDeviceQueue> device_queue_ = nullptr;
  160. VkImageCreateInfo create_info_{VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
  161. VkDeviceSize device_size_ = 0;
  162. uint32_t memory_type_index_ = 0;
  163. uint32_t queue_family_index_ = VK_QUEUE_FAMILY_IGNORED;
  164. absl::optional<VulkanYCbCrInfo> ycbcr_info_;
  165. VkImage image_ = VK_NULL_HANDLE;
  166. VkDeviceMemory device_memory_ = VK_NULL_HANDLE;
  167. VkExternalMemoryHandleTypeFlags handle_types_ = 0;
  168. scoped_refptr<gfx::NativePixmap> native_pixmap_;
  169. uint64_t modifier_ = gfx::NativePixmapHandle::kNoModifier;
  170. size_t plane_count_ = 1;
  171. std::array<VkSubresourceLayout, 4> layouts_ = {};
  172. };
  173. } // namespace gpu
  174. #endif // GPU_VULKAN_VULKAN_IMAGE_H_