vo_gpu: vulkan: use libplacebo instead

This commit rips out the entire mpv vulkan implementation in favor of
exposing lightweight wrappers on top of libplacebo instead, which
provides much of the same except in a more up-to-date and polished form.

This (finally) unifies the code base between mpv and libplacebo, which
is something I've been hoping to do for a long time.

Note: The ra_pl wrappers are abstract enough from the actual libplacebo
device type that we can in theory re-use them for other devices like
d3d11 or even opengl in the future, so I moved them to a separate
directory for the time being. However, the rest of the code is still
vulkan-specific, so I've kept the "vulkan" naming and file paths, rather
than introducing a new `--gpu-api` type. (Which would have been ended up
with significantly more code duplicaiton)

Plus, the code and functionality is similar enough that for most users
this should just be a straight-up drop-in replacement.

Note: This commit excludes some changes; specifically, the updates to
context_win and hwdec_cuda are deferred to separate commits for
authorship reasons.

1 files changed, 0 insertions, 471 deletions

diff --git a/video/out/vulkan/malloc.c b/video/out/vulkan/malloc.c
deleted file mode 100644
index e1e7ae28e6..0000000000
--- a/video/out/vulkan/malloc.c
+++ /dev/null
@@ -1,471 +0,0 @@
-#include "malloc.h"
-#include "utils.h"
-#include "osdep/timer.h"
-
-#if HAVE_WIN32_DESKTOP
-#include <versionhelpers.h>
-#endif
-
-// Controls the multiplication factor for new slab allocations. The new slab
-// will always be allocated such that the size of the slab is this factor times
-// the previous slab. Higher values make it grow faster.
-#define MPVK_HEAP_SLAB_GROWTH_RATE 4
-
-// Controls the minimum slab size, to reduce the frequency at which very small
-// slabs would need to get allocated when allocating the first few buffers.
-// (Default: 1 MB)
-#define MPVK_HEAP_MINIMUM_SLAB_SIZE (1 << 20)
-
-// Controls the maximum slab size, to reduce the effect of unbounded slab
-// growth exhausting memory. If the application needs a single allocation
-// that's bigger than this value, it will be allocated directly from the
-// device. (Default: 512 MB)
-#define MPVK_HEAP_MAXIMUM_SLAB_SIZE (1 << 29)
-
-// Controls the minimum free region size, to reduce thrashing the free space
-// map with lots of small buffers during uninit. (Default: 1 KB)
-#define MPVK_HEAP_MINIMUM_REGION_SIZE (1 << 10)
-
-// Represents a region of available memory
-struct vk_region {
-    size_t start; // first offset in region
-    size_t end;   // first offset *not* in region
-};
-
-static inline size_t region_len(struct vk_region r)
-{
-    return r.end - r.start;
-}
-
-// A single slab represents a contiguous region of allocated memory. Actual
-// allocations are served as slices of this. Slabs are organized into linked
-// lists, which represent individual heaps.
-struct vk_slab {
-    VkDeviceMemory mem;   // underlying device allocation
-    size_t size;          // total size of `slab`
-    size_t used;          // number of bytes actually in use (for GC accounting)
-    bool dedicated;       // slab is allocated specifically for one object
-    // free space map: a sorted list of memory regions that are available
-    struct vk_region *regions;
-    int num_regions;
-    // optional, depends on the memory type:
-    VkBuffer buffer;      // buffer spanning the entire slab
-    void *data;           // mapped memory corresponding to `mem`
-};
-
-// Represents a single memory heap. We keep track of a vk_heap for each
-// combination of buffer type and memory selection parameters. This shouldn't
-// actually be that many in practice, because some combinations simply never
-// occur, and others will generally be the same for the same objects.
-struct vk_heap {
-    VkBufferUsageFlags usage;    // the buffer usage type (or 0)
-    VkMemoryPropertyFlags flags; // the memory type flags (or 0)
-    uint32_t typeBits;           // the memory type index requirements (or 0)
-    bool exportable;             // whether memory is exportable to other APIs
-    struct vk_slab **slabs;      // array of slabs sorted by size
-    int num_slabs;
-};
-
-// The overall state of the allocator, which keeps track of a vk_heap for each
-// memory type.
-struct vk_malloc {
-    VkPhysicalDeviceMemoryProperties props;
-    struct vk_heap *heaps;
-    int num_heaps;
-};
-
-static void slab_free(struct mpvk_ctx *vk, struct vk_slab *slab)
-{
-    if (!slab)
-        return;
-
-    assert(slab->used == 0);
-
-    int64_t start = mp_time_us();
-    vkDestroyBuffer(vk->dev, slab->buffer, MPVK_ALLOCATOR);
-    // also implicitly unmaps the memory if needed
-    vkFreeMemory(vk->dev, slab->mem, MPVK_ALLOCATOR);
-    int64_t stop = mp_time_us();
-
-    MP_VERBOSE(vk, "Freeing slab of size %zu took %lld μs.\n",
-               slab->size, (long long)(stop - start));
-
-    talloc_free(slab);
-}
-
-static bool find_best_memtype(struct mpvk_ctx *vk, uint32_t typeBits,
-                              VkMemoryPropertyFlags flags,
-                              VkMemoryType *out_type, int *out_index)
-{
-    struct vk_malloc *ma = vk->alloc;
-
-    // The vulkan spec requires memory types to be sorted in the "optimal"
-    // order, so the first matching type we find will be the best/fastest one.
-    for (int i = 0; i < ma->props.memoryTypeCount; i++) {
-        // The memory type flags must include our properties
-        if ((ma->props.memoryTypes[i].propertyFlags & flags) != flags)
-            continue;
-        // The memory type must be supported by the requirements (bitfield)
-        if (typeBits && !(typeBits & (1 << i)))
-            continue;
-        *out_type = ma->props.memoryTypes[i];
-        *out_index = i;
-        return true;
-    }
-
-    MP_ERR(vk, "Found no memory type matching property flags 0x%x and type "
-               "bits 0x%x!\n", (unsigned)flags, (unsigned)typeBits);
-    return false;
-}
-
-static struct vk_slab *slab_alloc(struct mpvk_ctx *vk, struct vk_heap *heap,
-                                  size_t size)
-{
-    struct vk_slab *slab = talloc_ptrtype(NULL, slab);
-    *slab = (struct vk_slab) {
-        .size = size,
-    };
-
-    MP_TARRAY_APPEND(slab, slab->regions, slab->num_regions, (struct vk_region) {
-        .start = 0,
-        .end   = slab->size,
-    });
-
-    VkExportMemoryAllocateInfoKHR eminfo = {
-        .sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR,
-#if HAVE_WIN32_DESKTOP
-        .handleTypes = IsWindows8OrGreater()
-		? VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
-		: VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,
-#else
-        .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
-#endif
-    };
-
-    VkMemoryAllocateInfo minfo = {
-        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
-        .pNext = heap->exportable ? &eminfo : NULL,
-        .allocationSize = slab->size,
-    };
-
-    uint32_t typeBits = heap->typeBits ? heap->typeBits : UINT32_MAX;
-    if (heap->usage) {
-        // FIXME: Since we can't keep track of queue family ownership properly,
-        // and we don't know in advance what types of queue families this buffer
-        // will belong to, we're forced to share all of our buffers between all
-        // command pools.
-        uint32_t qfs[3] = {0};
-        for (int i = 0; i < vk->num_pools; i++)
-            qfs[i] = vk->pools[i]->qf;
-
-        VkExternalMemoryBufferCreateInfoKHR ebinfo = {
-            .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR,
-            .handleTypes = eminfo.handleTypes,
-        };
-
-        VkBufferCreateInfo binfo = {
-            .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-            .pNext = heap->exportable ? &ebinfo : NULL,
-            .size  = slab->size,
-            .usage = heap->usage,
-            .sharingMode = vk->num_pools > 1 ? VK_SHARING_MODE_CONCURRENT
-                                             : VK_SHARING_MODE_EXCLUSIVE,
-            .queueFamilyIndexCount = vk->num_pools,
-            .pQueueFamilyIndices = qfs,
-        };
-
-        VK(vkCreateBuffer(vk->dev, &binfo, MPVK_ALLOCATOR, &slab->buffer));
-
-        VkMemoryRequirements reqs;
-        vkGetBufferMemoryRequirements(vk->dev, slab->buffer, &reqs);
-        minfo.allocationSize = reqs.size; // this can be larger than slab->size
-        typeBits &= reqs.memoryTypeBits;  // this can restrict the types
-    }
-
-    VkMemoryType type;
-    int index;
-    if (!find_best_memtype(vk, typeBits, heap->flags, &type, &index))
-        goto error;
-
-    MP_VERBOSE(vk, "Allocating %zu memory of type 0x%x (id %d) in heap %d.\n",
-               slab->size, (unsigned)type.propertyFlags, index, (int)type.heapIndex);
-
-    minfo.memoryTypeIndex = index;
-    VK(vkAllocateMemory(vk->dev, &minfo, MPVK_ALLOCATOR, &slab->mem));
-
-    if (heap->flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
-        VK(vkMapMemory(vk->dev, slab->mem, 0, VK_WHOLE_SIZE, 0, &slab->data));
-
-    if (slab->buffer)
-        VK(vkBindBufferMemory(vk->dev, slab->buffer, slab->mem, 0));
-
-    return slab;
-
-error:
-    slab_free(vk, slab);
-    return NULL;
-}
-
-static void insert_region(struct vk_slab *slab, struct vk_region region)
-{
-    if (region.start == region.end)
-        return;
-
-    bool big_enough = region_len(region) >= MPVK_HEAP_MINIMUM_REGION_SIZE;
-
-    // Find the index of the first region that comes after this
-    for (int i = 0; i < slab->num_regions; i++) {
-        struct vk_region *r = &slab->regions[i];
-
-        // Check for a few special cases which can be coalesced
-        if (r->end == region.start) {
-            // The new region is at the tail of this region. In addition to
-            // modifying this region, we also need to coalesce all the following
-            // regions for as long as possible
-            r->end = region.end;
-
-            struct vk_region *next = &slab->regions[i+1];
-            while (i+1 < slab->num_regions && r->end == next->start) {
-                r->end = next->end;
-                MP_TARRAY_REMOVE_AT(slab->regions, slab->num_regions, i+1);
-            }
-            return;
-        }
-
-        if (r->start == region.end) {
-            // The new region is at the head of this region. We don't need to
-            // do anything special here - because if this could be further
-            // coalesced backwards, the previous loop iteration would already
-            // have caught it.
-            r->start = region.start;
-            return;
-        }
-
-        if (r->start > region.start) {
-            // The new region comes somewhere before this region, so insert
-            // it into this index in the array.
-            if (big_enough) {
-                MP_TARRAY_INSERT_AT(slab, slab->regions, slab->num_regions,
-                                    i, region);
-            }
-            return;
-        }
-    }
-
-    // If we've reached the end of this loop, then all of the regions
-    // come before the new region, and are disconnected - so append it
-    if (big_enough)
-        MP_TARRAY_APPEND(slab, slab->regions, slab->num_regions, region);
-}
-
-static void heap_uninit(struct mpvk_ctx *vk, struct vk_heap *heap)
-{
-    for (int i = 0; i < heap->num_slabs; i++)
-        slab_free(vk, heap->slabs[i]);
-
-    talloc_free(heap->slabs);
-    *heap = (struct vk_heap){0};
-}
-
-void vk_malloc_init(struct mpvk_ctx *vk)
-{
-    assert(vk->physd);
-    vk->alloc = talloc_zero(NULL, struct vk_malloc);
-    vkGetPhysicalDeviceMemoryProperties(vk->physd, &vk->alloc->props);
-}
-
-void vk_malloc_uninit(struct mpvk_ctx *vk)
-{
-    struct vk_malloc *ma = vk->alloc;
-    if (!ma)
-        return;
-
-    for (int i = 0; i < ma->num_heaps; i++)
-        heap_uninit(vk, &ma->heaps[i]);
-
-    talloc_free(ma);
-    vk->alloc = NULL;
-}
-
-void vk_free_memslice(struct mpvk_ctx *vk, struct vk_memslice slice)
-{
-    struct vk_slab *slab = slice.priv;
-    if (!slab)
-        return;
-
-    assert(slab->used >= slice.size);
-    slab->used -= slice.size;
-
-    MP_DBG(vk, "Freeing slice %zu + %zu from slab with size %zu\n",
-           slice.offset, slice.size, slab->size);
-
-    if (slab->dedicated) {
-        // If the slab was purpose-allocated for this memslice, we can just
-        // free it here
-        slab_free(vk, slab);
-    } else {
-        // Return the allocation to the free space map
-        insert_region(slab, (struct vk_region) {
-            .start = slice.offset,
-            .end   = slice.offset + slice.size,
-        });
-    }
-}
-
-// reqs: can be NULL
-static struct vk_heap *find_heap(struct mpvk_ctx *vk, VkBufferUsageFlags usage,
-                                 VkMemoryPropertyFlags flags,
-                                 VkMemoryRequirements *reqs,
-                                 bool exportable)
-{
-    struct vk_malloc *ma = vk->alloc;
-    int typeBits = reqs ? reqs->memoryTypeBits : 0;
-
-    for (int i = 0; i < ma->num_heaps; i++) {
-        if (ma->heaps[i].usage != usage)
-            continue;
-        if (ma->heaps[i].flags != flags)
-            continue;
-        if (ma->heaps[i].typeBits != typeBits)
-            continue;
-        if (ma->heaps[i].exportable != exportable)
-            continue;
-        return &ma->heaps[i];
-    }
-
-    // Not found => add it
-    MP_TARRAY_GROW(ma, ma->heaps, ma->num_heaps + 1);
-    struct vk_heap *heap = &ma->heaps[ma->num_heaps++];
-    *heap = (struct vk_heap) {
-        .usage    = usage,
-        .flags    = flags,
-        .typeBits = typeBits,
-        .exportable = exportable,
-    };
-    return heap;
-}
-
-static inline bool region_fits(struct vk_region r, size_t size, size_t align)
-{
-    return MP_ALIGN_UP(r.start, align) + size <= r.end;
-}
-
-// Finds the best-fitting region in a heap. If the heap is too small or too
-// fragmented, a new slab will be allocated under the hood.
-static bool heap_get_region(struct mpvk_ctx *vk, struct vk_heap *heap,
-                            size_t size, size_t align,
-                            struct vk_slab **out_slab, int *out_index)
-{
-    struct vk_slab *slab = NULL;
-
-    // If the allocation is very big, serve it directly instead of bothering
-    // with the heap
-    if (size > MPVK_HEAP_MAXIMUM_SLAB_SIZE) {
-        slab = slab_alloc(vk, heap, size);
-        *out_slab = slab;
-        *out_index = 0;
-        return !!slab;
-    }
-
-    for (int i = 0; i < heap->num_slabs; i++) {
-        slab = heap->slabs[i];
-        if (slab->size < size)
-            continue;
-
-        // Attempt a best fit search
-        int best = -1;
-        for (int n = 0; n < slab->num_regions; n++) {
-            struct vk_region r = slab->regions[n];
-            if (!region_fits(r, size, align))
-                continue;
-            if (best >= 0 && region_len(r) > region_len(slab->regions[best]))
-                continue;
-            best = n;
-        }
-
-        if (best >= 0) {
-            *out_slab = slab;
-            *out_index = best;
-            return true;
-        }
-    }
-
-    // Otherwise, allocate a new vk_slab and append it to the list.
-    size_t cur_size = MPMAX(size, slab ? slab->size : 0);
-    size_t slab_size = MPVK_HEAP_SLAB_GROWTH_RATE * cur_size;
-    slab_size = MPMAX(MPVK_HEAP_MINIMUM_SLAB_SIZE, slab_size);
-    slab_size = MPMIN(MPVK_HEAP_MAXIMUM_SLAB_SIZE, slab_size);
-    assert(slab_size >= size);
-    slab = slab_alloc(vk, heap, slab_size);
-    if (!slab)
-        return false;
-    MP_TARRAY_APPEND(NULL, heap->slabs, heap->num_slabs, slab);
-
-    // Return the only region there is in a newly allocated slab
-    assert(slab->num_regions == 1);
-    *out_slab = slab;
-    *out_index = 0;
-    return true;
-}
-
-static bool slice_heap(struct mpvk_ctx *vk, struct vk_heap *heap, size_t size,
-                       size_t alignment, struct vk_memslice *out)
-{
-    struct vk_slab *slab;
-    int index;
-    alignment = MP_ALIGN_UP(alignment, vk->limits.bufferImageGranularity);
-    if (!heap_get_region(vk, heap, size, alignment, &slab, &index))
-        return false;
-
-    struct vk_region reg = slab->regions[index];
-    MP_TARRAY_REMOVE_AT(slab->regions, slab->num_regions, index);
-    *out = (struct vk_memslice) {
-        .vkmem = slab->mem,
-        .offset = MP_ALIGN_UP(reg.start, alignment),
-        .size = size,
-        .slab_size = slab->size,
-        .priv = slab,
-    };
-
-    MP_DBG(vk, "Sub-allocating slice %zu + %zu from slab with size %zu\n",
-           out->offset, out->size, slab->size);
-
-    size_t out_end = out->offset + out->size;
-    insert_region(slab, (struct vk_region) { reg.start, out->offset });
-    insert_region(slab, (struct vk_region) { out_end, reg.end });
-
-    slab->used += size;
-    return true;
-}
-
-bool vk_malloc_generic(struct mpvk_ctx *vk, VkMemoryRequirements reqs,
-                       VkMemoryPropertyFlags flags, struct vk_memslice *out)
-{
-    struct vk_heap *heap = find_heap(vk, 0, flags, &reqs, false);
-    return slice_heap(vk, heap, reqs.size, reqs.alignment, out);
-}
-
-bool vk_malloc_buffer(struct mpvk_ctx *vk, VkBufferUsageFlags bufFlags,
-                      VkMemoryPropertyFlags memFlags, VkDeviceSize size,
-                      VkDeviceSize alignment, bool exportable,
-                      struct vk_bufslice *out)
-{
-    if (exportable) {
-        if (!vk->has_ext_external_memory_export) {
-            MP_ERR(vk, "Exportable memory requires the %s extension\n",
-                   MP_VK_EXTERNAL_MEMORY_EXPORT_EXTENSION_NAME);
-            return false;
-        }
-    }
-
-    struct vk_heap *heap = find_heap(vk, bufFlags, memFlags, NULL, exportable);
-    if (!slice_heap(vk, heap, size, alignment, &out->mem))
-        return false;
-
-    struct vk_slab *slab = out->mem.priv;
-    out->buf = slab->buffer;
-    if (slab->data)
-        out->data = (void *)((uintptr_t)slab->data + (ptrdiff_t)out->mem.offset);
-
-    return true;
-}