/root/firefox-clang/media/ffvpx/libavutil/vulkan.c

Bug Summary

File:	root/firefox-clang/media/ffvpx/libavutil/vulkan.c
Warning:	line 338, column 13 Access to field 'sem' results in a dereference of a null pointer (loaded from variable 'e')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -O2 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name vulkan.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/media/ffvpx/libavutil -fcoverage-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/media/ffvpx/libavutil -resource-dir /usr/lib/llvm-23/lib/clang/23 -include /root/firefox-clang/obj-x86_64-pc-linux-gnu/mozilla-config.h -include libavutil_visibility.h -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D DEBUG=1 -D HAVE_AV_CONFIG_H -D ASSERT_LEVEL=2 -I /root/firefox-clang/media/ffvpx/libavutil -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/media/ffvpx/libavutil -I /root/firefox-clang/third_party/khronos/vulkan-headers/include -I /root/firefox-clang/media/mozva -I /root/firefox-clang/third_party/drm/drm -I /root/firefox-clang/third_party/drm/drm/include -I /root/firefox-clang/third_party/drm/drm/include/libdrm -I /root/firefox-clang/media/ffvpx -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -internal-isystem /usr/lib/llvm-23/lib/clang/23/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wno-error=tautological-type-limit-compare -Wno-range-loop-analysis -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-unknown-warning-option -Wno-character-conversion -Wno-parentheses -Wno-pointer-sign -Wno-sign-compare -Wno-switch -Wno-type-limits -Wno-unused-function -Wno-deprecated-declarations -Wno-absolute-value -Wno-incompatible-pointer-types -Wno-string-conversion -Wno-visibility -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fdiagnostics-absolute-paths -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -mllvm -dwarf-linkage-names=Abstract -faddrsig -fdwarf2-cfi-asm -o /tmp/scan-build-2026-10-17-231001-351276-1 -x c /root/firefox-clang/media/ffvpx/libavutil/vulkan.c
1/*
* Copyright (c) Lynne
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/

21#include "config.h"
22#include <stdlib.h>
23#include "avassert.h"
24#include "mem.h"
25#include "refstruct.h"

27#include "vulkan.h"
28#include "libavutil/vulkan_loader.h"

30#if CONFIG_SHADER_COMPRESSION0
31#include "libavutil/zlib_utils.h"
32#endif

34const VkComponentMapping ff_comp_identity_map = {
  .r = VK_COMPONENT_SWIZZLE_IDENTITY,
  .g = VK_COMPONENT_SWIZZLE_IDENTITY,
  .b = VK_COMPONENT_SWIZZLE_IDENTITY,
  .a = VK_COMPONENT_SWIZZLE_IDENTITY,
39};

41/* Converts return values to strings */
42const char *ff_vk_ret2str(VkResult res)
43{
44#define CASE(VAL) case VAL: return #VAL
  switch (res) {
  CASE(VK_SUCCESS);
  CASE(VK_NOT_READY);
  CASE(VK_TIMEOUT);
  CASE(VK_EVENT_SET);
  CASE(VK_EVENT_RESET);
  CASE(VK_INCOMPLETE);
  CASE(VK_ERROR_OUT_OF_HOST_MEMORY);
  CASE(VK_ERROR_OUT_OF_DEVICE_MEMORY);
  CASE(VK_ERROR_INITIALIZATION_FAILED);
  CASE(VK_ERROR_DEVICE_LOST);
  CASE(VK_ERROR_MEMORY_MAP_FAILED);
  CASE(VK_ERROR_LAYER_NOT_PRESENT);
  CASE(VK_ERROR_EXTENSION_NOT_PRESENT);
  CASE(VK_ERROR_FEATURE_NOT_PRESENT);
  CASE(VK_ERROR_INCOMPATIBLE_DRIVER);
  CASE(VK_ERROR_TOO_MANY_OBJECTS);
  CASE(VK_ERROR_FORMAT_NOT_SUPPORTED);
  CASE(VK_ERROR_FRAGMENTED_POOL);
  CASE(VK_ERROR_UNKNOWN);
  CASE(VK_ERROR_OUT_OF_POOL_MEMORY);
  CASE(VK_ERROR_INVALID_EXTERNAL_HANDLE);
  CASE(VK_ERROR_FRAGMENTATION);
  CASE(VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS);
  CASE(VK_PIPELINE_COMPILE_REQUIRED);
  CASE(VK_ERROR_SURFACE_LOST_KHR);
  CASE(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR);
  CASE(VK_SUBOPTIMAL_KHR);
  CASE(VK_ERROR_OUT_OF_DATE_KHR);
  CASE(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR);
  CASE(VK_ERROR_VALIDATION_FAILED_EXT);
  CASE(VK_ERROR_INVALID_SHADER_NV);
  CASE(VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR);
  CASE(VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR);
  CASE(VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR);
  CASE(VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR);
  CASE(VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR);
  CASE(VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT);
  CASE(VK_ERROR_NOT_PERMITTED_KHR);
  CASE(VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT);
  CASE(VK_THREAD_IDLE_KHR);
  CASE(VK_THREAD_DONE_KHR);
  CASE(VK_OPERATION_DEFERRED_KHR);
  CASE(VK_OPERATION_NOT_DEFERRED_KHR);
  default: return "Unknown error";
  }
91#undef CASE
92}

94/* Malitia pura, Khronos */
95#define FN_MAP_TO(dst_t, dst_name, src_t, src_name)                                 \
  dst_t ff_vk_map_ ##src_name## _to_ ##dst_name(src_t src) \
  {                                                                   \
      dst_t dst = 0x0;                                                \
      MAP_TO(VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT,                   \
             VK_IMAGE_USAGE_SAMPLED_BIT);                             \
      MAP_TO(VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT,                    \
             VK_IMAGE_USAGE_TRANSFER_SRC_BIT);                        \
      MAP_TO(VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT,                    \
             VK_IMAGE_USAGE_TRANSFER_DST_BIT);                        \
      MAP_TO(VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT,                   \
             VK_IMAGE_USAGE_STORAGE_BIT);                             \
      MAP_TO(VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT,                \
             VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);                    \
      MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR,         \
             VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR);                \
      MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR,            \
             VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR);                \
      MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR,            \
             VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR);                \
      MAP_TO(VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR,          \
             VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR);                \
      MAP_TO(VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT,         \
             VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT);                   \
      return dst;                                                     \
  }

122#define MAP_TO(flag1, flag2) if (src & flag2) dst |= flag1;
123FN_MAP_TO(VkFormatFeatureFlagBits2, feats, VkImageUsageFlags, usage)
124#undef MAP_TO
125#define MAP_TO(flag1, flag2) if (src & flag1) dst |= flag2;
126FN_MAP_TO(VkImageUsageFlags, usage, VkFormatFeatureFlagBits2, feats)
127#undef MAP_TO
128#undef FN_MAP_TO

130static void load_enabled_qfs(FFVulkanContext *s)
131{
  s->nb_qfs = 0;
  for (int i = 0; i < s->hwctx->nb_qf; i++) {
      /* Skip duplicates */
      int skip = 0;
      for (int j = 0; j < s->nb_qfs; j++) {
          if (s->qfs[j] == s->hwctx->qf[i].idx) {
              skip = 1;
              break;
          }
      }
      if (skip)
          continue;

      s->qfs[s->nb_qfs++] = s->hwctx->qf[i].idx;
  }
147}

149static void reset_imageviews(AVRefStructOpaque unused, void *obj);

151int ff_vk_load_props(FFVulkanContext *s)
152{
  FFVulkanFunctions *vk = &s->vkfn;

  s->props = (VkPhysicalDeviceProperties2) {
      .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
  };

  FF_VK_STRUCT_EXT(s, &s->props, &s->props_11, FF_VK_EXT_NO_FLAG,do { if (((1ULL << 63) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 63))) { (&s->props_11)
->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES
; ff_vk_link_struct(&s->props, &s->props_11); }
 } while (0)
                   VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES)do { if (((1ULL << 63) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 63))) { (&s->props_11)
->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES
; ff_vk_link_struct(&s->props, &s->props_11); }
 } while (0);
  FF_VK_STRUCT_EXT(s, &s->props, &s->driver_props, FF_VK_EXT_NO_FLAG,do { if (((1ULL << 63) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 63))) { (&s->driver_props
)->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES
; ff_vk_link_struct(&s->props, &s->driver_props
); } } while (0)
                   VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES)do { if (((1ULL << 63) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 63))) { (&s->driver_props
)->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES
; ff_vk_link_struct(&s->props, &s->driver_props
); } } while (0);
  FF_VK_STRUCT_EXT(s, &s->props, &s->subgroup_props, FF_VK_EXT_NO_FLAG,do { if (((1ULL << 63) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 63))) { (&s->subgroup_props
)->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES
; ff_vk_link_struct(&s->props, &s->subgroup_props
); } } while (0)
                   VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES)do { if (((1ULL << 63) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 63))) { (&s->subgroup_props
)->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES
; ff_vk_link_struct(&s->props, &s->subgroup_props
); } } while (0);

  FF_VK_STRUCT_EXT(s, &s->props, &s->push_desc_props, FF_VK_EXT_PUSH_DESCRIPTOR,do { if (((1ULL << 14) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 14))) { (&s->push_desc_props
)->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR
; ff_vk_link_struct(&s->props, &s->push_desc_props
); } } while (0)
                   VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR)do { if (((1ULL << 14) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 14))) { (&s->push_desc_props
)->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR
; ff_vk_link_struct(&s->props, &s->push_desc_props
); } } while (0);
  FF_VK_STRUCT_EXT(s, &s->props, &s->hprops, FF_VK_EXT_EXTERNAL_HOST_MEMORY,do { if (((1ULL << 4) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 4))) { (&s->hprops)->
sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT
; ff_vk_link_struct(&s->props, &s->hprops); } }
 while (0)
                   VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT)do { if (((1ULL << 4) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 4))) { (&s->hprops)->
sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT
; ff_vk_link_struct(&s->props, &s->hprops); } }
 while (0);
  FF_VK_STRUCT_EXT(s, &s->props, &s->coop_matrix_props, FF_VK_EXT_COOP_MATRIX,do { if (((1ULL << 11) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 11))) { (&s->coop_matrix_props
)->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR
; ff_vk_link_struct(&s->props, &s->coop_matrix_props
); } } while (0)
                   VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR)do { if (((1ULL << 11) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 11))) { (&s->coop_matrix_props
)->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR
; ff_vk_link_struct(&s->props, &s->coop_matrix_props
); } } while (0);
  FF_VK_STRUCT_EXT(s, &s->props, &s->optical_flow_props, FF_VK_EXT_OPTICAL_FLOW,do { if (((1ULL << 12) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 12))) { (&s->optical_flow_props
)->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV
; ff_vk_link_struct(&s->props, &s->optical_flow_props
); } } while (0)
                   VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV)do { if (((1ULL << 12) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 12))) { (&s->optical_flow_props
)->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV
; ff_vk_link_struct(&s->props, &s->optical_flow_props
); } } while (0);
  FF_VK_STRUCT_EXT(s, &s->props, &s->host_image_props, FF_VK_EXT_HOST_IMAGE_COPY,do { if (((1ULL << 18) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 18))) { (&s->host_image_props
)->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT
; ff_vk_link_struct(&s->props, &s->host_image_props
); } } while (0)
                   VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT)do { if (((1ULL << 18) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 18))) { (&s->host_image_props
)->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT
; ff_vk_link_struct(&s->props, &s->host_image_props
); } } while (0);

177#ifdef VK_EXT_shader_long_vector1
  FF_VK_STRUCT_EXT(s, &s->props, &s->long_vector_props, FF_VK_EXT_LONG_VECTOR,do { if (((1ULL << 22) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 22))) { (&s->long_vector_props
)->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT
; ff_vk_link_struct(&s->props, &s->long_vector_props
); } } while (0)
                   VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT)do { if (((1ULL << 22) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 22))) { (&s->long_vector_props
)->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT
; ff_vk_link_struct(&s->props, &s->long_vector_props
); } } while (0);
180#endif

  s->feats = (VkPhysicalDeviceFeatures2) {
      .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
  };

  FF_VK_STRUCT_EXT(s, &s->feats, &s->feats_12, FF_VK_EXT_NO_FLAG,do { if (((1ULL << 63) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 63))) { (&s->feats_12)
->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES
; ff_vk_link_struct(&s->feats, &s->feats_12); }
 } while (0)
                   VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES)do { if (((1ULL << 63) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 63))) { (&s->feats_12)
->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES
; ff_vk_link_struct(&s->feats, &s->feats_12); }
 } while (0);
  FF_VK_STRUCT_EXT(s, &s->feats, &s->atomic_float_feats, FF_VK_EXT_ATOMIC_FLOAT,do { if (((1ULL << 10) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 10))) { (&s->atomic_float_feats
)->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT
; ff_vk_link_struct(&s->feats, &s->atomic_float_feats
); } } while (0)
                   VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT)do { if (((1ULL << 10) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 10))) { (&s->atomic_float_feats
)->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT
; ff_vk_link_struct(&s->feats, &s->atomic_float_feats
); } } while (0);
190#ifdef VK_KHR_unified_image_layouts1
  FF_VK_STRUCT_EXT(s, &s->feats, &s->unified_layout_feats, FF_VK_EXT_UNIFIED_IMAGE_LAYOUTS,do { if (((1ULL << 26) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 26))) { (&s->unified_layout_feats
)->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR
; ff_vk_link_struct(&s->feats, &s->unified_layout_feats
); } } while (0)
                   VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR)do { if (((1ULL << 26) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 26))) { (&s->unified_layout_feats
)->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR
; ff_vk_link_struct(&s->feats, &s->unified_layout_feats
); } } while (0);
193#endif

  if (!s->imageviews_pool) {
      s->imageviews_pool = av_refstruct_pool_alloc_ext(sizeof(FFVkImageViews), 0,
                                                       NULL((void*)0), NULL((void*)0), reset_imageviews,
                                                       NULL((void*)0), NULL((void*)0));
      if (!s->imageviews_pool)
          return AVERROR(ENOMEM)(-(12));
  }

  /* Try allocating 1024 layouts */
  s->host_image_copy_layouts = av_malloc(sizeof(*s->host_image_copy_layouts)*1024);
  s->host_image_props.pCopySrcLayouts = s->host_image_copy_layouts;
  s->host_image_props.copySrcLayoutCount = 512;
  s->host_image_props.pCopyDstLayouts = s->host_image_copy_layouts + 512;
  s->host_image_props.copyDstLayoutCount = 512;

  vk->GetPhysicalDeviceProperties2(s->hwctx->phys_dev, &s->props);

  /* Check if we had enough memory for all layouts */
  if (s->host_image_props.copySrcLayoutCount == 512 ||
      s->host_image_props.copyDstLayoutCount == 512) {
      VkImageLayout *new_array;
      size_t new_size;
      s->host_image_props.pCopySrcLayouts =
      s->host_image_props.pCopyDstLayouts = NULL((void*)0);
      s->host_image_props.copySrcLayoutCount =
      s->host_image_props.copyDstLayoutCount = 0;
      vk->GetPhysicalDeviceProperties2(s->hwctx->phys_dev, &s->props);

      new_size = s->host_image_props.copySrcLayoutCount +
                 s->host_image_props.copyDstLayoutCount;
      new_size *= sizeof(*s->host_image_copy_layouts);
      new_array = av_realloc(s->host_image_copy_layouts, new_size);
      if (!new_array)
          return AVERROR(ENOMEM)(-(12));

      s->host_image_copy_layouts = new_array;
      s->host_image_props.pCopySrcLayouts = new_array;
      s->host_image_props.pCopyDstLayouts = new_array + s->host_image_props.copySrcLayoutCount;
      vk->GetPhysicalDeviceProperties2(s->hwctx->phys_dev, &s->props);
  }

  vk->GetPhysicalDeviceMemoryProperties(s->hwctx->phys_dev, &s->mprops);
  vk->GetPhysicalDeviceFeatures2(s->hwctx->phys_dev, &s->feats);

  for (int i = 0; i < s->mprops.memoryTypeCount; i++)
      s->host_cached_flag |= s->mprops.memoryTypes[i].propertyFlags &
                             VK_MEMORY_PROPERTY_HOST_CACHED_BIT;

  load_enabled_qfs(s);

  if (s->qf_props)
      return 0;

  vk->GetPhysicalDeviceQueueFamilyProperties2(s->hwctx->phys_dev, &s->tot_nb_qfs, NULL((void*)0));

  s->qf_props = av_calloc(s->tot_nb_qfs, sizeof(*s->qf_props));
  if (!s->qf_props)
      return AVERROR(ENOMEM)(-(12));

  s->query_props = av_calloc(s->tot_nb_qfs, sizeof(*s->query_props));
  if (!s->qf_props) {
      av_freep(&s->qf_props);
      return AVERROR(ENOMEM)(-(12));
  }

  s->video_props = av_calloc(s->tot_nb_qfs, sizeof(*s->video_props));
  if (!s->video_props) {
      av_freep(&s->qf_props);
      av_freep(&s->query_props);
      return AVERROR(ENOMEM)(-(12));
  }

267#ifdef VK_KHR_maintenance91
  s->ownership_props = av_calloc(s->tot_nb_qfs, sizeof(*s->ownership_props));
  if (!s->ownership_props) {
      av_freep(&s->qf_props);
      av_freep(&s->query_props);
      av_freep(&s->video_props);
      return AVERROR(ENOMEM)(-(12));
  }
275#endif

  for (uint32_t i = 0; i < s->tot_nb_qfs; i++) {
      s->qf_props[i] = (VkQueueFamilyProperties2) {
          .sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
      };

      FF_VK_STRUCT_EXT(s, &s->qf_props[i], &s->query_props[i], FF_VK_EXT_VIDEO_QUEUE,do { if (((1ULL << 36) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 36))) { (&s->query_props
[i])->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR
; ff_vk_link_struct(&s->qf_props[i], &s->query_props
[i]); } } while (0)
                       VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR)do { if (((1ULL << 36) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 36))) { (&s->query_props
[i])->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR
; ff_vk_link_struct(&s->qf_props[i], &s->query_props
[i]); } } while (0);
      FF_VK_STRUCT_EXT(s, &s->qf_props[i], &s->video_props[i], FF_VK_EXT_VIDEO_QUEUE,do { if (((1ULL << 36) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 36))) { (&s->video_props
[i])->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR
; ff_vk_link_struct(&s->qf_props[i], &s->video_props
[i]); } } while (0)
                       VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR)do { if (((1ULL << 36) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 36))) { (&s->video_props
[i])->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR
; ff_vk_link_struct(&s->qf_props[i], &s->video_props
[i]); } } while (0);
286#ifdef VK_KHR_maintenance91
      FF_VK_STRUCT_EXT(s, &s->qf_props[i], &s->ownership_props[i], FF_VK_EXT_MAINTENANCE_9,do { if (((1ULL << 25) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 25))) { (&s->ownership_props
[i])->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR
; ff_vk_link_struct(&s->qf_props[i], &s->ownership_props
[i]); } } while (0)
                       VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR)do { if (((1ULL << 25) == (1ULL << 63)) || ((s)->
extensions & (1ULL << 25))) { (&s->ownership_props
[i])->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR
; ff_vk_link_struct(&s->qf_props[i], &s->ownership_props
[i]); } } while (0);
289#endif
  }

  vk->GetPhysicalDeviceQueueFamilyProperties2(s->hwctx->phys_dev, &s->tot_nb_qfs, s->qf_props);

  if (s->extensions & FF_VK_EXT_COOP_MATRIX(1ULL << 11)) {
      vk->GetPhysicalDeviceCooperativeMatrixPropertiesKHR(s->hwctx->phys_dev,
                                                          &s->coop_mat_props_nb, NULL((void*)0));

      if (s->coop_mat_props_nb) {
          s->coop_mat_props = av_malloc_array(s->coop_mat_props_nb,
                                              sizeof(VkCooperativeMatrixPropertiesKHR));
          for (int i = 0; i < s->coop_mat_props_nb; i++) {
              s->coop_mat_props[i] = (VkCooperativeMatrixPropertiesKHR) {
                  .sType = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR,
              };
          }

          vk->GetPhysicalDeviceCooperativeMatrixPropertiesKHR(s->hwctx->phys_dev,
                                                              &s->coop_mat_props_nb,
                                                              s->coop_mat_props);
      }
  }

  return 0;
314}

316AVVulkanDeviceQueueFamily *ff_vk_qf_find(FFVulkanContext *s,
                                       VkQueueFlagBits dev_family,
                                       VkVideoCodecOperationFlagBitsKHR vid_ops)
319{
  for (int i = 0; i < s->hwctx->nb_qf; i++) {
      if ((s->hwctx->qf[i].flags & dev_family) &&
          (s->hwctx->qf[i].video_caps & vid_ops) == vid_ops) {
          return &s->hwctx->qf[i];
      }
  }
  return NULL((void*)0);
327}

329static void exec_discard_deps(FFVulkanContext *s, FFVkExecContext *e);

331void ff_vk_exec_pool_free(FFVulkanContext *s, FFVkExecPool *pool)
332{
  FFVulkanFunctions *vk = &s->vkfn;

  for (int i = 0; i < pool->pool_size; i++) {
16
←
Assuming 'i' is < field 'pool_size'→
17
←
Loop condition is true.  Entering loop body→
      FFVkExecContext *e = &pool->contexts[i];
18
←
'e' initialized to a null pointer value→

      if (e->sem) {
19
←
Access to field 'sem' results in a dereference of a null pointer (loaded from variable 'e')
          VkSemaphoreWaitInfo sem_wait_info = {
              .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
              .semaphoreCount = 1,
              .pSemaphores = &e->sem,
              .pValues = &e->sem_value,
          };
          vk->WaitSemaphores(s->hwctx->act_dev, &sem_wait_info, UINT64_MAX(18446744073709551615UL));
          vk->DestroySemaphore(s->hwctx->act_dev, e->sem, s->hwctx->alloc);
      }

      exec_discard_deps(s, e);
      pthread_mutex_destroystrict_pthread_mutex_destroy(&e->lock);
  }

  /* Free shader-specific data */
  for (int i = 0; i < pool->nb_reg_shd; i++) {
      FFVulkanShaderData *sd = &pool->reg_shd[i];

      if (sd->desc_pool)
          vk->DestroyDescriptorPool(s->hwctx->act_dev, sd->desc_pool,
                                    s->hwctx->alloc);

      av_freep(&sd->desc_sets);
  }
  pool->nb_reg_shd = 0;

  for (int i = 0; i < pool->pool_size; i++) {
      if (pool->cmd_buf_pools[i])
          vk->FreeCommandBuffers(s->hwctx->act_dev, pool->cmd_buf_pools[i],
                                 1, &pool->cmd_bufs[i]);

      if (pool->cmd_buf_pools[i])
          vk->DestroyCommandPool(s->hwctx->act_dev, pool->cmd_buf_pools[i], s->hwctx->alloc);
  }
  if (pool->query_pool)
      vk->DestroyQueryPool(s->hwctx->act_dev, pool->query_pool, s->hwctx->alloc);

  av_free(pool->query_data);
  av_free(pool->cmd_buf_pools);
  av_free(pool->cmd_bufs);
  av_free(pool->contexts);
  pool->pool_size = 0;
381}

383/* Per-family, per-library queue selection phases; each library links its own
* copy, and pools which benefit from spreading are created by the same one */
385static atomic_uint exec_pool_phase[FF_ARRAY_ELEMS(((AVVulkanDeviceContext *)NULL)->qf)(sizeof(((AVVulkanDeviceContext *)((void*)0))->qf) / sizeof
((((AVVulkanDeviceContext *)((void*)0))->qf)[0]))];
386static AVOncepthread_once_t exec_pool_phase_seeded = AV_ONCE_INIT0;

388static void exec_pool_phase_seed(void)
389{
  uint32_t seed = rand();
  for (int i = 0; i < FF_ARRAY_ELEMS(exec_pool_phase)(sizeof(exec_pool_phase) / sizeof((exec_pool_phase)[0])); i++)
      atomic_store_explicit__c11_atomic_store(&exec_pool_phase[i], seed, memory_order_relaxed);
393}

395int ff_vk_exec_pool_init(FFVulkanContext *s, AVVulkanDeviceQueueFamily *qf,
                       FFVkExecPool *pool, int nb_contexts,
                       int nb_queries, VkQueryType query_type, int query_64bit,
                       const void *query_create_pnext)
399{
  int err;
  VkResult ret;
  FFVulkanFunctions *vk = &s->vkfn;

  VkCommandPoolCreateInfo cqueue_create;
  VkCommandBufferAllocateInfo cbuf_create;

  const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR *ef = NULL((void*)0);

  atomic_init__c11_atomic_init(&pool->idx, 0);

  if (query_type == VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR) {
1
Assuming 'query_type' is not equal to VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR→
2
←
Taking false branch→
      ef = ff_vk_find_struct(query_create_pnext,
                             VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR);
      if (!ef)
          return AVERROR(EINVAL)(-(22));
  }

  /* Allocate space for command buffer pools */
  pool->cmd_buf_pools = av_malloc(nb_contexts*sizeof(*pool->cmd_buf_pools));
  if (!pool->cmd_buf_pools) {
3
←
Assuming field 'cmd_buf_pools' is non-null→
4
←
Taking false branch→
      err = AVERROR(ENOMEM)(-(12));
      goto fail;
  }

  /* Allocate space for command buffers */
  pool->cmd_bufs = av_malloc(nb_contexts*sizeof(*pool->cmd_bufs));
  if (!pool->cmd_bufs) {
5
←
Assuming field 'cmd_bufs' is non-null→
6
←
Taking false branch→
      err = AVERROR(ENOMEM)(-(12));
      goto fail;
  }

  for (int i = 0; i < nb_contexts; i++) {
7
←
Assuming 'i' is >= 'nb_contexts'→
8
←
Loop condition is false. Execution continues on line 468→
      /* Create command pool */
      cqueue_create = (VkCommandPoolCreateInfo) {
          .sType              = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
          .flags              = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT |
                                VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
          .queueFamilyIndex   = qf->idx,
      };

      ret = vk->CreateCommandPool(s->hwctx->act_dev, &cqueue_create,
                                  s->hwctx->alloc, &pool->cmd_buf_pools[i]);
      if (ret != VK_SUCCESS) {
          av_log(s, AV_LOG_ERROR16, "Command pool creation failure: %s\n",
                 ff_vk_ret2str(ret));
          err = AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
          goto fail;
      }

      /* Allocate command buffer */
      cbuf_create = (VkCommandBufferAllocateInfo) {
          .sType              = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
          .level              = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
          .commandPool        = pool->cmd_buf_pools[i],
          .commandBufferCount = 1,
      };
      ret = vk->AllocateCommandBuffers(s->hwctx->act_dev, &cbuf_create,
                                       &pool->cmd_bufs[i]);
      if (ret != VK_SUCCESS) {
          av_log(s, AV_LOG_ERROR16, "Command buffer alloc failure: %s\n",
                 ff_vk_ret2str(ret));
          err = AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
          goto fail;
      }
  }

  /* Query pool */
  if (nb_queries) {
9
←
Assuming 'nb_queries' is 0→
10
←
Taking false branch→
      VkQueryPoolCreateInfo query_pool_info = {
          .sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
          .pNext = query_create_pnext,
          .queryType = query_type,
          .queryCount = nb_queries*nb_contexts,
      };
      ret = vk->CreateQueryPool(s->hwctx->act_dev, &query_pool_info,
                                s->hwctx->alloc, &pool->query_pool);
      if (ret != VK_SUCCESS) {
          av_log(s, AV_LOG_ERROR16, "Query pool alloc failure: %s\n",
                 ff_vk_ret2str(ret));
          err = AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
          goto fail;
      }

      pool->nb_queries = nb_queries;
      pool->query_status_stride = 1 + 1; /* One result, one status by default */
      pool->query_results = nb_queries;
      pool->query_statuses = nb_queries;

      /* Video encode queries produce two results per query */
      if (query_type == VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR) {
          int nb_results = av_popcountav_popcount_c(ef->encodeFeedbackFlags);
          pool->query_status_stride = nb_results + 1;
          pool->query_results *= nb_results;
      } else if (query_type == VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR) {
          pool->query_status_stride = 1;
          pool->query_results = 0;
      }

      pool->qd_size = (pool->query_results + pool->query_statuses)*(query_64bit ? 8 : 4);

      /* Allocate space for the query data */
      pool->query_data = av_calloc(nb_contexts, pool->qd_size);
      if (!pool->query_data) {
          err = AVERROR(ENOMEM)(-(12));
          goto fail;
      }
  }

  /* Allocate space for the contexts */
  pool->contexts = av_calloc(nb_contexts, sizeof(*pool->contexts));
11
←
Value assigned to field 'contexts'→
  if (!pool->contexts) {
12
←
Assuming field 'contexts' is null→
13
←
Taking true branch→
      err = AVERROR(ENOMEM)(-(12));
      goto fail;
14
←
Control jumps to line 590→
  }

  pool->pool_size = nb_contexts;

  for (int i = 0; i < pool->pool_size; i++)
      pthread_mutex_initstrict_pthread_mutex_init(&pool->contexts[i].lock, NULL((void*)0));

521#ifdef VK_KHR_internally_synchronized_queues1
  /* Check if the extension and its flag are actually enabled */
  int internal_queue_sync = 0;
  if (s->extensions & FF_VK_EXT_INTERNAL_QUEUE_SYNC(1ULL << 23)) {
      const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR *iqs;
      iqs = ff_vk_find_struct(s->hwctx->device_features.pNext,
                              VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR);
      internal_queue_sync = iqs && iqs->internallySynchronizedQueues;
  }
530#endif

  /* Video pools are pinned to the phase-picked queue (sessions order their
   * execution anyway); all other pools rotate starting from it, so pools
   * advancing in lockstep do not collide. */
  av_assert1(qf->idx < FF_ARRAY_ELEMS(exec_pool_phase))do { if (!(qf->idx < (sizeof(exec_pool_phase) / sizeof(
(exec_pool_phase)[0])))) { av_log(((void*)0), 0, "Assertion %s failed at %s:%d\n"
, "qf->idx < (sizeof(exec_pool_phase) / sizeof((exec_pool_phase)[0]))"
, "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 535);
 abort(); } } while (0);
  ff_thread_once(&exec_pool_phase_seeded, exec_pool_phase_seed)strict_pthread_once(&exec_pool_phase_seeded, exec_pool_phase_seed
);
  uint32_t phase = atomic_fetch_add(&exec_pool_phase[qf->idx], 1)__c11_atomic_fetch_add(&exec_pool_phase[qf->idx], 1, 5
);
  int pin_queue = qf->flags & (VK_QUEUE_VIDEO_DECODE_BIT_KHR |
                               VK_QUEUE_VIDEO_ENCODE_BIT_KHR);

  /* Init contexts */
  for (int i = 0; i < pool->pool_size; i++) {
      FFVkExecContext *e = &pool->contexts[i];
      VkSemaphoreTypeCreateInfo sem_type = {
          .sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
          .semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE,
      };
      VkSemaphoreCreateInfo sem_create = {
          .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
          .pNext = &sem_type,
      };

      /* Timeline semaphore carrying the busy state */
      ret = vk->CreateSemaphore(s->hwctx->act_dev, &sem_create, s->hwctx->alloc,
                                &e->sem);
      if (ret != VK_SUCCESS) {
          av_log(s, AV_LOG_ERROR16, "Failed to create submission semaphore: %s\n",
                 ff_vk_ret2str(ret));
          return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
      }

      e->idx = i;
      e->parent = pool;

      /* Query data */
      e->query_data = ((uint8_t *)pool->query_data) + pool->qd_size*i;
      e->query_idx = nb_queries*i;

      /* Command buffer */
      e->buf = pool->cmd_bufs[i];

      /* Queue index distribution */
      e->qi = pin_queue ? phase % qf->num : (i + phase) % qf->num;
      e->qf = qf->idx;
      VkDeviceQueueInfo2 qinfo = {
          .sType            = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2,
577#ifdef VK_KHR_internally_synchronized_queues1
          .flags            = internal_queue_sync ?
                              VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR : 0,
580#endif
          .queueFamilyIndex = qf->idx,
          .queueIndex       = e->qi,
      };
      vk->GetDeviceQueue2(s->hwctx->act_dev, &qinfo, &e->queue);
  }

  return 0;

589fail:
  ff_vk_exec_pool_free(s, pool);
15
←
Calling 'ff_vk_exec_pool_free'→
  return err;
592}

594VkResult ff_vk_exec_get_query(FFVulkanContext *s, FFVkExecContext *e,
                            void **data, VkQueryResultFlagBits flags)
596{
  FFVulkanFunctions *vk = &s->vkfn;
  const FFVkExecPool *pool = e->parent;
  VkQueryResultFlags qf = flags & ~(VK_QUERY_RESULT_64_BIT |
                                    VK_QUERY_RESULT_WITH_STATUS_BIT_KHR);

  if (!e->query_data) {
      av_log(s, AV_LOG_ERROR16, "Requested a query with a NULL query_data pointer!\n");
      return VK_INCOMPLETE;
  }

  qf |= pool->query_64bit ?
        VK_QUERY_RESULT_64_BIT : 0x0;
  qf |= pool->query_statuses ?
        VK_QUERY_RESULT_WITH_STATUS_BIT_KHR : 0x0;

  if (data)
      *data = e->query_data;

  return vk->GetQueryPoolResults(s->hwctx->act_dev, pool->query_pool,
                                 e->query_idx,
                                 pool->nb_queries,
                                 pool->qd_size, e->query_data,
                                 pool->qd_size, qf);
620}

622FFVkExecContext *ff_vk_exec_get(FFVulkanContext *s, FFVkExecPool *pool)
623{
  FFVulkanFunctions *vk = &s->vkfn;

  /* Release the dependencies of every completed context, rather than leaving them held until reuse */
  for (int i = 0; i < pool->pool_size; i++) {
      uint64_t sem_val;
      FFVkExecContext *e = &pool->contexts[i];
      if (pthread_mutex_trylock(&e->lock))
          continue; /* In use by a recording or submitting thread */
      /* Busy contexts (counter below sem_value) are claimed or executing:
       * their dependency lists are off-limits */
      if (vk->GetSemaphoreCounterValue(s->hwctx->act_dev, e->sem, &sem_val) == VK_SUCCESS &&
          sem_val >= e->sem_value &&
          (e->nb_buf_deps || e->nb_refstruct_deps || e->nb_obj_deps ||
           e->nb_frame_deps || e->nb_sw_frame_deps))
          exec_discard_deps(s, e);
      pthread_mutex_unlockstrict_pthread_mutex_unlock(&e->lock);
  }

  return &pool->contexts[atomic_fetch_add(&pool->idx, 1)__c11_atomic_fetch_add(&pool->idx, 1, 5) % pool->pool_size];
643}

645void ff_vk_exec_wait(FFVulkanContext *s, FFVkExecContext *e)
646{
  FFVulkanFunctions *vk = &s->vkfn;
  VkSemaphoreWaitInfo sem_wait_info = {
      .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
      .semaphoreCount = 1,
      .pSemaphores = &e->sem,
      .pValues = &e->sem_value,
  };
  pthread_mutex_lockstrict_pthread_mutex_lock(&e->lock);
  vk->WaitSemaphores(s->hwctx->act_dev, &sem_wait_info, UINT64_MAX(18446744073709551615UL));
  exec_discard_deps(s, e);
  pthread_mutex_unlockstrict_pthread_mutex_unlock(&e->lock);
658}

660int ff_vk_exec_start(FFVulkanContext *s, FFVkExecContext *e)
661{
  VkResult ret;
  FFVulkanFunctions *vk = &s->vkfn;
  const FFVkExecPool *pool = e->parent;

  VkCommandBufferBeginInfo cmd_start = {
      .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
      .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
  };
  VkSemaphoreWaitInfo sem_wait_info = {
      .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
      .semaphoreCount = 1,
      .pSemaphores = &e->sem,
      .pValues = &e->sem_value,
  };

  pthread_mutex_lockstrict_pthread_mutex_lock(&e->lock);

  /* Wait out the context's previous execution */
  vk->WaitSemaphores(s->hwctx->act_dev, &sem_wait_info, UINT64_MAX(18446744073709551615UL));

  /* Discard queue dependencies */
  exec_discard_deps(s, e);

  ret = vk->BeginCommandBuffer(e->buf, &cmd_start);
  if (ret != VK_SUCCESS) {
      av_log(s, AV_LOG_ERROR16, "Failed to start command recoding: %s\n",
             ff_vk_ret2str(ret));
      pthread_mutex_unlockstrict_pthread_mutex_unlock(&e->lock);
      return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
  }

  if (pool->nb_queries)
      vk->CmdResetQueryPool(e->buf, pool->query_pool,
                            e->query_idx, pool->nb_queries);

  /* Claim: the semaphore stays below this value until submission completes
   * or the recording is discarded, keeping every other user away */
  e->sem_value++;
  e->sem_sig[e->sem_sig_cnt++] = (VkSemaphoreSubmitInfo) {
      .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
      .semaphore = e->sem,
      .value = e->sem_value,
      .stageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
  };

  pthread_mutex_unlockstrict_pthread_mutex_unlock(&e->lock);

  return 0;
710}

712static void exec_discard_deps(FFVulkanContext *s, FFVkExecContext *e)
713{
  FFVulkanFunctions *vk = &s->vkfn;

  for (int j = 0; j < e->nb_buf_deps; j++)
      av_buffer_unref(&e->buf_deps[j]);
  e->nb_buf_deps = 0;

  for (int j = 0; j < e->nb_refstruct_deps; j++)
      av_refstruct_unref(&e->refstruct_deps[j]);
  e->nb_refstruct_deps = 0;

  for (int j = 0; j < e->nb_obj_deps; j++) {
      FFVkExecObjDep *od = &e->obj_deps[j];
      switch (od->type) {
      case VK_OBJECT_TYPE_IMAGE_VIEW:
          vk->DestroyImageView(s->hwctx->act_dev,
                               (VkImageView)od->obj, s->hwctx->alloc);
          break;
      case VK_OBJECT_TYPE_SEMAPHORE:
          vk->DestroySemaphore(s->hwctx->act_dev,
                               (VkSemaphore)od->obj, s->hwctx->alloc);
          break;
      default:
          av_assert1(0)do { if (!(0)) { av_log(((void*)0), 0, "Assertion %s failed at %s:%d\n"
, "0", "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 736
); abort(); } } while (0);
      }
  }
  e->nb_obj_deps = 0;

  for (int j = 0; j < e->nb_sw_frame_deps; j++)
      av_frame_free(&e->sw_frame_deps[j]);
  e->nb_sw_frame_deps = 0;

  for (int j = 0; j < e->nb_frame_deps; j++) {
      AVFrame *f = e->frame_deps[j];
      if (e->frame_locked[j]) {
          AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
          AVVulkanFramesContext *vkfc = hwfc->hwctx;
          AVVkFrame *vkf = (AVVkFrame *)f->data[0];
          vkfc->unlock_frame(hwfc, vkf);
          e->frame_locked[j] = 0;
      }
      e->frame_update[j] = 0;
  }
  e->nb_frame_deps = 0;

  e->sem_wait_cnt = 0;
  e->sem_sig_cnt = 0;
  e->sem_sig_val_dst_cnt = 0;
761}

763void ff_vk_exec_discard(FFVulkanContext *s, FFVkExecContext *e)
764{
  FFVulkanFunctions *vk = &s->vkfn;
  VkSemaphoreSignalInfo sig_info = {
      .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO,
      .semaphore = e->sem,
      .value = e->sem_value,
  };

  /* An abandoned recording is exclusively the claimer's: free everything
   * without the mutex, and un-claim last by signalling the burnt generation */
  exec_discard_deps(s, e);
  vk->ResetCommandBuffer(e->buf, 0);
  vk->SignalSemaphore(s->hwctx->act_dev, &sig_info);
777}

779void ff_vk_exec_add_dep_refstruct(FFVulkanContext *s, FFVkExecContext *e,
                                void *obj)
781{
  av_assert1(e->nb_refstruct_deps < FF_VK_EXEC_MAX_BUF_DEPS)do { if (!(e->nb_refstruct_deps < 256)) { av_log(((void
*)0), 0, "Assertion %s failed at %s:%d\n", "e->nb_refstruct_deps < 256"
, "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 782);
 abort(); } } while (0);
  e->refstruct_deps[e->nb_refstruct_deps++] = av_refstruct_ref(obj);
784}

786void ff_vk_exec_move_dep_refstruct(FFVulkanContext *s, FFVkExecContext *e,
                                 void *obj)
788{
  void **ptr = obj;

  av_assert1(e->nb_refstruct_deps < FF_VK_EXEC_MAX_BUF_DEPS)do { if (!(e->nb_refstruct_deps < 256)) { av_log(((void
*)0), 0, "Assertion %s failed at %s:%d\n", "e->nb_refstruct_deps < 256"
, "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 791);
 abort(); } } while (0);

  for (int i = 0; i < e->nb_refstruct_deps; i++) {
      if (e->refstruct_deps[i] == *ptr) {
          av_refstruct_unref(obj);
          return;
      }
  }

  e->refstruct_deps[e->nb_refstruct_deps++] = *ptr;
  *ptr = NULL((void*)0);
802}

804void ff_vk_exec_add_dep_obj(FFVulkanContext *s, FFVkExecContext *e,
                          VkObjectType type, uint64_t obj)
806{
  av_assert1(e->nb_obj_deps < FF_VK_EXEC_MAX_BUF_DEPS)do { if (!(e->nb_obj_deps < 256)) { av_log(((void*)0), 0
, "Assertion %s failed at %s:%d\n", "e->nb_obj_deps < 256"
, "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 807);
 abort(); } } while (0);
  e->obj_deps[e->nb_obj_deps++] = (FFVkExecObjDep) { obj, type };
809}

811int ff_vk_exec_add_dep_sw_frame(FFVulkanContext *s, FFVkExecContext *e,
                              AVFrame *f)
813{
  av_assert1(e->nb_sw_frame_deps < FF_VK_EXEC_MAX_SW_FRAME_DEPS)do { if (!(e->nb_sw_frame_deps < 16)) { av_log(((void*)
0), 0, "Assertion %s failed at %s:%d\n", "e->nb_sw_frame_deps < 16"
, "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 814);
 abort(); } } while (0);

  e->sw_frame_deps[e->nb_sw_frame_deps] = av_frame_clone(f);
  if (!e->sw_frame_deps[e->nb_sw_frame_deps])
      return AVERROR(ENOMEM)(-(12));

  e->nb_sw_frame_deps++;

  return 0;
823}

825void ff_vk_exec_add_dep_wait_sem(FFVulkanContext *s, FFVkExecContext *e,
                               VkSemaphore sem, uint64_t val,
                               VkPipelineStageFlagBits2 stage)
828{
  av_assert1(e->sem_wait_cnt < FF_VK_EXEC_MAX_SEM_OPS)do { if (!(e->sem_wait_cnt < (64*8))) { av_log(((void*)
0), 0, "Assertion %s failed at %s:%d\n", "e->sem_wait_cnt < (64*8)"
, "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 829);
 abort(); } } while (0);

  e->sem_wait[e->sem_wait_cnt++] = (VkSemaphoreSubmitInfo) {
      .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
      .semaphore = sem,
      .value = val,
      .stageMask = stage,
  };
837}

839void ff_vk_exec_add_dep_signal_sem(FFVulkanContext *s, FFVkExecContext *e,
                                 VkSemaphore sem, uint64_t val,
                                 VkPipelineStageFlagBits2 stage)
842{
  av_assert1(e->sem_sig_cnt < FF_VK_EXEC_MAX_SEM_OPS)do { if (!(e->sem_sig_cnt < (64*8))) { av_log(((void*)0
), 0, "Assertion %s failed at %s:%d\n", "e->sem_sig_cnt < (64*8)"
, "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 843);
 abort(); } } while (0);

  e->sem_sig[e->sem_sig_cnt++] = (VkSemaphoreSubmitInfo) {
      .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
      .semaphore = sem,
      .value = val,
      .stageMask = stage,
  };
851}

853void ff_vk_exec_add_dep_bool_sem(FFVulkanContext *s, FFVkExecContext *e,
                               VkSemaphore *sem, int nb,
                               VkPipelineStageFlagBits2 stage,
                               int wait)
857{
  /* Do not transfer ownership if we're signalling a binary semaphore,
   * since we're probably exporting it. */
  if (!wait) {
      av_assert1((e->sem_sig_cnt + nb) <= FF_VK_EXEC_MAX_SEM_OPS)do { if (!((e->sem_sig_cnt + nb) <= (64*8))) { av_log((
(void*)0), 0, "Assertion %s failed at %s:%d\n", "(e->sem_sig_cnt + nb) <= (64*8)"
, "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 861);
 abort(); } } while (0);
      for (int i = 0; i < nb; i++) {
          e->sem_sig[e->sem_sig_cnt++] = (VkSemaphoreSubmitInfo) {
              .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
              .semaphore = sem[i],
              .stageMask = stage,
          };
      }

      return;
  }

  /* Ownership of each semaphore passes to the execution */
  for (int i = 0; i < nb; i++) {
      ff_vk_exec_add_dep_obj(s, e, VK_OBJECT_TYPE_SEMAPHORE,
                             (uint64_t)sem[i]);
      ff_vk_exec_add_dep_wait_sem(s, e, sem[i], 0, stage);
  }
879}

881int ff_vk_exec_add_dep_frame(FFVulkanContext *s, FFVkExecContext *e, AVFrame *f,
                           VkPipelineStageFlagBits2 wait_stage,
                           VkPipelineStageFlagBits2 signal_stage)
884{
  AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
  AVVulkanFramesContext *vkfc = hwfc->hwctx;
  AVVkFrame *vkf = (AVVkFrame *)f->data[0];
  int nb_images = ff_vk_count_images(vkf);

  /* Don't add duplicates */
  for (int i = 0; i < e->nb_frame_deps; i++)
      if (e->frame_deps[i]->data[0] == f->data[0])
          return 1;

  av_assert1(e->nb_frame_deps < FF_VK_EXEC_MAX_FRAME_DEPS)do { if (!(e->nb_frame_deps < 64)) { av_log(((void*)0),
 0, "Assertion %s failed at %s:%d\n", "e->nb_frame_deps < 64"
, "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 895);
 abort(); } } while (0);
  av_assert1((e->sem_wait_cnt + nb_images) <= FF_VK_EXEC_MAX_SEM_OPS)do { if (!((e->sem_wait_cnt + nb_images) <= (64*8))) { av_log
(((void*)0), 0, "Assertion %s failed at %s:%d\n", "(e->sem_wait_cnt + nb_images) <= (64*8)"
, "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 896);
 abort(); } } while (0);
  av_assert1((e->sem_sig_cnt + nb_images) <= FF_VK_EXEC_MAX_SEM_OPS)do { if (!((e->sem_sig_cnt + nb_images) <= (64*8))) { av_log
(((void*)0), 0, "Assertion %s failed at %s:%d\n", "(e->sem_sig_cnt + nb_images) <= (64*8)"
, "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 897);
 abort(); } } while (0);

  /* prepare_frame in hwcontext_vulkan.c uses the regular frame management
   * code but has no frame yet, and it doesn't need to actually store a ref
   * to the frame. */
  if (f->buf[0]) {
      av_assert1(e->nb_buf_deps < FF_VK_EXEC_MAX_BUF_DEPS)do { if (!(e->nb_buf_deps < 256)) { av_log(((void*)0), 0
, "Assertion %s failed at %s:%d\n", "e->nb_buf_deps < 256"
, "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 903);
 abort(); } } while (0);
      e->buf_deps[e->nb_buf_deps] = av_buffer_ref(f->buf[0]);
      if (!e->buf_deps[e->nb_buf_deps])
          return AVERROR(ENOMEM)(-(12));
      e->nb_buf_deps++;
  }

  e->frame_deps[e->nb_frame_deps] = f;

  vkfc->lock_frame(hwfc, vkf);
  e->frame_locked[e->nb_frame_deps] = 1;
  e->frame_update[e->nb_frame_deps] = 0;
  e->nb_frame_deps++;

  for (int i = 0; i < nb_images; i++) {
      e->sem_wait[e->sem_wait_cnt++] = (VkSemaphoreSubmitInfo) {
          .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
          .semaphore = vkf->sem[i],
          .value = vkf->sem_value[i],
          .stageMask = wait_stage,
      };

      e->sem_sig[e->sem_sig_cnt++] = (VkSemaphoreSubmitInfo) {
          .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
          .semaphore = vkf->sem[i],
          .value = vkf->sem_value[i] + 1,
          .stageMask = signal_stage,
      };

      e->sem_sig_val_dst[e->sem_sig_val_dst_cnt] = &vkf->sem_value[i];
      e->sem_sig_val_dst_cnt++;
  }

  return 0;
937}

939void ff_vk_exec_update_frame(FFVulkanContext *s, FFVkExecContext *e, AVFrame *f,
                           VkImageMemoryBarrier2 *bar, uint32_t *nb_img_bar)
941{
  int i;
  for (i = 0; i < e->nb_frame_deps; i++)
      if (e->frame_deps[i]->data[0] == f->data[0])
          break;
  av_assert0(i < e->nb_frame_deps)do { if (!(i < e->nb_frame_deps)) { av_log(((void*)0), 0
, "Assertion %s failed at %s:%d\n", "i < e->nb_frame_deps"
, "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 946);
 abort(); } } while (0);

  /* Don't update duplicates */
  if (nb_img_bar && !e->frame_update[i])
      (*nb_img_bar)++;

  e->queue_family_dst[i] = bar->dstQueueFamilyIndex;
  e->access_dst[i] = bar->dstAccessMask;
  e->layout_dst[i] = bar->newLayout;
  e->frame_update[i] = 1;
956}

958int ff_vk_exec_mirror_sem_value(FFVulkanContext *s, FFVkExecContext *e,
                              VkSemaphore *dst, uint64_t *dst_val,
                              AVFrame *f)
961{
  AVVkFrame *vkf = (AVVkFrame *)f->data[0];

  /* Reject unknown frames */
  int i;
  for (i = 0; i < e->nb_frame_deps; i++)
      if (e->frame_deps[i]->data[0] == f->data[0])
          break;
  if (i == e->nb_frame_deps)
      return AVERROR(EINVAL)(-(22));

  av_assert1(e->sem_sig_val_dst_cnt < FF_VK_EXEC_MAX_SEM_OPS)do { if (!(e->sem_sig_val_dst_cnt < (64*8))) { av_log((
(void*)0), 0, "Assertion %s failed at %s:%d\n", "e->sem_sig_val_dst_cnt < (64*8)"
, "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 972);
 abort(); } } while (0);

  *dst     = vkf->sem[0];
  *dst_val = vkf->sem_value[0];

  e->sem_sig_val_dst[e->sem_sig_val_dst_cnt] = dst_val;
  e->sem_sig_val_dst_cnt++;

  return 0;
981}

983int ff_vk_exec_submit(FFVulkanContext *s, FFVkExecContext *e)
984{
  VkResult ret;
  FFVulkanFunctions *vk = &s->vkfn;
  VkCommandBufferSubmitInfo cmd_buf_info = (VkCommandBufferSubmitInfo) {
      .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO,
      .commandBuffer = e->buf,
  };
  VkSubmitInfo2 submit_info = (VkSubmitInfo2) {
      .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2,
      .pCommandBufferInfos = &cmd_buf_info,
      .commandBufferInfoCount = 1,
      .pWaitSemaphoreInfos = e->sem_wait,
      .waitSemaphoreInfoCount = e->sem_wait_cnt,
      .pSignalSemaphoreInfos = e->sem_sig,
      .signalSemaphoreInfoCount = e->sem_sig_cnt,
  };

  ret = vk->EndCommandBuffer(e->buf);
  if (ret != VK_SUCCESS) {
      av_log(s, AV_LOG_ERROR16, "Unable to finish command buffer: %s\n",
             ff_vk_ret2str(ret));
      ff_vk_exec_discard(s, e);
      return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
  }

1009#if FF_API_VULKAN_SYNC_QUEUES(61 < 62)
1010FF_DISABLE_DEPRECATION_WARNINGSGCC diagnostic push
 GCC diagnostic ignored "-Wdeprecated-declarations"

  s->hwctx->lock_queue(s->device, e->qf, e->qi);
1012FF_ENABLE_DEPRECATION_WARNINGSGCC diagnostic pop
1013#endif
  ret = vk->QueueSubmit2(e->queue, 1, &submit_info, VK_NULL_HANDLE((void*)0));
1015#if FF_API_VULKAN_SYNC_QUEUES(61 < 62)
1016FF_DISABLE_DEPRECATION_WARNINGSGCC diagnostic push
 GCC diagnostic ignored "-Wdeprecated-declarations"

  s->hwctx->unlock_queue(s->device, e->qf, e->qi);
1018FF_ENABLE_DEPRECATION_WARNINGSGCC diagnostic pop
1019#endif

  if (ret != VK_SUCCESS) {
      av_log(s, AV_LOG_ERROR16, "Unable to submit command buffer: %s\n",
             ff_vk_ret2str(ret));
      /* This also un-claims the context by signalling its semaphore */
      ff_vk_exec_discard(s, e);
      return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
  }

  for (int i = 0; i < e->sem_sig_val_dst_cnt; i++)
      *e->sem_sig_val_dst[i] += 1;

  /* Unlock all frames */
  for (int j = 0; j < e->nb_frame_deps; j++) {
      if (e->frame_locked[j]) {
          AVFrame *f = e->frame_deps[j];
          AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
          AVVulkanFramesContext *vkfc = hwfc->hwctx;
          AVVkFrame *vkf = (AVVkFrame *)f->data[0];

          if (e->frame_update[j]) {
              int nb_images = ff_vk_count_images(vkf);
              for (int i = 0; i < nb_images; i++) {
                  vkf->layout[i] = e->layout_dst[j];
                  vkf->access[i] = e->access_dst[j];
                  vkf->queue_family[i] = e->queue_family_dst[j];
              }
          }
          vkfc->unlock_frame(hwfc, vkf);
          e->frame_locked[j] = 0;
      }
  }

  e->had_submission = 1;

  return 0;
1056}

1058int ff_vk_alloc_mem(FFVulkanContext *s, VkMemoryRequirements *req,
                  VkMemoryPropertyFlagBits req_flags, void *alloc_extension,
                  VkMemoryPropertyFlagBits *mem_flags, VkDeviceMemory *mem)
1061{
  VkResult ret;
  int index = -1;
  FFVulkanFunctions *vk = &s->vkfn;

  VkMemoryAllocateInfo alloc_info = {
      .sType           = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
      .pNext           = alloc_extension,
  };

  alloc_info.allocationSize = req->size;

  /* 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 < s->mprops.memoryTypeCount; i++) {
      /* The memory type must be supported by the requirements (bitfield) */
      if (!(req->memoryTypeBits & (1 << i)))
          continue;

      /* The memory type flags must include our properties */
      if ((req_flags != UINT32_MAX(4294967295U)) &&
          ((s->mprops.memoryTypes[i].propertyFlags & req_flags) != req_flags))
          continue;

      /* Found a suitable memory type */
      index = i;
      break;
  }

  if (index < 0) {
      av_log(s, AV_LOG_ERROR16, "No memory type found for flags 0x%x\n",
             req_flags);
      return AVERROR(EINVAL)(-(22));
  }

  alloc_info.memoryTypeIndex = index;

  ret = vk->AllocateMemory(s->hwctx->act_dev, &alloc_info,
                           s->hwctx->alloc, mem);
  if (ret != VK_SUCCESS)
      return AVERROR(ENOMEM)(-(12));

  if (mem_flags)
      *mem_flags |= s->mprops.memoryTypes[index].propertyFlags;

  return 0;
1107}

1109int ff_vk_image_create(FFVulkanContext *s, VkImage *img, VkDeviceMemory *mem,
                     int width, int height, VkFormat format, int nb_layers,
                     VkImageTiling tiling, VkImageUsageFlags usage,
                     VkImageCreateFlags flags, void *create_pnext)
1113{
  int err;
  VkResult ret;
  FFVulkanFunctions *vk = &s->vkfn;
  VkMemoryPropertyFlagBits mem_flags;

  VkImageCreateInfo create_info = {
      .sType         = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
      .pNext         = create_pnext,
      .flags         = flags,
      .imageType     = VK_IMAGE_TYPE_2D,
      .format        = format,
      .extent        = { width, height, 1 },
      .mipLevels     = 1,
      .arrayLayers   = nb_layers,
      .tiling        = tiling,
      .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
      .usage         = usage,
      .samples       = VK_SAMPLE_COUNT_1_BIT,
      .sharingMode   = VK_SHARING_MODE_EXCLUSIVE,
  };
  VkMemoryDedicatedAllocateInfo ded_alloc = {
      .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
  };
  VkMemoryRequirements2 req = {
      .sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
  };
  VkImageMemoryRequirementsInfo2 req_desc = {
      .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
  };
  VkBindImageMemoryInfo bind_info = {
      .sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
  };

  *img = VK_NULL_HANDLE((void*)0);
  *mem = VK_NULL_HANDLE((void*)0);

  ret = vk->CreateImage(s->hwctx->act_dev, &create_info,
                        s->hwctx->alloc, img);
  if (ret != VK_SUCCESS) {
      av_log(s, AV_LOG_ERROR16, "Image creation failure: %s\n",
             ff_vk_ret2str(ret));
      return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
  }

  req_desc.image = *img;
  vk->GetImageMemoryRequirements2(s->hwctx->act_dev, &req_desc, &req);

  /* Never shared with another image, so always dedicated */
  ded_alloc.image = *img;
  err = ff_vk_alloc_mem(s, &req.memoryRequirements,
                        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
                        &ded_alloc, &mem_flags, mem);
  if (err < 0)
      goto fail;

  bind_info.image  = *img;
  bind_info.memory = *mem;
  ret = vk->BindImageMemory2(s->hwctx->act_dev, 1, &bind_info);
  if (ret != VK_SUCCESS) {
      av_log(s, AV_LOG_ERROR16, "Failed to bind image memory: %s\n",
             ff_vk_ret2str(ret));
      err = AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
      goto fail;
  }

  return 0;

1181fail:
  ff_vk_image_free(s, img, mem);
  return err;
1184}

1186void ff_vk_image_free(FFVulkanContext *s, VkImage *img, VkDeviceMemory *mem)
1187{
  FFVulkanFunctions *vk = &s->vkfn;

  if (*img) {
      vk->DestroyImage(s->hwctx->act_dev, *img, s->hwctx->alloc);
      *img = VK_NULL_HANDLE((void*)0);
  }
  if (*mem) {
      vk->FreeMemory(s->hwctx->act_dev, *mem, s->hwctx->alloc);
      *mem = VK_NULL_HANDLE((void*)0);
  }
1198}

1200int ff_vk_create_buf(FFVulkanContext *s, FFVkBuffer *buf, size_t size,
                   void *pNext, void *alloc_pNext,
                   VkBufferUsageFlags usage, VkMemoryPropertyFlagBits flags)
1203{
  int err;
  VkResult ret;
  int use_ded_mem;
  FFVulkanFunctions *vk = &s->vkfn;

  VkBufferCreateInfo buf_spawn = {
      .sType       = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
      .pNext       = pNext,
      .usage       = usage,
      .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
      .size        = flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT ?
                     FFALIGN(size, s->props.properties.limits.minMemoryMapAlignment)(((size)+(s->props.properties.limits.minMemoryMapAlignment
)-1)&~((s->props.properties.limits.minMemoryMapAlignment
)-1)) :
                     size,
  };

  VkMemoryAllocateFlagsInfo alloc_flags = {
      .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
      .flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,
  };
  VkBufferMemoryRequirementsInfo2 req_desc = {
      .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
  };
  VkMemoryDedicatedAllocateInfo ded_alloc = {
      .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
      .pNext = alloc_pNext,
  };
  VkMemoryDedicatedRequirements ded_req = {
      .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
  };
  VkMemoryRequirements2 req = {
      .sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
      .pNext = &ded_req,
  };

  av_log(s, AV_LOG_DEBUG48, "Creating a buffer of %zu bytes, "
                          "usage: 0x%x, flags: 0x%x\n",
         size, usage, flags);

  ret = vk->CreateBuffer(s->hwctx->act_dev, &buf_spawn, s->hwctx->alloc, &buf->buf);
  if (ret != VK_SUCCESS) {
      av_log(s, AV_LOG_ERROR16, "Failed to create buffer: %s\n",
             ff_vk_ret2str(ret));
      return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
  }

  req_desc.buffer = buf->buf;

  vk->GetBufferMemoryRequirements2(s->hwctx->act_dev, &req_desc, &req);

  /* In case the implementation prefers/requires dedicated allocation */
  use_ded_mem = ded_req.prefersDedicatedAllocation |
                ded_req.requiresDedicatedAllocation;
  if (use_ded_mem) {
      ded_alloc.buffer = buf->buf;
      ded_alloc.pNext = alloc_pNext;
      alloc_pNext = &ded_alloc;
  }

  if (usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
      alloc_flags.pNext = alloc_pNext;
      alloc_pNext = &alloc_flags;
  }

  err = ff_vk_alloc_mem(s, &req.memoryRequirements, flags, alloc_pNext,
                        &buf->flags, &buf->mem);
  if (err)
      return err;

  ret = vk->BindBufferMemory(s->hwctx->act_dev, buf->buf, buf->mem, 0);
  if (ret != VK_SUCCESS) {
      av_log(s, AV_LOG_ERROR16, "Failed to bind memory to buffer: %s\n",
             ff_vk_ret2str(ret));
      return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
  }

  if (usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
      VkBufferDeviceAddressInfo address_info = {
          .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
          .buffer = buf->buf,
      };
      buf->address = vk->GetBufferDeviceAddress(s->hwctx->act_dev, &address_info);
  }

  buf->size = size;

  return 0;
1290}

1292int ff_vk_map_buffers(FFVulkanContext *s, FFVkBuffer **buf, uint8_t *mem[],
                    int nb_buffers, int invalidate)
1294{
  VkResult ret;
  FFVulkanFunctions *vk = &s->vkfn;
  VkMappedMemoryRange inval_list[64];
  int inval_count = 0;

  for (int i = 0; i < nb_buffers; i++) {
      void *dst;
      ret = vk->MapMemory(s->hwctx->act_dev, buf[i]->mem, 0,
                          VK_WHOLE_SIZE(~0ULL), 0, &dst);
      if (ret != VK_SUCCESS) {
          av_log(s, AV_LOG_ERROR16, "Failed to map buffer memory: %s\n",
                 ff_vk_ret2str(ret));
          return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
      }
      buf[i]->mapped_mem = dst;
      if (mem)
          mem[i] = dst;
  }

  if (!invalidate)
      return 0;

  for (int i = 0; i < nb_buffers; i++) {
      const VkMappedMemoryRange ival_buf = {
          .sType  = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
          .memory = buf[i]->mem,
          .size   = VK_WHOLE_SIZE(~0ULL),
      };
      if (buf[i]->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
          continue;
      inval_list[inval_count++] = ival_buf;
  }

  if (inval_count) {
      ret = vk->InvalidateMappedMemoryRanges(s->hwctx->act_dev, inval_count,
                                             inval_list);
      if (ret != VK_SUCCESS) {
          av_log(s, AV_LOG_ERROR16, "Failed to invalidate memory: %s\n",
                 ff_vk_ret2str(ret));
          return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
      }
  }

  return 0;
1339}

1341int ff_vk_flush_buffer(FFVulkanContext *s, FFVkBuffer *buf,
                     VkDeviceSize offset, VkDeviceSize mem_size,
                     int flush)
1344{
  VkResult ret;
  FFVulkanFunctions *vk = &s->vkfn;

  if (buf->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
      return 0;

  const VkMappedMemoryRange flush_data = {
      .sType  = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
      .memory = buf->mem,
      .offset = offset,
      .size   = mem_size,
  };

  if (flush)
      ret = vk->FlushMappedMemoryRanges(s->hwctx->act_dev, 1, &flush_data);
  else
      ret = vk->InvalidateMappedMemoryRanges(s->hwctx->act_dev, 1, &flush_data);

  if (ret != VK_SUCCESS) {
      av_log(s, AV_LOG_ERROR16, "Failed to flush memory: %s\n",
             ff_vk_ret2str(ret));
      return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
  }

  return 0;
1370}

1372int ff_vk_unmap_buffers(FFVulkanContext *s, FFVkBuffer **buf, int nb_buffers,
                      int flush)
1374{
  int err = 0;
  VkResult ret;
  FFVulkanFunctions *vk = &s->vkfn;
  VkMappedMemoryRange flush_list[64];
  int flush_count = 0;

  if (flush) {
      for (int i = 0; i < nb_buffers; i++) {
          const VkMappedMemoryRange flush_buf = {
              .sType  = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
              .memory = buf[i]->mem,
              .size   = VK_WHOLE_SIZE(~0ULL),
          };

          av_assert0(!buf[i]->host_ref)do { if (!(!buf[i]->host_ref)) { av_log(((void*)0), 0, "Assertion %s failed at %s:%d\n"
, "!buf[i]->host_ref", "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c"
, 1389); abort(); } } while (0);
          if (buf[i]->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
              continue;
          flush_list[flush_count++] = flush_buf;
      }
  }

  if (flush_count) {
      ret = vk->FlushMappedMemoryRanges(s->hwctx->act_dev, flush_count,
                                        flush_list);
      if (ret != VK_SUCCESS) {
          av_log(s, AV_LOG_ERROR16, "Failed to flush memory: %s\n",
                 ff_vk_ret2str(ret));
          err = AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24))); /* We still want to try to unmap them */
      }
  }

  for (int i = 0; i < nb_buffers; i++) {
      vk->UnmapMemory(s->hwctx->act_dev, buf[i]->mem);
      buf[i]->mapped_mem = NULL((void*)0);
  }

  return err;
1412}

1414void ff_vk_free_buf(FFVulkanContext *s, FFVkBuffer *buf)
1415{
  FFVulkanFunctions *vk = &s->vkfn;

  if (!buf || !s->hwctx)
      return;

  if (buf->mapped_mem && !buf->host_ref)
      ff_vk_unmap_buffer(s, buf, 0);
  if (buf->buf != VK_NULL_HANDLE((void*)0))
      vk->DestroyBuffer(s->hwctx->act_dev, buf->buf, s->hwctx->alloc);
  if (buf->mem != VK_NULL_HANDLE((void*)0))
      vk->FreeMemory(s->hwctx->act_dev, buf->mem, s->hwctx->alloc);
  if (buf->host_ref)
      av_buffer_unref(&buf->host_ref);

  buf->buf = VK_NULL_HANDLE((void*)0);
  buf->mem = VK_NULL_HANDLE((void*)0);
  buf->mapped_mem = NULL((void*)0);
1433}

1435static void pooled_buf_free(AVRefStructOpaque opaque, void *obj)
1436{
  ff_vk_free_buf(opaque.nc, obj);
1438}

1440int ff_vk_get_pooled_buffer(FFVulkanContext *ctx, AVRefStructPool **buf_pool,
                          FFVkBuffer **buf, VkBufferUsageFlags usage,
                          void *create_pNext, size_t size,
                          VkMemoryPropertyFlagBits mem_props)
1444{
  int err;
  FFVkBuffer *data;

  if (!(*buf_pool)) {
      *buf_pool = av_refstruct_pool_alloc_ext(sizeof(FFVkBuffer), 0, ctx,
                                              NULL((void*)0), NULL((void*)0), pooled_buf_free,
                                              NULL((void*)0));
      if (!(*buf_pool))
          return AVERROR(ENOMEM)(-(12));
  }

  *buf = data = av_refstruct_pool_get(*buf_pool);
  if (!data)
      return AVERROR(ENOMEM)(-(12));

  if (data->size >= size)
      return 0;

  ff_vk_free_buf(ctx, data);
  memset(data, 0, sizeof(*data));

  err = ff_vk_create_buf(ctx, data, size,
                         create_pNext, NULL((void*)0), usage,
                         mem_props);
  if (err < 0) {
      av_refstruct_unref(buf);
      return err;
  }

  if (mem_props & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
      err = ff_vk_map_buffer(ctx, data, &data->mapped_mem, 0);
      if (err < 0) {
          av_refstruct_unref(buf);
          return err;
      }
  }

  return 0;
1483}

1485static int create_mapped_buffer(FFVulkanContext *s,
                              FFVkBuffer *vkb, VkBufferUsageFlags usage,
                              size_t size,
                              VkExternalMemoryBufferCreateInfo *create_desc,
                              VkImportMemoryHostPointerInfoEXT *import_desc,
                              VkMemoryHostPointerPropertiesEXT props)
1491{
  int err;
  VkResult ret;
  FFVulkanFunctions *vk = &s->vkfn;

  VkBufferCreateInfo buf_spawn = {
      .sType       = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
      .pNext       = create_desc,
      .usage       = usage,
      .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
      .size        = size,
  };
  VkMemoryRequirements req = {
      .size           = size,
      .alignment      = s->hprops.minImportedHostPointerAlignment,
      .memoryTypeBits = props.memoryTypeBits,
  };

  err = ff_vk_alloc_mem(s, &req,
                        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
                        import_desc, &vkb->flags, &vkb->mem);
  if (err < 0)
      return err;

  ret = vk->CreateBuffer(s->hwctx->act_dev, &buf_spawn, s->hwctx->alloc, &vkb->buf);
  if (ret != VK_SUCCESS) {
      vk->FreeMemory(s->hwctx->act_dev, vkb->mem, s->hwctx->alloc);
      return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
  }

  ret = vk->BindBufferMemory(s->hwctx->act_dev, vkb->buf, vkb->mem, 0);
  if (ret != VK_SUCCESS) {
      vk->FreeMemory(s->hwctx->act_dev, vkb->mem, s->hwctx->alloc);
      vk->DestroyBuffer(s->hwctx->act_dev, vkb->buf, s->hwctx->alloc);
      return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
  }

  return 0;
1529}

1531static void host_map_free(AVRefStructOpaque opaque, void *obj)
1532{
  ff_vk_free_buf(opaque.nc, obj);
1534}

1536int ff_vk_host_map_buffer(FFVulkanContext *s, FFVkBuffer **dst,
                        uint8_t *src_data, VkDeviceSize size,
                        const AVBufferRef *src_buf,
                        VkBufferUsageFlags usage)
1540{
  int err;
  VkResult ret;
  FFVulkanFunctions *vk = &s->vkfn;

  VkExternalMemoryBufferCreateInfo create_desc = {
      .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
      .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
  };
  VkMemoryAllocateFlagsInfo alloc_flags = {
      .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
      .flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,
  };
  VkImportMemoryHostPointerInfoEXT import_desc = {
      .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
      .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
      .pNext = usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT ? &alloc_flags : NULL((void*)0),
  };
  VkMemoryHostPointerPropertiesEXT props;

  AVBufferRef *ref;
  FFVkBuffer *vkb;
  size_t offs;
  size_t buffer_size;

  *dst = NULL((void*)0);

  /* Get the previous point at which mapping was possible and use it */
  offs = (uintptr_t)src_data % s->hprops.minImportedHostPointerAlignment;
  import_desc.pHostPointer = src_data - offs;

  props = (VkMemoryHostPointerPropertiesEXT) {
      VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
  };
  ret = vk->GetMemoryHostPointerPropertiesEXT(s->hwctx->act_dev,
                                              import_desc.handleType,
                                              import_desc.pHostPointer,
                                              &props);
  if (!(ret == VK_SUCCESS && props.memoryTypeBits))
      return AVERROR(EINVAL)(-(22));

  /* Ref the source buffer */
  ref = av_buffer_ref(src_buf);
  if (!ref)
      return AVERROR(ENOMEM)(-(12));

  /* Add the offset at the start, which gets ignored. */
  const VkDeviceSize src_avail = src_buf->size - (src_data - src_buf->data);
  buffer_size = offs + FFMIN(size, src_avail)((size) > (src_avail) ? (src_avail) : (size));
  buffer_size = FFALIGN(buffer_size, s->props.properties.limits.minMemoryMapAlignment)(((buffer_size)+(s->props.properties.limits.minMemoryMapAlignment
)-1)&~((s->props.properties.limits.minMemoryMapAlignment
)-1));
  buffer_size = FFALIGN(buffer_size, s->hprops.minImportedHostPointerAlignment)(((buffer_size)+(s->hprops.minImportedHostPointerAlignment
)-1)&~((s->hprops.minImportedHostPointerAlignment)-1));

  /* Create a buffer struct */
  vkb = av_refstruct_alloc_ext(sizeof(*vkb), 0, s, host_map_free);
  if (!vkb) {
      av_buffer_unref(&ref);
      return AVERROR(ENOMEM)(-(12));
  }

  err = create_mapped_buffer(s, vkb, usage,
                             buffer_size, &create_desc, &import_desc,
                             props);
  if (err < 0) {
      av_buffer_unref(&ref);
      av_refstruct_unref(&vkb);
      return err;
  }

  if (usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
      VkBufferDeviceAddressInfo address_info = {
          .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
          .buffer = vkb->buf,
      };
      vkb->address = vk->GetBufferDeviceAddress(s->hwctx->act_dev, &address_info);
  }

  vkb->host_ref       = ref;
  vkb->virtual_offset = offs;
  vkb->address       += offs;
  vkb->mapped_mem     = src_data;
  vkb->size           = buffer_size - offs;

  *dst = vkb;

  return 0;
1625}

1627int ff_vk_shader_add_push_const(FFVulkanShader *shd, int offset, int size,
                              VkShaderStageFlagBits stage)
1629{
  VkPushConstantRange *pc = &shd->push_consts[shd->push_consts_num++];
  av_assert1(shd->push_consts_num < FF_VK_MAX_PUSH_CONSTS)do { if (!(shd->push_consts_num < 4)) { av_log(((void*)
0), 0, "Assertion %s failed at %s:%d\n", "shd->push_consts_num < 4"
, "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 1631)
; abort(); } } while (0);
  pc->stageFlags = stage;
  pc->offset = offset;
  pc->size = size;
  return 0;
1636}

1638int ff_vk_init_sampler(FFVulkanContext *s, VkSampler *sampler,
                     int unnorm_coords, VkFilter filt)
1640{
  VkResult ret;
  FFVulkanFunctions *vk = &s->vkfn;

  VkSamplerCreateInfo sampler_info = {
      .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
      .magFilter = filt,
      .minFilter = sampler_info.magFilter,
      .mipmapMode = (unnorm_coords || filt == VK_FILTER_NEAREST) ?
                    VK_SAMPLER_MIPMAP_MODE_NEAREST :
                    VK_SAMPLER_MIPMAP_MODE_LINEAR,
      .addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
      .addressModeV = sampler_info.addressModeU,
      .addressModeW = sampler_info.addressModeU,
      .anisotropyEnable = VK_FALSE0U,
      .compareOp = VK_COMPARE_OP_NEVER,
      .borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
      .unnormalizedCoordinates = unnorm_coords,
  };

  ret = vk->CreateSampler(s->hwctx->act_dev, &sampler_info,
                          s->hwctx->alloc, sampler);
  if (ret != VK_SUCCESS) {
      av_log(s, AV_LOG_ERROR16, "Unable to init sampler: %s\n",
             ff_vk_ret2str(ret));
      return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
  }

  return 0;
1669}

1671VkImageAspectFlags ff_vk_aspect_flag(AVFrame *f, int p)
1672{
  AVVkFrame *vkf = (AVVkFrame *)f->data[0];
  AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
  int nb_images = ff_vk_count_images(vkf);
  int nb_planes = av_pix_fmt_count_planes(hwfc->sw_format);

  static const VkImageAspectFlags plane_aspect[] = { VK_IMAGE_ASPECT_PLANE_0_BIT,
                                                     VK_IMAGE_ASPECT_PLANE_1_BIT,
                                                     VK_IMAGE_ASPECT_PLANE_2_BIT, };

  if (ff_vk_mt_is_np_rgb(hwfc->sw_format) || (nb_planes == nb_images))
      return VK_IMAGE_ASPECT_COLOR_BIT;

  return plane_aspect[p];
1686}

1688int ff_vk_mt_is_np_rgb(enum AVPixelFormat pix_fmt)
1689{
  if (pix_fmt == AV_PIX_FMT_ABGR   || pix_fmt == AV_PIX_FMT_BGRA   ||
      pix_fmt == AV_PIX_FMT_RGBA   || pix_fmt == AV_PIX_FMT_RGB24  ||
      pix_fmt == AV_PIX_FMT_BGR24  || pix_fmt == AV_PIX_FMT_RGB48AV_PIX_FMT_RGB48LE  ||
      pix_fmt == AV_PIX_FMT_RGBA64AV_PIX_FMT_RGBA64LE || pix_fmt == AV_PIX_FMT_RGB565AV_PIX_FMT_RGB565LE ||
      pix_fmt == AV_PIX_FMT_BGR565AV_PIX_FMT_BGR565LE || pix_fmt == AV_PIX_FMT_BGR0   ||
      pix_fmt == AV_PIX_FMT_0BGR   || pix_fmt == AV_PIX_FMT_RGB0   ||
      pix_fmt == AV_PIX_FMT_GBRP10AV_PIX_FMT_GBRP10LE  || pix_fmt == AV_PIX_FMT_GBRP12AV_PIX_FMT_GBRP12LE ||
      pix_fmt == AV_PIX_FMT_GBRP14AV_PIX_FMT_GBRP14LE  || pix_fmt == AV_PIX_FMT_GBRP16AV_PIX_FMT_GBRP16LE ||
      pix_fmt == AV_PIX_FMT_GBRAP   || pix_fmt == AV_PIX_FMT_GBRAP10AV_PIX_FMT_GBRAP10LE ||
      pix_fmt == AV_PIX_FMT_GBRAP12AV_PIX_FMT_GBRAP12LE || pix_fmt == AV_PIX_FMT_GBRAP14AV_PIX_FMT_GBRAP14LE ||
      pix_fmt == AV_PIX_FMT_GBRAP16AV_PIX_FMT_GBRAP16LE || pix_fmt == AV_PIX_FMT_GBRAP32AV_PIX_FMT_GBRAP32LE ||
      pix_fmt == AV_PIX_FMT_GBRPF16AV_PIX_FMT_GBRPF16LE || pix_fmt == AV_PIX_FMT_GBRAPF16AV_PIX_FMT_GBRAPF16LE ||
      pix_fmt == AV_PIX_FMT_GBRPF32AV_PIX_FMT_GBRPF32LE || pix_fmt == AV_PIX_FMT_GBRAPF32AV_PIX_FMT_GBRAPF32LE ||
      pix_fmt == AV_PIX_FMT_X2RGB10AV_PIX_FMT_X2RGB10LE || pix_fmt == AV_PIX_FMT_X2BGR10AV_PIX_FMT_X2BGR10LE ||
      pix_fmt == AV_PIX_FMT_RGBAF32AV_PIX_FMT_RGBAF32LE || pix_fmt == AV_PIX_FMT_RGBF32AV_PIX_FMT_RGBF32LE ||
      pix_fmt == AV_PIX_FMT_RGBA128AV_PIX_FMT_RGBA128LE || pix_fmt == AV_PIX_FMT_RGB96AV_PIX_FMT_RGB96LE ||
      pix_fmt == AV_PIX_FMT_GBRP || pix_fmt == AV_PIX_FMT_BAYER_RGGB16AV_PIX_FMT_BAYER_RGGB16LE)
      return 1;
  return 0;
1709}

1711void ff_vk_set_perm(enum AVPixelFormat pix_fmt, int lut[4], int inv)
1712{
  switch (pix_fmt) {
  case AV_PIX_FMT_GBRP:
  case AV_PIX_FMT_GBRAP:
  case AV_PIX_FMT_GBRAP10AV_PIX_FMT_GBRAP10LE:
  case AV_PIX_FMT_GBRAP12AV_PIX_FMT_GBRAP12LE:
  case AV_PIX_FMT_GBRAP14AV_PIX_FMT_GBRAP14LE:
  case AV_PIX_FMT_GBRAP16AV_PIX_FMT_GBRAP16LE:
  case AV_PIX_FMT_GBRAPF16AV_PIX_FMT_GBRAPF16LE:
  case AV_PIX_FMT_GBRP10AV_PIX_FMT_GBRP10LE:
  case AV_PIX_FMT_GBRP12AV_PIX_FMT_GBRP12LE:
  case AV_PIX_FMT_GBRP14AV_PIX_FMT_GBRP14LE:
  case AV_PIX_FMT_GBRP16AV_PIX_FMT_GBRP16LE:
  case AV_PIX_FMT_GBRPF16AV_PIX_FMT_GBRPF16LE:
  case AV_PIX_FMT_GBRPF32AV_PIX_FMT_GBRPF32LE:
  case AV_PIX_FMT_GBRAP32AV_PIX_FMT_GBRAP32LE:
  case AV_PIX_FMT_GBRAPF32AV_PIX_FMT_GBRAPF32LE:
      lut[0] = 1;
      lut[1] = 2;
      lut[2] = 0;
      lut[3] = 3;
      break;
  case AV_PIX_FMT_X2BGR10AV_PIX_FMT_X2BGR10LE:
      lut[0] = 0;
      lut[1] = 2;
      lut[2] = 1;
      lut[3] = 3;
      break;
  case AV_PIX_FMT_BGRA:
  case AV_PIX_FMT_BGR0:
      /* Stored in RGBA images, so reverse them */
      lut[0] = 2;
      lut[1] = 1;
      lut[2] = 0;
      lut[3] = 3;
      break;
  default:
      lut[0] = 0;
      lut[1] = 1;
      lut[2] = 2;
      lut[3] = 3;
      break;
  }

  if (inv) {
      int lut_tmp[4] = { lut[0], lut[1], lut[2], lut[3] };
      for (int i = 0; i < 4; i++)
          lut[lut_tmp[i]] = i;
  }

  return;
1763}

1765const char *ff_vk_shader_rep_fmt(enum AVPixelFormat pix_fmt,
                               enum FFVkShaderRepFormat rep_fmt)
1767{
  switch (pix_fmt) {
  case AV_PIX_FMT_RGBA:
  case AV_PIX_FMT_BGRA:
  case AV_PIX_FMT_RGB24:
  case AV_PIX_FMT_BGR24:
  case AV_PIX_FMT_BGR0:
  case AV_PIX_FMT_RGB0:
  case AV_PIX_FMT_RGB565AV_PIX_FMT_RGB565LE:
  case AV_PIX_FMT_BGR565AV_PIX_FMT_BGR565LE:
  case AV_PIX_FMT_UYVA:
  case AV_PIX_FMT_YUYV422:
  case AV_PIX_FMT_UYVY422: {
      const char *rep_tab[] = {
          [FF_VK_REP_NATIVE] = "rgba8ui",
          [FF_VK_REP_FLOAT] = "rgba8",
          [FF_VK_REP_INT] = "rgba8i",
          [FF_VK_REP_UINT] = "rgba8ui",
      };
      return rep_tab[rep_fmt];
  }
  case AV_PIX_FMT_X2RGB10AV_PIX_FMT_X2RGB10LE:
  case AV_PIX_FMT_X2BGR10AV_PIX_FMT_X2BGR10LE:
  case AV_PIX_FMT_Y210AV_PIX_FMT_Y210LE:
  case AV_PIX_FMT_XV30AV_PIX_FMT_XV30LE: {
      const char *rep_tab[] = {
          [FF_VK_REP_NATIVE] = "rgb10_a2ui",
          [FF_VK_REP_FLOAT] = "rgb10_a2",
          [FF_VK_REP_INT] = NULL((void*)0),
          [FF_VK_REP_UINT] = "rgb10_a2ui",
      };
      return rep_tab[rep_fmt];
  }
  case AV_PIX_FMT_RGB48AV_PIX_FMT_RGB48LE:
  case AV_PIX_FMT_RGBA64AV_PIX_FMT_RGBA64LE:
  case AV_PIX_FMT_Y212AV_PIX_FMT_Y212LE:
  case AV_PIX_FMT_Y216AV_PIX_FMT_Y216LE:
  case AV_PIX_FMT_XV36AV_PIX_FMT_XV36LE:
  case AV_PIX_FMT_XV48AV_PIX_FMT_XV48LE: {
      const char *rep_tab[] = {
          [FF_VK_REP_NATIVE] = "rgba16ui",
          [FF_VK_REP_FLOAT] = "rgba16",
          [FF_VK_REP_INT] = "rgba16i",
          [FF_VK_REP_UINT] = "rgba16ui",
      };
      return rep_tab[rep_fmt];
  }
  case AV_PIX_FMT_RGBAF16AV_PIX_FMT_RGBAF16LE: {
      const char *rep_tab[] = {
          [FF_VK_REP_NATIVE] = "rgba16f",
          [FF_VK_REP_FLOAT] = "rgba16f",
          [FF_VK_REP_INT] = "rgba32i",
          [FF_VK_REP_UINT] = "rgba16u",
      };
      return rep_tab[rep_fmt];
  }
  case AV_PIX_FMT_RGBF32AV_PIX_FMT_RGBF32LE:
  case AV_PIX_FMT_RGBAF32AV_PIX_FMT_RGBAF32LE: {
      const char *rep_tab[] = {
          [FF_VK_REP_NATIVE] = "rgba32f",
          [FF_VK_REP_FLOAT] = "rgba32f",
          [FF_VK_REP_INT] = "rgba32i",
          [FF_VK_REP_UINT] = "rgba32ui",
      };
      return rep_tab[rep_fmt];
  }
  case AV_PIX_FMT_RGB96AV_PIX_FMT_RGB96LE:
  case AV_PIX_FMT_RGBA128AV_PIX_FMT_RGBA128LE: {
      const char *rep_tab[] = {
          [FF_VK_REP_NATIVE] = "rgba32ui",
          [FF_VK_REP_FLOAT] = NULL((void*)0),
          [FF_VK_REP_INT] = "rgba32i",
          [FF_VK_REP_UINT] = "rgba32ui",
      };
      return rep_tab[rep_fmt];
  }
  case AV_PIX_FMT_GBRP:
  case AV_PIX_FMT_GRAY8:
  case AV_PIX_FMT_GBRAP:
  case AV_PIX_FMT_YUV420P:
  case AV_PIX_FMT_YUV422P:
  case AV_PIX_FMT_YUV444P:
  case AV_PIX_FMT_YUVA420P:
  case AV_PIX_FMT_YUVA422P:
  case AV_PIX_FMT_YUVA444P: {
      const char *rep_tab[] = {
          [FF_VK_REP_NATIVE] = "r8ui",
          [FF_VK_REP_FLOAT] = "r8",
          [FF_VK_REP_INT] = "r8i",
          [FF_VK_REP_UINT] = "r8ui",
      };
      return rep_tab[rep_fmt];
  };
  case AV_PIX_FMT_GRAY10AV_PIX_FMT_GRAY10LE:
  case AV_PIX_FMT_GRAY12AV_PIX_FMT_GRAY12LE:
  case AV_PIX_FMT_GRAY14AV_PIX_FMT_GRAY14LE:
  case AV_PIX_FMT_GRAY16AV_PIX_FMT_GRAY16LE:
  case AV_PIX_FMT_GBRAP10AV_PIX_FMT_GBRAP10LE:
  case AV_PIX_FMT_GBRAP12AV_PIX_FMT_GBRAP12LE:
  case AV_PIX_FMT_GBRAP14AV_PIX_FMT_GBRAP14LE:
  case AV_PIX_FMT_GBRAP16AV_PIX_FMT_GBRAP16LE:
  case AV_PIX_FMT_GBRAPF16AV_PIX_FMT_GBRAPF16LE:
  case AV_PIX_FMT_GBRP10AV_PIX_FMT_GBRP10LE:
  case AV_PIX_FMT_GBRP12AV_PIX_FMT_GBRP12LE:
  case AV_PIX_FMT_GBRP14AV_PIX_FMT_GBRP14LE:
  case AV_PIX_FMT_GBRP16AV_PIX_FMT_GBRP16LE:
  case AV_PIX_FMT_GBRPF16AV_PIX_FMT_GBRPF16LE:
  case AV_PIX_FMT_YUV420P10AV_PIX_FMT_YUV420P10LE:
  case AV_PIX_FMT_YUV420P12AV_PIX_FMT_YUV420P12LE:
  case AV_PIX_FMT_YUV420P16AV_PIX_FMT_YUV420P16LE:
  case AV_PIX_FMT_YUV422P10AV_PIX_FMT_YUV422P10LE:
  case AV_PIX_FMT_YUV422P12AV_PIX_FMT_YUV422P12LE:
  case AV_PIX_FMT_YUV422P16AV_PIX_FMT_YUV422P16LE:
  case AV_PIX_FMT_YUV444P10AV_PIX_FMT_YUV444P10LE:
  case AV_PIX_FMT_YUV444P12AV_PIX_FMT_YUV444P12LE:
  case AV_PIX_FMT_YUV444P16AV_PIX_FMT_YUV444P16LE:
  case AV_PIX_FMT_YUVA420P10AV_PIX_FMT_YUVA420P10LE:
  case AV_PIX_FMT_YUVA420P16AV_PIX_FMT_YUVA420P16LE:
  case AV_PIX_FMT_YUVA422P10AV_PIX_FMT_YUVA422P10LE:
  case AV_PIX_FMT_YUVA422P12AV_PIX_FMT_YUVA422P12LE:
  case AV_PIX_FMT_YUVA422P16AV_PIX_FMT_YUVA422P16LE:
  case AV_PIX_FMT_YUVA444P10AV_PIX_FMT_YUVA444P10LE:
  case AV_PIX_FMT_YUVA444P12AV_PIX_FMT_YUVA444P12LE:
  case AV_PIX_FMT_YUVA444P16AV_PIX_FMT_YUVA444P16LE:
  case AV_PIX_FMT_BAYER_RGGB16AV_PIX_FMT_BAYER_RGGB16LE: {
      const char *rep_tab[] = {
          [FF_VK_REP_NATIVE] = "r16ui",
          [FF_VK_REP_FLOAT] = "r16f",
          [FF_VK_REP_INT] = "r16i",
          [FF_VK_REP_UINT] = "r16ui",
      };
      return rep_tab[rep_fmt];
  };
  case AV_PIX_FMT_GRAY32AV_PIX_FMT_GRAY32LE:
  case AV_PIX_FMT_GRAYF32AV_PIX_FMT_GRAYF32LE:
  case AV_PIX_FMT_GBRPF32AV_PIX_FMT_GBRPF32LE:
  case AV_PIX_FMT_GBRAPF32AV_PIX_FMT_GBRAPF32LE: {
      const char *rep_tab[] = {
          [FF_VK_REP_NATIVE] = "r32f",
          [FF_VK_REP_FLOAT] = "r32f",
          [FF_VK_REP_INT] = "r32i",
          [FF_VK_REP_UINT] = "r32ui",
      };
      return rep_tab[rep_fmt];
  };
  case AV_PIX_FMT_GBRAP32AV_PIX_FMT_GBRAP32LE: {
      const char *rep_tab[] = {
          [FF_VK_REP_NATIVE] = "r32ui",
          [FF_VK_REP_FLOAT] = NULL((void*)0),
          [FF_VK_REP_INT] = "r32i",
          [FF_VK_REP_UINT] = "r32ui",
      };
      return rep_tab[rep_fmt];
  };
  case AV_PIX_FMT_NV12:
  case AV_PIX_FMT_NV16:
  case AV_PIX_FMT_NV24: {
      const char *rep_tab[] = {
          [FF_VK_REP_NATIVE] = "rg8ui",
          [FF_VK_REP_FLOAT] = "rg8",
          [FF_VK_REP_INT] = "rg8i",
          [FF_VK_REP_UINT] = "rg8ui",
      };
      return rep_tab[rep_fmt];
  };
  case AV_PIX_FMT_P010AV_PIX_FMT_P010LE:
  case AV_PIX_FMT_P210AV_PIX_FMT_P210LE:
  case AV_PIX_FMT_P410AV_PIX_FMT_P410LE: {
      const char *rep_tab[] = {
          [FF_VK_REP_NATIVE] = "rgb10_a2ui",
          [FF_VK_REP_FLOAT] = "rgb10_a2",
          [FF_VK_REP_INT] = NULL((void*)0),
          [FF_VK_REP_UINT] = "rgb10_a2ui",
      };
      return rep_tab[rep_fmt];
  };
  case AV_PIX_FMT_P012AV_PIX_FMT_P012LE:
  case AV_PIX_FMT_P016AV_PIX_FMT_P016LE:
  case AV_PIX_FMT_P212AV_PIX_FMT_P212LE:
  case AV_PIX_FMT_P216AV_PIX_FMT_P216LE:
  case AV_PIX_FMT_P412AV_PIX_FMT_P412LE:
  case AV_PIX_FMT_P416AV_PIX_FMT_P416LE: {
      const char *rep_tab[] = {
          [FF_VK_REP_NATIVE] = "rg16ui",
          [FF_VK_REP_FLOAT] = "rg16",
          [FF_VK_REP_INT] = "rg16i",
          [FF_VK_REP_UINT] = "rg16ui",
      };
      return rep_tab[rep_fmt];
  };
  default:
      return "rgba32f";
  }
1960}

1962static void reset_imageviews(AVRefStructOpaque unused, void *obj)
1963{
  FFVkImageViews *iv = obj;

  for (int i = 0; i < iv->nb_views; i++) {
      if (iv->views[i])
          iv->destroy_image_view(iv->dev, iv->views[i], iv->alloc);
  }

  memset(iv->views, 0, sizeof(iv->views));
1972}

1974FFVkImageViews *ff_vk_imageviews_alloc(FFVulkanContext *s, int nb_views)
1975{
  FFVulkanFunctions *vk = &s->vkfn;
  FFVkImageViews *iv;

  av_assert1(nb_views <= AV_NUM_DATA_POINTERS)do { if (!(nb_views <= 8)) { av_log(((void*)0), 0, "Assertion %s failed at %s:%d\n"
, "nb_views <= 8", "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c"
, 1979); abort(); } } while (0);

  iv = av_refstruct_pool_get(s->imageviews_pool);
  if (!iv)
      return NULL((void*)0);

  iv->nb_views           = nb_views;
  iv->dev                = s->hwctx->act_dev;
  iv->alloc              = s->hwctx->alloc;
  iv->destroy_image_view = vk->DestroyImageView;

  return iv;
1991}

1993static VkFormat map_fmt_to_rep(VkFormat fmt, enum FFVkShaderRepFormat rep_fmt)
1994{
1995#define REPS_FMT(fmt) \
  [FF_VK_REP_NATIVE] = fmt ## _UINT, \
  [FF_VK_REP_FLOAT]  = fmt ## _UNORM, \
  [FF_VK_REP_INT]    = fmt ## _SINT, \
  [FF_VK_REP_UINT]   = fmt ## _UINT,

2001#define REPS_FMT_PACK(fmt, num) \
  [FF_VK_REP_NATIVE] = fmt ## _UINT_PACK ## num, \
  [FF_VK_REP_FLOAT]  = fmt ## _UNORM_PACK ## num, \
  [FF_VK_REP_INT]    = fmt ## _SINT_PACK ## num, \
  [FF_VK_REP_UINT]   = fmt ## _UINT_PACK ## num,

  const VkFormat fmts_map[][4] = {
      { REPS_FMT_PACK(VK_FORMAT_A2B10G10R10, 32) },
      { REPS_FMT_PACK(VK_FORMAT_A2R10G10B10, 32) },
      {
          VK_FORMAT_B5G6R5_UNORM_PACK16,
          VK_FORMAT_B5G6R5_UNORM_PACK16,
          VK_FORMAT_UNDEFINED,
          VK_FORMAT_UNDEFINED,
      },
      {
          VK_FORMAT_R5G6B5_UNORM_PACK16,
          VK_FORMAT_R5G6B5_UNORM_PACK16,
          VK_FORMAT_UNDEFINED,
          VK_FORMAT_UNDEFINED,
      },
      { REPS_FMT(VK_FORMAT_B8G8R8) },
      { REPS_FMT(VK_FORMAT_B8G8R8A8) },
      { REPS_FMT(VK_FORMAT_R8) },
      { REPS_FMT(VK_FORMAT_R8G8) },
      { REPS_FMT(VK_FORMAT_R8G8B8) },
      { REPS_FMT(VK_FORMAT_R8G8B8A8) },
      { REPS_FMT(VK_FORMAT_R16) },
      { REPS_FMT(VK_FORMAT_R16G16) },
      { REPS_FMT(VK_FORMAT_R16G16B16) },
      { REPS_FMT(VK_FORMAT_R16G16B16A16) },
      {
          VK_FORMAT_R32_UINT,
          VK_FORMAT_R32_SFLOAT,
          VK_FORMAT_R32_SINT,
          VK_FORMAT_R32_UINT,
      },
      {
          VK_FORMAT_R32G32B32_SFLOAT,
          VK_FORMAT_R32G32B32_SFLOAT,
          VK_FORMAT_UNDEFINED,
          VK_FORMAT_UNDEFINED,
      },
      {
          VK_FORMAT_R16G16B16A16_SFLOAT,
          VK_FORMAT_R16G16B16A16_SFLOAT,
          VK_FORMAT_UNDEFINED,
          VK_FORMAT_UNDEFINED,
      },
      {
          VK_FORMAT_R32G32B32A32_SFLOAT,
          VK_FORMAT_R32G32B32A32_SFLOAT,
          VK_FORMAT_UNDEFINED,
          VK_FORMAT_UNDEFINED,
      },
      {
          VK_FORMAT_R32G32B32_UINT,
          VK_FORMAT_UNDEFINED,
          VK_FORMAT_R32G32B32_SINT,
          VK_FORMAT_R32G32B32_UINT,
      },
      {
          VK_FORMAT_R32G32B32A32_UINT,
          VK_FORMAT_UNDEFINED,
          VK_FORMAT_R32G32B32A32_SINT,
          VK_FORMAT_R32G32B32A32_UINT,
      },
      {
          VK_FORMAT_R16_SFLOAT,
          VK_FORMAT_R16_SFLOAT,
          VK_FORMAT_R16_SINT,
          VK_FORMAT_R16_UINT,
      },
  };
2075#undef REPS_FMT_PACK
2076#undef REPS_FMT

  if (fmt == VK_FORMAT_UNDEFINED)
      return VK_FORMAT_UNDEFINED;

  for (int i = 0; i < FF_ARRAY_ELEMS(fmts_map)(sizeof(fmts_map) / sizeof((fmts_map)[0])); i++) {
      if (fmts_map[i][FF_VK_REP_NATIVE] == fmt ||
          fmts_map[i][FF_VK_REP_FLOAT] == fmt ||
          fmts_map[i][FF_VK_REP_INT] == fmt ||
          fmts_map[i][FF_VK_REP_UINT] == fmt)
          return fmts_map[i][rep_fmt];
  }

  return VK_FORMAT_UNDEFINED;
2090}

2092int ff_vk_create_imageview(FFVulkanContext *s,
                         VkImageView *img_view, VkImageAspectFlags *aspect,
                         AVFrame *f, int plane, enum FFVkShaderRepFormat rep_fmt)
2095{
  VkResult ret;
  FFVulkanFunctions *vk = &s->vkfn;
  AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
  AVVulkanFramesContext *vkfc = hwfc->hwctx;
  const VkFormat *rep_fmts = av_vkfmt_from_pixfmt(hwfc->sw_format);
  AVVkFrame *vkf = (AVVkFrame *)f->data[0];
  const int nb_images = ff_vk_count_images(vkf);

  VkImageViewUsageCreateInfo view_usage_info = {
      .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
      .usage = vkfc->usage &
               (~(VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR |
                  VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR)),
  };
  VkImageViewCreateInfo view_create_info = {
      .sType      = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
      .pNext      = &view_usage_info,
      .image      = vkf->img[FFMIN(plane, nb_images - 1)((plane) > (nb_images - 1) ? (nb_images - 1) : (plane))],
      .viewType   = VK_IMAGE_VIEW_TYPE_2D,
      .format     = map_fmt_to_rep(rep_fmts[plane], rep_fmt),
      .components = ff_comp_identity_map,
      .subresourceRange = {
          .aspectMask = ff_vk_aspect_flag(f, plane),
          .levelCount = 1,
          .layerCount = 1,
      },
  };
  if (view_create_info.format == VK_FORMAT_UNDEFINED) {
      av_log(s, AV_LOG_ERROR16, "Unable to find a compatible representation "
                              "of format %i and mode %i\n",
             rep_fmts[plane], rep_fmt);
      return AVERROR(EINVAL)(-(22));
  }

  ret = vk->CreateImageView(s->hwctx->act_dev, &view_create_info,
                            s->hwctx->alloc, img_view);
  if (ret != VK_SUCCESS) {
      av_log(s, AV_LOG_ERROR16, "Failed to create imageview: %s\n",
             ff_vk_ret2str(ret));
      return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
  }

  *aspect = view_create_info.subresourceRange.aspectMask;

  return 0;
2141}

2143int ff_vk_create_imageviews(FFVulkanContext *s, FFVkExecContext *e,
                          VkImageView views[AV_NUM_DATA_POINTERS8],
                          AVFrame *f, enum FFVkShaderRepFormat rep_fmt)
2146{
  int err = 0;
  VkResult ret;
  FFVulkanFunctions *vk = &s->vkfn;
  AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
  AVVulkanFramesContext *vkfc = hwfc->hwctx;
  const VkFormat *rep_fmts = av_vkfmt_from_pixfmt(hwfc->sw_format);
  AVVkFrame *vkf = (AVVkFrame *)f->data[0];
  const int nb_images = ff_vk_count_images(vkf);
  const int nb_planes = av_pix_fmt_count_planes(hwfc->sw_format);
  VkImageView tmp_views[AV_NUM_DATA_POINTERS8] = { 0 };

  for (int i = 0; i < nb_planes; i++) {
      VkImageViewUsageCreateInfo view_usage_info = {
          .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
          .usage = vkfc->usage &
                   (~(VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR |
                      VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR)),
      };
      VkImageViewCreateInfo view_create_info = {
          .sType      = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
          .pNext      = &view_usage_info,
          .image      = vkf->img[FFMIN(i, nb_images - 1)((i) > (nb_images - 1) ? (nb_images - 1) : (i))],
          .viewType   = VK_IMAGE_VIEW_TYPE_2D,
          .format     = map_fmt_to_rep(rep_fmts[i], rep_fmt),
          .components = ff_comp_identity_map,
          .subresourceRange = {
              .aspectMask = ff_vk_aspect_flag(f, i),
              .levelCount = 1,
              .layerCount = 1,
          },
      };
      if (view_create_info.format == VK_FORMAT_UNDEFINED) {
          av_log(s, AV_LOG_ERROR16, "Unable to find a compatible representation "
                                  "of format %i and mode %i\n",
                 rep_fmts[i], rep_fmt);
          err = AVERROR(EINVAL)(-(22));
          goto fail;
      }

      ret = vk->CreateImageView(s->hwctx->act_dev, &view_create_info,
                                s->hwctx->alloc, &tmp_views[i]);
      if (ret != VK_SUCCESS) {
          av_log(s, AV_LOG_ERROR16, "Failed to create imageview: %s\n",
                 ff_vk_ret2str(ret));
          err = AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
          goto fail;
      }
  }

  /* The execution context owns the views, destroying them on completion */
  for (int i = 0; i < nb_planes; i++)
      ff_vk_exec_add_dep_obj(s, e, VK_OBJECT_TYPE_IMAGE_VIEW,
                             (uint64_t)tmp_views[i]);

  memcpy(views, tmp_views, nb_planes*sizeof(*views));

  return 0;

2205fail:
  for (int i = 0; i < nb_planes; i++)
      if (tmp_views[i])
          vk->DestroyImageView(s->hwctx->act_dev, tmp_views[i], s->hwctx->alloc);
  return err;
2210}

2212void ff_vk_frame_barrier(FFVulkanContext *s, FFVkExecContext *e,
                       AVFrame *pic, VkImageMemoryBarrier2 *bar, int *nb_bar,
                       VkPipelineStageFlags2 src_stage,
                       VkPipelineStageFlags2 dst_stage,
                       VkAccessFlagBits2     new_access,
                       VkImageLayout         new_layout,
                       uint32_t              new_qf)
2219{
  int found = -1;
  AVVkFrame *vkf = (AVVkFrame *)pic->data[0];
  const int nb_images = ff_vk_count_images(vkf);
  for (int i = 0; i < e->nb_frame_deps; i++)
      if (e->frame_deps[i]->data[0] == pic->data[0]) {
          if (e->frame_update[i])
              found = i;
          break;
      }

  for (int i = 0; i < nb_images; i++) {
      bar[*nb_bar] = (VkImageMemoryBarrier2) {
          .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
          .pNext = NULL((void*)0),
          .srcStageMask = src_stage,
          .dstStageMask = dst_stage,
          .srcAccessMask = found >= 0 ? e->access_dst[found] : vkf->access[i],
          .dstAccessMask = new_access,
          .oldLayout = found >= 0 ? e->layout_dst[found] : vkf->layout[0],
          .newLayout = new_layout,
          .srcQueueFamilyIndex = found >= 0 ? e->queue_family_dst[found] : vkf->queue_family[0],
          .dstQueueFamilyIndex = new_qf,
          .image = vkf->img[i],
          .subresourceRange = (VkImageSubresourceRange) {
              .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
              .layerCount = 1,
              .levelCount = 1,
          },
      };
      *nb_bar += 1;
  }

  ff_vk_exec_update_frame(s, e, pic, &bar[*nb_bar - nb_images], NULL((void*)0));
2253}

2255int ff_vk_shader_load(FFVulkanShader *shd,
                    VkPipelineStageFlags stage, VkSpecializationInfo *spec,
                    uint32_t wg_size[3], uint32_t required_subgroup_size)
2258{
  shd->stage = stage;
  shd->precompiled = 1;
  shd->specialization_info = spec;
  memcpy(shd->lg_size, wg_size, 3*sizeof(uint32_t));

  shd->subgroup_info = (VkPipelineShaderStageRequiredSubgroupSizeCreateInfo) {
      .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO,
      .requiredSubgroupSize = required_subgroup_size,
  };

  switch (shd->stage) {
  case VK_SHADER_STAGE_ANY_HIT_BIT_KHR:
  case VK_SHADER_STAGE_CALLABLE_BIT_KHR:
  case VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR:
  case VK_SHADER_STAGE_INTERSECTION_BIT_KHR:
  case VK_SHADER_STAGE_MISS_BIT_KHR:
  case VK_SHADER_STAGE_RAYGEN_BIT_KHR:
      shd->bind_point = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR;
      break;
  case VK_SHADER_STAGE_COMPUTE_BIT:
      shd->bind_point = VK_PIPELINE_BIND_POINT_COMPUTE;
      break;
  default:
      shd->bind_point = VK_PIPELINE_BIND_POINT_GRAPHICS;
      break;
  };

  return 0;
2287}

2289static int init_pipeline_layout(FFVulkanContext *s, FFVulkanShader *shd)
2290{
  VkResult ret;
  FFVulkanFunctions *vk = &s->vkfn;
  VkPipelineLayoutCreateInfo pipeline_layout_info;

  /* Finally create the pipeline layout */
  pipeline_layout_info = (VkPipelineLayoutCreateInfo) {
      .sType                  = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
      .pSetLayouts            = shd->desc_layout,
      .setLayoutCount         = shd->nb_descriptor_sets,
      .pushConstantRangeCount = shd->push_consts_num,
      .pPushConstantRanges    = shd->push_consts,
  };

  ret = vk->CreatePipelineLayout(s->hwctx->act_dev, &pipeline_layout_info,
                                 s->hwctx->alloc, &shd->pipeline_layout);
  if (ret != VK_SUCCESS) {
      av_log(s, AV_LOG_ERROR16, "Unable to init pipeline layout: %s\n",
             ff_vk_ret2str(ret));
      return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
  }

  return 0;
2313}

2315static int create_shader_module(FFVulkanContext *s, FFVulkanShader *shd,
                              VkShaderModule *mod,
                              const uint8_t *spirv, size_t spirv_len)
2318{
  VkResult ret;
  FFVulkanFunctions *vk = &s->vkfn;

  VkShaderModuleCreateInfo shader_module_info = {
      .sType    = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
      .pNext    = NULL((void*)0),
      .flags    = 0x0,
      .pCode    = (void *)spirv,
      .codeSize = spirv_len,
  };

  ret = vk->CreateShaderModule(s->hwctx->act_dev, &shader_module_info,
                               s->hwctx->alloc, mod);
  if (ret != VK_SUCCESS) {
      av_log(s, AV_LOG_ERROR16, "Error creating shader module: %s\n",
             ff_vk_ret2str(ret));
      return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
  }

  return 0;
2339}

2341static int init_compute_pipeline(FFVulkanContext *s, FFVulkanShader *shd,
                               VkShaderModule mod, const char *entrypoint)
2343{
  VkResult ret;
  FFVulkanFunctions *vk = &s->vkfn;

  VkComputePipelineCreateInfo pipeline_create_info = {
      .sType  = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
      .flags = 0x0,
      .layout = shd->pipeline_layout,
      .stage = (VkPipelineShaderStageCreateInfo) {
          .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
          .pNext = shd->subgroup_info.requiredSubgroupSize ?
                   &shd->subgroup_info : NULL((void*)0),
          .pName = entrypoint,
          .flags = shd->subgroup_info.requiredSubgroupSize ?
                   VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT : 0x0,
          .stage = shd->stage,
          .module = mod,
          .pSpecializationInfo = shd->specialization_info,
      },
  };

  ret = vk->CreateComputePipelines(s->hwctx->act_dev, VK_NULL_HANDLE((void*)0), 1,
                                   &pipeline_create_info,
                                   s->hwctx->alloc, &shd->pipeline);
  if (ret != VK_SUCCESS) {
      av_log(s, AV_LOG_ERROR16, "Unable to init compute pipeline: %s\n",
             ff_vk_ret2str(ret));
      return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
  }

  return 0;
2374}

2376static int create_shader_object(FFVulkanContext *s, FFVulkanShader *shd,
                              const uint8_t *spirv, size_t spirv_len,
                              size_t *binary_size, const char *entrypoint)
2379{
  VkResult ret;
  FFVulkanFunctions *vk = &s->vkfn;

  VkShaderCreateInfoEXT shader_obj_create = {
      .sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT,
      .pNext = shd->subgroup_info.requiredSubgroupSize ?
               &shd->subgroup_info : NULL((void*)0),
      .flags = shd->subgroup_info.requiredSubgroupSize ?
               VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT : 0x0,
      .stage = shd->stage,
      .nextStage = 0,
      .codeType = VK_SHADER_CODE_TYPE_SPIRV_EXT,
      .pCode = spirv,
      .codeSize = spirv_len,
      .pName = entrypoint,
      .pSetLayouts = shd->desc_layout,
      .setLayoutCount = shd->nb_descriptor_sets,
      .pushConstantRangeCount = shd->push_consts_num,
      .pPushConstantRanges = shd->push_consts,
      .pSpecializationInfo = shd->specialization_info,
  };

  ret = vk->CreateShadersEXT(s->hwctx->act_dev, 1, &shader_obj_create,
                             s->hwctx->alloc, &shd->object);
  if (ret != VK_SUCCESS) {
      av_log(s, AV_LOG_ERROR16, "Unable to create shader object: %s\n",
             ff_vk_ret2str(ret));
      return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
  }

  if (vk->GetShaderBinaryDataEXT(s->hwctx->act_dev, shd->object,
                                 binary_size, NULL((void*)0)) != VK_SUCCESS)
      return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));

  return 0;
2415}

2417static int init_descriptors(FFVulkanContext *s, FFVulkanShader *shd)
2418{
  VkResult ret;
  FFVulkanFunctions *vk = &s->vkfn;

  int has_singular = 0;
  int max_descriptors = 0;
  for (int i = 0; i < shd->nb_descriptor_sets; i++) {
      max_descriptors = FFMAX(max_descriptors, shd->desc_set[i].nb_bindings)((max_descriptors) > (shd->desc_set[i].nb_bindings) ? (
max_descriptors) : (shd->desc_set[i].nb_bindings));
      if (shd->desc_set[i].singular)
          has_singular = 1;
  }
  shd->use_push = (s->extensions & FF_VK_EXT_PUSH_DESCRIPTOR(1ULL << 14)) &&
                  (max_descriptors <= s->push_desc_props.maxPushDescriptors) &&
                  (shd->nb_descriptor_sets == 1) &&
                  (has_singular == 0);

  for (int i = 0; i < shd->nb_descriptor_sets; i++) {
      FFVulkanDescriptorSet *set = &shd->desc_set[i];
      VkDescriptorSetLayoutCreateInfo desc_layout_create = {
          .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
          .bindingCount = set->nb_bindings,
          .pBindings = set->binding,
          .flags = (shd->use_push) ?
                   VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR :
                   0x0,
      };

      ret = vk->CreateDescriptorSetLayout(s->hwctx->act_dev,
                                          &desc_layout_create,
                                          s->hwctx->alloc,
                                          &shd->desc_layout[i]);
      if (ret != VK_SUCCESS) {
          av_log(s, AV_LOG_ERROR16, "Unable to create descriptor set layout: %s",
                 ff_vk_ret2str(ret));
          return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
      }
  }

  return 0;
2457}

2459int ff_vk_shader_link(FFVulkanContext *s, FFVulkanShader *shd,
                    const char *spirv, size_t spirv_len,
                    const char *entrypoint)
2462{
  int err;
  FFVulkanFunctions *vk = &s->vkfn;
  VkSpecializationMapEntry spec_entries[3];
  VkSpecializationInfo spec_info;
  size_t input_size = spirv_len, binary_size = 0;

  if (shd->precompiled) {
      if (!shd->specialization_info) {
          spec_info = (VkSpecializationInfo) {
              .pMapEntries = spec_entries,
              .mapEntryCount = 0,
              .pData = shd->lg_size,
              .dataSize = 0,
          };
          shd->specialization_info = &spec_info;
      }

      VkSpecializationMapEntry *spe = (void *)shd->specialization_info->pMapEntries;
      for (int i = 0; i < 3; i++) {
          spe[shd->specialization_info->mapEntryCount++] = (VkSpecializationMapEntry) {
              .constantID = 253 + i,
              .offset = shd->specialization_info->dataSize + i*sizeof(uint32_t),
              .size = sizeof(uint32_t),
          };
      }

      uint8_t *spd = (uint8_t *)shd->specialization_info->pData;
      memcpy(&spd[shd->specialization_info->dataSize],
             shd->lg_size, 3*sizeof(uint32_t));
      shd->specialization_info->dataSize += 3*sizeof(uint32_t);

2494#if CONFIG_SHADER_COMPRESSION0
      uint8_t *out;
      size_t out_len;
      int ret = ff_zlib_expand(s, &out, &out_len, spirv, spirv_len);
      if (ret < 0)
          return ret;
      spirv = out;
      spirv_len = out_len;
2502#endif
  }

  err = init_descriptors(s, shd);
  if (err < 0)
      goto end;

  err = init_pipeline_layout(s, shd);
  if (err < 0)
      goto end;

  if (s->extensions & FF_VK_EXT_SHADER_OBJECT(1ULL << 13)) {
      err = create_shader_object(s, shd, spirv, spirv_len,
                                 &binary_size, entrypoint);
      if (err < 0)
          goto end;
  } else {
      VkShaderModule mod;
      err = create_shader_module(s, shd, &mod, spirv, spirv_len);
      if (err < 0)
          goto end;

      switch (shd->bind_point) {
      case VK_PIPELINE_BIND_POINT_COMPUTE:
          err = init_compute_pipeline(s, shd, mod, entrypoint);
          break;
      default:
          av_log(s, AV_LOG_ERROR16, "Unsupported shader type: %i\n",
                 shd->bind_point);
          err = AVERROR(EINVAL)(-(22));
          goto end;
          break;
      };

      vk->DestroyShaderModule(s->hwctx->act_dev, mod, s->hwctx->alloc);
      if (err < 0)
          goto end;
  }

  if (shd->name)
      av_log(s, AV_LOG_VERBOSE40, "Shader %s linked, size:", shd->name);
  else
      av_log(s, AV_LOG_VERBOSE40, "Shader linked, size:");

  if (input_size != spirv_len)
      av_log(s, AV_LOG_VERBOSE40, " %zu compressed,", input_size);
  av_log(s, AV_LOG_VERBOSE40, " %zu SPIR-V", spirv_len);
  if (binary_size != spirv_len)
      av_log(s, AV_LOG_VERBOSE40, ", %zu binary", binary_size);
  av_log(s, AV_LOG_VERBOSE40, "\n");

2553end:
  if (shd->precompiled) {
      shd->specialization_info->mapEntryCount -= 3;
      shd->specialization_info->dataSize -= 3*sizeof(uint32_t);
  }
2558#if CONFIG_SHADER_COMPRESSION0
  if (shd->precompiled)
      av_free((void *)spirv);
2561#endif
  return err;
2563}

2565void ff_vk_shader_add_descriptor_set(FFVulkanContext *s, FFVulkanShader *shd,
                                   const FFVulkanDescriptorSetBinding *desc, int nb,
                                   int singular)
2568{
  FFVulkanDescriptorSet *set = &shd->desc_set[shd->nb_descriptor_sets++];
  av_assert1(shd->nb_descriptor_sets < FF_VK_MAX_DESCRIPTOR_SETS)do { if (!(shd->nb_descriptor_sets < 4)) { av_log(((void
*)0), 0, "Assertion %s failed at %s:%d\n", "shd->nb_descriptor_sets < 4"
, "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 2570)
; abort(); } } while (0);
  av_assert1(nb < FF_VK_MAX_DESCRIPTOR_BINDINGS)do { if (!(nb < 16)) { av_log(((void*)0), 0, "Assertion %s failed at %s:%d\n"
, "nb < 16", "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c"
, 2571); abort(); } } while (0);

  for (int i = 0; i < nb; i++) {
      set->binding[i].binding            = i;
      set->binding[i].descriptorType     = desc[i].type;
      set->binding[i].descriptorCount    = FFMAX(desc[i].elems, 1)((desc[i].elems) > (1) ? (desc[i].elems) : (1));
      set->binding[i].stageFlags         = desc[i].stages;
      set->binding[i].pImmutableSamplers = desc[i].samplers;
  }

  for (int i = 0; i < nb; i++) {
      int j;
      for (j = 0; j < shd->nb_desc_pool_size; j++)
          if (shd->desc_pool_size[j].type == desc[i].type)
              break;
      if (j >= shd->nb_desc_pool_size) {
          shd->nb_desc_pool_size++;
          av_assert1(shd->nb_desc_pool_size < FF_VK_MAX_DESCRIPTOR_TYPES)do { if (!(shd->nb_desc_pool_size < 16)) { av_log(((void
*)0), 0, "Assertion %s failed at %s:%d\n", "shd->nb_desc_pool_size < 16"
, "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 2588)
; abort(); } } while (0);
      }

      shd->desc_pool_size[j].type             = desc[i].type;
      shd->desc_pool_size[j].descriptorCount += FFMAX(desc[i].elems, 1)((desc[i].elems) > (1) ? (desc[i].elems) : (1));
  }

  set->singular = singular;
  set->nb_bindings = nb;
2597}

2599int ff_vk_shader_register_exec(FFVulkanContext *s, FFVkExecPool *pool,
                             FFVulkanShader *shd)
2601{
  if (!shd->nb_descriptor_sets)
      return 0;

  FFVulkanShaderData *sd = &pool->reg_shd[pool->nb_reg_shd++];
  av_assert1(pool->nb_reg_shd < FF_VK_MAX_SHADERS)do { if (!(pool->nb_reg_shd < 16)) { av_log(((void*)0),
 0, "Assertion %s failed at %s:%d\n", "pool->nb_reg_shd < 16"
, "/root/firefox-clang/media/ffvpx/libavutil/vulkan.c", 2606)
; abort(); } } while (0);

  sd->shd = shd;
  sd->nb_descriptor_sets = shd->nb_descriptor_sets;

  if (!shd->use_push) {
      VkResult ret;
      FFVulkanFunctions *vk = &s->vkfn;
      VkDescriptorSetLayout *tmp_layouts;
      VkDescriptorSetAllocateInfo set_alloc_info;
      VkDescriptorPoolCreateInfo pool_create_info;

      for (int i = 0; i < shd->nb_desc_pool_size; i++)
          shd->desc_pool_size[i].descriptorCount *= pool->pool_size;

      pool_create_info = (VkDescriptorPoolCreateInfo) {
          .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
          .flags = 0,
          .pPoolSizes = shd->desc_pool_size,
          .poolSizeCount = shd->nb_desc_pool_size,
          .maxSets = sd->nb_descriptor_sets*pool->pool_size,
      };

      ret = vk->CreateDescriptorPool(s->hwctx->act_dev, &pool_create_info,
                                     s->hwctx->alloc, &sd->desc_pool);
      if (ret != VK_SUCCESS) {
          av_log(s, AV_LOG_ERROR16, "Unable to create descriptor pool: %s\n",
                 ff_vk_ret2str(ret));
          return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
      }

      tmp_layouts = av_malloc_array(pool_create_info.maxSets, sizeof(*tmp_layouts));
      if (!tmp_layouts)
          return AVERROR(ENOMEM)(-(12));

      /* Colate each execution context's descriptor set layouts */
      for (int i = 0; i < pool->pool_size; i++)
          for (int j = 0; j < sd->nb_descriptor_sets; j++)
              tmp_layouts[i*sd->nb_descriptor_sets + j] = shd->desc_layout[j];

      set_alloc_info = (VkDescriptorSetAllocateInfo) {
          .sType              = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
          .descriptorPool     = sd->desc_pool,
          .pSetLayouts        = tmp_layouts,
          .descriptorSetCount = pool_create_info.maxSets,
      };

      sd->desc_sets = av_malloc_array(pool_create_info.maxSets,
                                      sizeof(*tmp_layouts));
      if (!sd->desc_sets) {
          av_free(tmp_layouts);
          return AVERROR(ENOMEM)(-(12));
      }
      ret = vk->AllocateDescriptorSets(s->hwctx->act_dev, &set_alloc_info,
                                       sd->desc_sets);
      av_free(tmp_layouts);
      if (ret != VK_SUCCESS) {
          av_log(s, AV_LOG_ERROR16, "Unable to allocate descriptor set: %s\n",
                 ff_vk_ret2str(ret));
          av_freep(&sd->desc_sets);
          return AVERROR_EXTERNAL(-(int)(('E') | (('X') << 8) | (('T') << 16) | ((
unsigned)(' ') << 24)));
      }
  }

  return 0;
2671}

2673static inline const FFVulkanShaderData *get_shd_data(FFVkExecContext *e,
                                                   const FFVulkanShader *shd)
2675{
  for (int i = 0; i < e->parent->nb_reg_shd; i++)
      if (e->parent->reg_shd[i].shd == shd)
          return &e->parent->reg_shd[i];
  return NULL((void*)0);
2680}

2682static inline void update_set_pool_write(FFVulkanContext *s, FFVkExecContext *e,
                                       FFVulkanShader *shd, int set,
                                       VkWriteDescriptorSet *write_info)
2685{
  FFVulkanFunctions *vk = &s->vkfn;
  FFVulkanDescriptorSet *desc_set = &shd->desc_set[set];
  const FFVulkanShaderData *sd = get_shd_data(e, shd);

  if (desc_set->singular) {
      for (int i = 0; i < e->parent->pool_size; i++) {
          write_info->dstSet = sd->desc_sets[i*sd->nb_descriptor_sets + set];
          vk->UpdateDescriptorSets(s->hwctx->act_dev, 1, write_info, 0, NULL((void*)0));
      }
  } else {
      if (shd->use_push) {
          vk->CmdPushDescriptorSetKHR(e->buf,
                                      shd->bind_point,
                                      shd->pipeline_layout,
                                      set, 1,
                                      write_info);
      } else {
          write_info->dstSet = sd->desc_sets[e->idx*sd->nb_descriptor_sets + set];
          vk->UpdateDescriptorSets(s->hwctx->act_dev, 1, write_info, 0, NULL((void*)0));
      }
  }
2707}

2709int ff_vk_shader_update_img(FFVulkanContext *s, FFVkExecContext *e,
                          FFVulkanShader *shd, int set, int bind, int offs,
                          VkImageView view, VkImageLayout layout,
                          VkSampler sampler)
2713{
  FFVulkanDescriptorSet *desc_set = &shd->desc_set[set];

  VkDescriptorImageInfo desc_pool_write_info_img = {
      .sampler = sampler,
      .imageView = view,
      .imageLayout = layout,
  };
  VkWriteDescriptorSet desc_pool_write_info = {
      .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
      .dstBinding = bind,
      .descriptorCount = 1,
      .dstArrayElement = offs,
      .descriptorType = desc_set->binding[bind].descriptorType,
      .pImageInfo = &desc_pool_write_info_img,
  };
  update_set_pool_write(s, e, shd, set, &desc_pool_write_info);

  return 0;
2732}

2734void ff_vk_shader_update_img_array(FFVulkanContext *s, FFVkExecContext *e,
                                 FFVulkanShader *shd, AVFrame *f,
                                 VkImageView *views, int set, int binding,
                                 VkImageLayout layout, VkSampler sampler)
2738{
  AVHWFramesContext *hwfc = (AVHWFramesContext *)f->hw_frames_ctx->data;
  const int nb_planes = av_pix_fmt_count_planes(hwfc->sw_format);

  for (int i = 0; i < nb_planes; i++)
      ff_vk_shader_update_img(s, e, shd, set, binding, i,
                              views[i], layout, sampler);
2745}

2747int ff_vk_shader_update_desc_buffer(FFVulkanContext *s, FFVkExecContext *e,
                                  FFVulkanShader *shd,
                                  int set, int bind, int elem,
                                  FFVkBuffer *buf, VkDeviceSize offset, VkDeviceSize len,
                                  VkFormat fmt)
2752{
  FFVulkanDescriptorSet *desc_set = &shd->desc_set[set];

  VkDescriptorBufferInfo desc_pool_write_info_buf = {
      .buffer = buf->buf,
      .offset = buf->virtual_offset + offset,
      .range = len,
  };
  VkWriteDescriptorSet desc_pool_write_info = {
      .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
      .dstBinding = bind,
      .descriptorCount = 1,
      .dstArrayElement = elem,
      .descriptorType = desc_set->binding[bind].descriptorType,
      .pBufferInfo = &desc_pool_write_info_buf,
  };
  update_set_pool_write(s, e, shd, set, &desc_pool_write_info);

  return 0;
2771}

2773void ff_vk_shader_update_push_const(FFVulkanContext *s, FFVkExecContext *e,
                                  FFVulkanShader *shd,
                                  VkShaderStageFlagBits stage,
                                  int offset, size_t size, void *src)
2777{
  FFVulkanFunctions *vk = &s->vkfn;
  vk->CmdPushConstants(e->buf, shd->pipeline_layout,
                       stage, offset, size, src);
2781}

2783void ff_vk_exec_bind_shader(FFVulkanContext *s, FFVkExecContext *e,
                          const FFVulkanShader *shd)
2785{
  FFVulkanFunctions *vk = &s->vkfn;
  const FFVulkanShaderData *sd = get_shd_data(e, shd);

  if (s->extensions & FF_VK_EXT_SHADER_OBJECT(1ULL << 13)) {
      VkShaderStageFlagBits stages = shd->stage;
      vk->CmdBindShadersEXT(e->buf, 1, &stages, &shd->object);
  } else {
      vk->CmdBindPipeline(e->buf, shd->bind_point, shd->pipeline);
  }

  if (sd && sd->nb_descriptor_sets) {
      if (!shd->use_push) {
          vk->CmdBindDescriptorSets(e->buf, shd->bind_point, shd->pipeline_layout,
                                    0, sd->nb_descriptor_sets,
                                    &sd->desc_sets[e->idx*sd->nb_descriptor_sets],
                                    0, NULL((void*)0));
      }
  }
2804}

2806void ff_vk_shader_free(FFVulkanContext *s, FFVulkanShader *shd)
2807{
  FFVulkanFunctions *vk = &s->vkfn;

2810#if 0
  if (shd->shader.module)
      vk->DestroyShaderModule(s->hwctx->act_dev, shd->shader.module,
                              s->hwctx->alloc);
2814#endif

  if (shd->object)
      vk->DestroyShaderEXT(s->hwctx->act_dev, shd->object, s->hwctx->alloc);
  if (shd->pipeline)
      vk->DestroyPipeline(s->hwctx->act_dev, shd->pipeline, s->hwctx->alloc);
  if (shd->pipeline_layout)
      vk->DestroyPipelineLayout(s->hwctx->act_dev, shd->pipeline_layout,
                                s->hwctx->alloc);

  for (int i = 0; i < shd->nb_descriptor_sets; i++)
      if (shd->desc_layout[i])
          vk->DestroyDescriptorSetLayout(s->hwctx->act_dev, shd->desc_layout[i],
                                         s->hwctx->alloc);
2828}

2830void ff_vk_uninit(FFVulkanContext *s)
2831{
  av_freep(&s->query_props);
  av_freep(&s->qf_props);
  av_freep(&s->video_props);
2835#ifdef VK_KHR_maintenance91
  av_freep(&s->ownership_props);
2837#endif
  av_freep(&s->coop_mat_props);
  av_freep(&s->host_image_copy_layouts);
  av_refstruct_pool_uninit(&s->imageviews_pool);

  av_buffer_unref(&s->device_ref);
  av_buffer_unref(&s->frames_ref);
2844}

2846int ff_vk_init(FFVulkanContext *s, void *log_parent,
             AVBufferRef *device_ref, AVBufferRef *frames_ref)
2848{
  int err;

  static const AVClass vulkan_context_class = {
      .class_name       = "vk",
      .version          = LIBAVUTIL_VERSION_INT((61)<<16 | (1)<<8 | (101)),
      .parent_log_context_offset = offsetof(FFVulkanContext, log_parent)__builtin_offsetof(FFVulkanContext, log_parent),
  };

  memset(s, 0, sizeof(*s));
  s->log_parent = log_parent;
  s->class      = &vulkan_context_class;

  if (frames_ref) {
      s->frames_ref = av_buffer_ref(frames_ref);
      if (!s->frames_ref)
          return AVERROR(ENOMEM)(-(12));

      s->frames = (AVHWFramesContext *)s->frames_ref->data;
      s->hwfc = s->frames->hwctx;

      device_ref = s->frames->device_ref;
  }

  s->device_ref = av_buffer_ref(device_ref);
  if (!s->device_ref) {
      ff_vk_uninit(s);
      return AVERROR(ENOMEM)(-(12));
  }

  s->device = (AVHWDeviceContext *)s->device_ref->data;
  s->hwctx = s->device->hwctx;

  s->extensions = ff_vk_extensions_to_mask(s->hwctx->enabled_dev_extensions,
                                           s->hwctx->nb_enabled_dev_extensions);
  s->extensions |= ff_vk_extensions_to_mask(s->hwctx->enabled_inst_extensions,
                                            s->hwctx->nb_enabled_inst_extensions);

  err = ff_vk_load_functions(s->device, &s->vkfn, s->extensions, 1, 1);
  if (err < 0) {
      ff_vk_uninit(s);
      return err;
  }

  err = ff_vk_load_props(s);
  if (err < 0) {
      ff_vk_uninit(s);
      return err;
  }

  return 0;
2899}