wsi/wayland/swapchain.hpp

   1 /*
   2  * Copyright (c) 2017-2019, 2021 Arm Limited.
   3  *
   4  * SPDX-License-Identifier: MIT
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to
   8  * deal in the Software without restriction, including without limitation the
   9  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  10  * sell copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in all
  14  * copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  */
  24
  25 #pragma once
  26
  27 #include "wsi/swapchain_base.hpp"
  28
  29 extern "C" {
  30 #include <vulkan/vk_icd.h>
  31 }
  32
  33 #include <wayland-client.h>
  34 #include <linux-dmabuf-unstable-v1-client-protocol.h>
  35 #include "util/wsialloc/wsialloc.h"
  36 #include "wl_object_owner.hpp"
  37
  38 namespace wsi
  39 {
  40 namespace wayland
  41 {
  42
  43 class swapchain : public wsi::swapchain_base
  44 {
  45 public:
  46    explicit swapchain(layer::device_private_data &dev_data, const VkAllocationCallbacks *allocator);
  47
  48    ~swapchain();
  49
  50    /* TODO: make the buffer destructor a friend? so this can be protected */
  51    void release_buffer(struct wl_buffer *wl_buffer);
  52
  53 protected:
  54    /**
  55     * @brief Initialize platform specifics.
  56     */
  57    VkResult init_platform(VkDevice device, const VkSwapchainCreateInfoKHR *pSwapchainCreateInfo) override;
  58
  59    /**
  60     * @brief Creates a new swapchain image.
  61     *
  62     * @param image_create_info Data to be used to create the image.
  63     *
  64     * @param image Handle to the image.
  65     *
  66     * @return If image creation is successful returns VK_SUCCESS, otherwise
  67     * will return VK_ERROR_OUT_OF_DEVICE_MEMORY or VK_ERROR_INITIALIZATION_FAILED
  68     * depending on the error that occurred.
  69     */
  70    VkResult create_image(VkImageCreateInfo image_create_info, swapchain_image &image) override;
  71
  72    /**
  73     * @brief Method to present an image
  74     *
  75     * @param pendingIndex Index of the pending image to be presented.
  76     */
  77    void present_image(uint32_t pendingIndex) override;
  78
  79    /**
  80     * @brief Method to release a swapchain image
  81     *
  82     * @param image Handle to the image about to be released.
  83     */
  84    void destroy_image(swapchain_image &image) override;
  85
  86    /**
  87     * @brief Method to check if there are any free images
  88     *
  89     * @return true if any images are free, otherwise false.
  90     */
  91    bool free_image_found();
  92
  93    /**
  94     * @brief Hook for any actions to free up a buffer for acquire
  95     *
  96     * @param[in,out] timeout time to wait, in nanoseconds. 0 doesn't block,
  97     *                        UINT64_MAX waits indefinitely. The timeout should
  98     *                        be updated if a sleep is required - this can
  99     *                        be set to 0 if the semaphore is now not expected
 100     *                        block.
 101     */
 102    VkResult get_free_buffer(uint64_t *timeout) override;
 103
 104 private:
 105    struct wayland_image_data;
 106
 107    VkResult allocate_image(VkImageCreateInfo &image_create_info, wayland_image_data *image_data, VkImage *image);
 108
 109    struct wl_display *m_display;
 110    struct wl_surface *m_surface;
 111    zwp_linux_dmabuf_v1_owner m_dmabuf_interface;
 112
 113    /* The queue on which we dispatch the swapchain related events, mostly frame completion */
 114    struct wl_event_queue *m_surface_queue;
 115    /* The queue on which we dispatch buffer related events, mostly buffer_release */
 116    struct wl_event_queue *m_buffer_queue;
 117
 118    /**
 119     * @brief Handle to the WSI allocator.
 120     */
 121    wsialloc_allocator *m_wsi_allocator;
 122
 123    /**
 124     * @brief true when waiting for the server hint to present a buffer
 125     *
 126     * true if a buffer has been presented and we've not had a wl_surface::frame
 127     * callback to indicate the server is ready for the next buffer.
 128     */
 129    bool m_present_pending;
 130
 131    /*
 132     * @brief Allocate memory for an image plane.
 133     *
 134     * Allocates a VkDeviceMemory object from a given fd for an image plane. First
 135     * it makes a call to get_fd_mem_type_index() to acquire the memory type for
 136     * the given fd and then it allocates device memory by calling vkAllocateMemory().
 137     *
 138     * @param      fd     The plane's fd.
 139     * @param[out] memory The allocated VkDeviceMemory object.
 140     *
 141     * @return VK_SUCCESS on success. If one of the functions that are being called
 142     * fails its return value is returned. VK_ERROR_OUT_OF_HOST_MEMORY is returned
 143     * when the host gets out of memory.
 144     */
 145    VkResult allocate_plane_memory(int fd, VkDeviceMemory *memory);
 146
 147    /*
 148     * @brief Get the memory type which the specified file descriptor can be
 149     * imported as.
 150     *
 151     * @param      fd      The given fd.
 152     * @param[out] mem_idx The index of the supported memory type.
 153     *
 154     * @return VK_SUCCESS on success. On failure the error value of
 155     * vkGetMemoryFdPropertiesKHR is returned.
 156     */
 157    VkResult get_fd_mem_type_index(int fd, uint32_t &mem_idx);
 158
 159    /*
 160     * @brief Get the properties a format has when combined with a DRM modifier.
 161     *
 162     * @param      format            The target format.
 163     * @param[out] format_props_list A vector which will store the supported properties
 164     *                               for every modifier.
 165     *
 166     * @return VK_SUCCESS on success. VK_ERROR_OUT_OF_HOST_MEMORY is returned when
 167     * the host gets out of memory.
 168     */
 169    VkResult get_drm_format_properties(
 170       VkFormat format, util::vector<VkDrmFormatModifierPropertiesEXT> &format_props_list);
 171 };
 172 } // namespace wayland
 173 } // namespace wsi