Merge "Revert "Partial revert of aosp/2858589 to avoid Mesa layer for Android"" into main
GitOrigin-RevId: fe6b8b0169fac58b893ce22237d8d6541e1f9c9b
Change-Id: I2501e24d2c5019998f2d8de97f1e7a7e3994ee41
diff --git a/codegen/vulkan/vulkan-docs-next/scripts/cereal/__init__.py b/codegen/vulkan/vulkan-docs-next/scripts/cereal/__init__.py
index 809a177..1966572 100644
--- a/codegen/vulkan/vulkan-docs-next/scripts/cereal/__init__.py
+++ b/codegen/vulkan/vulkan-docs-next/scripts/cereal/__init__.py
@@ -4,7 +4,6 @@
from .extensionstructs import *
from .frontend import *
from .functable import *
-from .mesa_functable import *
from .marshaling import *
from .reservedmarshaling import *
from .counting import *
diff --git a/codegen/vulkan/vulkan-docs-next/scripts/cereal/functable.py b/codegen/vulkan/vulkan-docs-next/scripts/cereal/functable.py
index 016d6ca..2d34150 100644
--- a/codegen/vulkan/vulkan-docs-next/scripts/cereal/functable.py
+++ b/codegen/vulkan/vulkan-docs-next/scripts/cereal/functable.py
@@ -2,6 +2,10 @@
from .common.vulkantypes import \
VulkanAPI, makeVulkanTypeSimple, iterateVulkanType
from .common.vulkantypes import EXCLUDED_APIS
+from .common.vulkantypes import HANDLE_TYPES
+
+import copy
+import re
RESOURCE_TRACKER_ENTRIES = [
"vkEnumerateInstanceExtensionProperties",
@@ -45,6 +49,7 @@
"vkCreateSamplerYcbcrConversionKHR",
"vkDestroySamplerYcbcrConversionKHR",
"vkUpdateDescriptorSetWithTemplate",
+ "vkUpdateDescriptorSetWithTemplateKHR",
"vkGetPhysicalDeviceImageFormatProperties2",
"vkGetPhysicalDeviceImageFormatProperties2KHR",
"vkBeginCommandBuffer",
@@ -67,7 +72,6 @@
"vkAllocateDescriptorSets",
"vkFreeDescriptorSets",
"vkCreateDescriptorSetLayout",
- "vkUpdateDescriptorSets",
"vkCmdExecuteCommands",
"vkCmdBindDescriptorSets",
"vkDestroyDescriptorSetLayout",
@@ -91,13 +95,78 @@
"VkResult" : ["VK_SUCCESS"],
}
-POSTPROCESSES = {
- "vkResetCommandPool" : """if (vkResetCommandPool_VkResult_return == VK_SUCCESS) {
- ResourceTracker::get()->resetCommandPoolStagingInfo(commandPool);
- }""",
- "vkAllocateCommandBuffers" : """if (vkAllocateCommandBuffers_VkResult_return == VK_SUCCESS) {
- ResourceTracker::get()->addToCommandPool(pAllocateInfo->commandPool, pAllocateInfo->commandBufferCount, pCommandBuffers);
- }""",
+HANDWRITTEN_ENTRY_POINTS = [
+ # Instance/device/physical-device special-handling, dispatch tables, etc..
+ "vkCreateInstance",
+ "vkDestroyInstance",
+ "vkGetInstanceProcAddr",
+ "vkEnumerateInstanceVersion",
+ "vkEnumerateInstanceLayerProperties",
+ "vkEnumerateInstanceExtensionProperties",
+ "vkEnumerateDeviceExtensionProperties",
+ "vkGetDeviceProcAddr",
+ "vkEnumeratePhysicalDevices",
+ "vkEnumeratePhysicalDeviceGroups",
+ "vkCreateDevice",
+ "vkDestroyDevice",
+ "vkCreateComputePipelines",
+ # Manual alloc/free + vk_*_init/free() call w/ special params
+ "vkGetDeviceQueue",
+ "vkGetDeviceQueue2",
+ # Command pool/buffer handling
+ "vkCreateCommandPool",
+ "vkDestroyCommandPool",
+ "vkAllocateCommandBuffers",
+ "vkResetCommandPool",
+ "vkFreeCommandBuffers",
+ "vkResetCommandPool",
+ # Special cases to handle struct translations in the pNext chain
+ # TODO: Make a codegen module (use deepcopy as reference) to make this more robust
+ "vkCmdBeginRenderPass2KHR",
+ "vkCmdBeginRenderPass",
+ "vkAllocateMemory",
+ "vkUpdateDescriptorSets",
+ "vkQueueCommitDescriptorSetUpdatesGOOGLE",
+]
+
+# TODO: handles with no equivalent gfxstream objects (yet).
+# Might need some special handling.
+HANDLES_DONT_TRANSLATE = {
+ "VkSurfaceKHR",
+ ## The following objects have no need for mesa counterparts
+ # Allows removal of handwritten create/destroy (for array).
+ "VkDescriptorSet",
+ # Bug in translation
+ "VkSampler",
+ "VkSamplerYcbcrConversion",
+}
+
+# Handles whose gfxstream object have non-base-object vk_ structs
+# Optionally includes array of pairs of extraParams: {index, extraParam}
+# -1 means drop parameter of paramName specified by extraParam
+HANDLES_MESA_VK = {
+ # Handwritten handlers (added here for completeness)
+ "VkInstance" : None,
+ "VkPhysicalDevice" : None,
+ "VkDevice" : None,
+ "VkQueue" : None,
+ "VkCommandPool" : None,
+ "VkCommandBuffer" : None,
+ # Auto-generated creation/destroy
+ "VkDeviceMemory" : None,
+ "VkQueryPool" : None,
+ "VkBuffer" : [[-1, "pMemoryRequirements"]],
+ "VkBufferView" : None,
+ "VkImage" : [[-1, "pMemoryRequirements"]],
+ "VkImageView": [[1, "false /* driver_internal */"]],
+ "VkSampler" : None,
+}
+
+# Types that have a corresponding method for transforming
+# an input list to its internal counterpart
+TYPES_TRANSFORM_LIST_METHOD = {
+ "VkSemaphore",
+ "VkSemaphoreSubmitInfo",
}
def is_cmdbuf_dispatch(api):
@@ -106,6 +175,59 @@
def is_queue_dispatch(api):
return "VkQueue" == api.parameters[0].typeName
+def getCreateParam(api):
+ for param in api.parameters:
+ if param.isCreatedBy(api):
+ return param
+ return None
+
+def getDestroyParam(api):
+ for param in api.parameters:
+ if param.isDestroyedBy(api):
+ return param
+ return None
+
+# i.e. VkQueryPool --> vk_query_pool
+def typeNameToMesaType(typeName):
+ vkTypeNameRegex = "(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])"
+ words = re.split(vkTypeNameRegex, typeName)
+ outputType = "vk"
+ for word in words[1:]:
+ outputType += "_"
+ outputType += word.lower()
+ return outputType
+
+def typeNameToBaseName(typeName):
+ return typeNameToMesaType(typeName)[len("vk_"):]
+
+def paramNameToObjectName(paramName):
+ return "gfxstream_%s" % paramName
+
+def typeNameToVkObjectType(typeName):
+ return "VK_OBJECT_TYPE_%s" % typeNameToBaseName(typeName).upper()
+
+def typeNameToObjectType(typeName):
+ return "gfxstream_vk_%s" % typeNameToBaseName(typeName)
+
+def transformListFuncName(typeName):
+ return "transform%sList" % (typeName)
+
+def hasMesaVkObject(typeName):
+ return typeName in HANDLES_MESA_VK
+
+def isAllocatorParam(param):
+ ALLOCATOR_TYPE_NAME = "VkAllocationCallbacks"
+ return (param.pointerIndirectionLevels == 1
+ and param.isConst
+ and param.typeName == ALLOCATOR_TYPE_NAME)
+
+def isArrayParam(param):
+ return (1 == param.pointerIndirectionLevels
+ and param.isConst
+ and "len" in param.attribs)
+
+INTERNAL_OBJECT_NAME = "internal_object"
+
class VulkanFuncTable(VulkanWrapperGenerator):
def __init__(self, module, typeInfo):
VulkanWrapperGenerator.__init__(self, module, typeInfo)
@@ -119,11 +241,6 @@
def onBegin(self,):
cgen = self.cgen
- cgen.line("static void sOnInvalidDynamicallyCheckedCall(const char* apiname, const char* neededFeature)")
- cgen.beginBlock()
- cgen.stmt("ALOGE(\"invalid call to %s: %s not supported\", apiname, neededFeature)")
- cgen.stmt("abort()")
- cgen.endBlock()
self.module.appendImpl(cgen.swapCode())
pass
@@ -144,264 +261,365 @@
api = typeInfo.apis[name]
self.entries.append(api)
self.entryFeatures.append(self.feature)
+ self.loopVars = ["i", "j", "k", "l", "m", "n"]
+ self.loopVarIndex = 0
- def genEncoderOrResourceTrackerCall(cgen, api, declareResources=True):
- cgen.stmt("AEMU_SCOPED_TRACE(\"%s\")" % api.name)
+ def getNextLoopVar():
+ if self.loopVarIndex >= len(self.loopVars):
+ raise
+ loopVar = self.loopVars[self.loopVarIndex]
+ self.loopVarIndex += 1
+ return loopVar
- if is_cmdbuf_dispatch(api):
- cgen.stmt("auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer)")
- elif is_queue_dispatch(api):
- cgen.stmt("auto vkEnc = ResourceTracker::getQueueEncoder(queue)")
+ def isCompoundType(typeName):
+ return typeInfo.isCompoundType(typeName)
+
+ def handleTranslationRequired(typeName):
+ return typeName in HANDLE_TYPES and typeName not in HANDLES_DONT_TRANSLATE
+
+ def translationRequired(typeName):
+ if isCompoundType(typeName):
+ struct = typeInfo.structs[typeName]
+ for member in struct.members:
+ if translationRequired(member.typeName):
+ return True
+ return False
else:
- cgen.stmt("auto vkEnc = ResourceTracker::getThreadLocalEncoder()")
+ return handleTranslationRequired(typeName)
+
+ def genDestroyGfxstreamObjects():
+ destroyParam = getDestroyParam(api)
+ if not destroyParam:
+ return
+ if not translationRequired(destroyParam.typeName):
+ return
+ objectName = paramNameToObjectName(destroyParam.paramName)
+ allocatorParam = "NULL"
+ for p in api.parameters:
+ if isAllocatorParam(p):
+ allocatorParam = p.paramName
+ if not hasMesaVkObject(destroyParam.typeName):
+ deviceParam = api.parameters[0]
+ if "VkDevice" != deviceParam.typeName:
+ print("ERROR: Unhandled non-VkDevice parameters[0]: %s (for API: %s)" %(deviceParam.typeName, api.name))
+ raise
+ # call vk_object_free() directly
+ mesaObjectDestroy = "(void *)%s" % objectName
+ cgen.funcCall(
+ None,
+ "vk_object_free",
+ ["&%s->vk" % paramNameToObjectName(deviceParam.paramName), allocatorParam, mesaObjectDestroy]
+ )
+ else:
+ baseName = typeNameToBaseName(destroyParam.typeName)
+ # objectName for destroy always at the back
+ mesaObjectPrimary = "&%s->vk" % paramNameToObjectName(api.parameters[0].paramName)
+ mesaObjectDestroy = "&%s->vk" % objectName
+ cgen.funcCall(
+ None,
+ "vk_%s_destroy" % (baseName),
+ [mesaObjectPrimary, allocatorParam, mesaObjectDestroy]
+ )
+
+ def genMesaObjectAlloc(allocCallLhs):
+ deviceParam = api.parameters[0]
+ if "VkDevice" != deviceParam.typeName:
+ print("ERROR: Unhandled non-VkDevice parameters[0]: %s (for API: %s)" %(deviceParam.typeName, api.name))
+ raise
+ allocatorParam = "NULL"
+ for p in api.parameters:
+ if isAllocatorParam(p):
+ allocatorParam = p.paramName
+ createParam = getCreateParam(api)
+ objectType = typeNameToObjectType(createParam.typeName)
+ # Call vk_object_zalloc directly
+ cgen.funcCall(
+ allocCallLhs,
+ "(%s *)vk_object_zalloc" % objectType,
+ ["&%s->vk" % paramNameToObjectName(deviceParam.paramName), allocatorParam, ("sizeof(%s)" % objectType), typeNameToVkObjectType(createParam.typeName)]
+ )
+
+ def genMesaObjectCreate(createCallLhs):
+ def dropParam(params, drop):
+ for p in params:
+ if p == drop:
+ params.remove(p)
+ return params
+ createParam = getCreateParam(api)
+ objectType = "struct %s" % typeNameToObjectType(createParam.typeName)
+ modParams = copy.deepcopy(api.parameters)
+ # Mod params for the vk_%s_create() call i.e. vk_buffer_create()
+ for p in modParams:
+ if p.paramName == createParam.paramName:
+ modParams.remove(p)
+ elif handleTranslationRequired(p.typeName):
+ # Cast handle to the mesa type
+ p.paramName = ("(%s*)%s" % (typeNameToMesaType(p.typeName), paramNameToObjectName(p.paramName)))
+ mesaCreateParams = [p.paramName for p in modParams] + ["sizeof(%s)" % objectType]
+ # Some special handling
+ extraParams = HANDLES_MESA_VK[createParam.typeName]
+ if extraParams:
+ for pair in extraParams:
+ if -1 == pair[0]:
+ mesaCreateParams = dropParam(mesaCreateParams, pair[1])
+ else:
+ mesaCreateParams.insert(pair[0], pair[1])
+ cgen.funcCall(
+ createCallLhs,
+ "(%s *)vk_%s_create" % (objectType, typeNameToBaseName(createParam.typeName)),
+ mesaCreateParams
+ )
+
+ # Alloc/create gfxstream_vk_* object
+ def genCreateGfxstreamObjects():
+ createParam = getCreateParam(api)
+ if not createParam:
+ return False
+ if not handleTranslationRequired(createParam.typeName):
+ return False
+ objectType = "struct %s" % typeNameToObjectType(createParam.typeName)
+ callLhs = "%s *%s" % (objectType, paramNameToObjectName(createParam.paramName))
+ if hasMesaVkObject(createParam.typeName):
+ genMesaObjectCreate(callLhs)
+ else:
+ genMesaObjectAlloc(callLhs)
+
+ retVar = api.getRetVarExpr()
+ if retVar:
+ retTypeName = api.getRetTypeExpr()
+ # ex: vkCreateBuffer_VkResult_return = gfxstream_buffer ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ cgen.stmt("%s = %s ? %s : %s" %
+ (retVar, paramNameToObjectName(createParam.paramName), SUCCESS_VAL[retTypeName][0], "VK_ERROR_OUT_OF_HOST_MEMORY"))
+ return True
+
+ def genVkFromHandle(param, fromName):
+ objectName = paramNameToObjectName(param.paramName)
+ cgen.stmt("VK_FROM_HANDLE(%s, %s, %s)" %
+ (typeNameToObjectType(param.typeName), objectName, fromName))
+ return objectName
+
+ def genGetGfxstreamHandles():
+ createParam = getCreateParam(api)
+ for param in api.parameters:
+ if not handleTranslationRequired(param.typeName):
+ continue
+ elif isArrayParam(param):
+ continue
+ elif param != createParam:
+ if param.pointerIndirectionLevels > 0:
+ print("ERROR: Unhandled pointerIndirectionLevels > 1 for API %s (param %s)" % (api.name, param.paramName))
+ raise
+ genVkFromHandle(param, param.paramName)
+
+ def internalNestedParamName(param):
+ parentName = ""
+ if param.parent:
+ parentName = "_%s" % param.parent.typeName
+ return "internal%s_%s" % (parentName, param.paramName)
+
+ def genInternalArrayDeclarations(param, countParamName, nestLevel=0):
+ internalArray = None
+ if 0 == nestLevel:
+ internalArray = "internal_%s" % param.paramName
+ cgen.stmt("std::vector<%s> %s(%s)" % (param.typeName, internalArray, countParamName))
+ elif 1 == nestLevel or 2 == nestLevel:
+ internalArray = internalNestedParamName(param)
+ if isArrayParam(param):
+ cgen.stmt("std::vector<std::vector<%s>> %s" % (param.typeName, internalArray))
+ else:
+ cgen.stmt("std::vector<%s> %s" % (param.typeName, internalArray))
+ else:
+ print("ERROR: nestLevel > 2 not verified.")
+ raise
+ if isCompoundType(param.typeName):
+ for member in typeInfo.structs[param.typeName].members:
+ if translationRequired(member.typeName):
+ if handleTranslationRequired(member.typeName) and not isArrayParam(member):
+ # No declarations for non-array handleType
+ continue
+ genInternalArrayDeclarations(member, countParamName, nestLevel + 1)
+ return internalArray
+
+ def genInternalCompoundType(param, outName, inName, currLoopVar):
+ nextLoopVar = None
+ cgen.stmt("%s = %s" % (outName, inName))
+ for member in typeInfo.structs[param.typeName].members:
+ if not translationRequired(member.typeName):
+ continue
+ cgen.line("/* %s::%s */" % (param.typeName, member.paramName))
+ nestedOutName = ("%s[%s]" % (internalNestedParamName(member), currLoopVar))
+ if isArrayParam(member):
+ countParamName = "%s.%s" % (outName, member.attribs["len"])
+ inArrayName = "%s.%s" % (outName, member.paramName)
+ cgen.stmt("%s.push_back(std::vector<%s>())" % (internalNestedParamName(member), member.typeName))
+ if member.typeName in TYPES_TRANSFORM_LIST_METHOD:
+ # Use the corresponding transformList call
+ cgen.funcCall(nestedOutName, transformListFuncName(member.typeName), [inArrayName, countParamName])
+ cgen.stmt("%s = %s.data()" % (inArrayName, nestedOutName))
+ cgen.stmt("%s = %s.size()" % (countParamName, nestedOutName))
+ else:
+ # Standard translation
+ cgen.stmt("%s.reserve(%s)" % (nestedOutName, countParamName))
+ cgen.stmt("memset(&%s[0], 0, sizeof(%s) * %s)" % (nestedOutName, member.typeName, countParamName))
+ if not nextLoopVar:
+ nextLoopVar = getNextLoopVar()
+ internalArray = genInternalArray(member, countParamName, nestedOutName, inArrayName, nextLoopVar)
+ cgen.stmt("%s = %s" %(inArrayName, internalArray))
+ elif isCompoundType(member.typeName):
+ memberFullName = "%s.%s" % (outName, member.paramName)
+ if 1 == member.pointerIndirectionLevels:
+ cgen.beginIf(memberFullName)
+ inParamName = "%s[0]" % memberFullName
+ genInternalCompoundType(member, nestedOutName, inParamName, currLoopVar)
+ cgen.stmt("%s.%s = &%s" % (outName, member.paramName, nestedOutName))
+ else:
+ cgen.beginBlock()
+ genInternalCompoundType(member, nestedOutName, memberFullName, currLoopVar)
+ cgen.stmt("%s.%s = %s" % (outName, member.paramName, nestedOutName))
+ cgen.endBlock()
+ else:
+ # Replace member with internal object
+ replaceName = "%s.%s" % (outName, member.paramName)
+ if member.isOptional:
+ cgen.beginIf(replaceName)
+ gfxstreamObject = genVkFromHandle(member, replaceName)
+ cgen.stmt("%s = %s->%s" % (replaceName, gfxstreamObject, INTERNAL_OBJECT_NAME))
+ if member.isOptional:
+ cgen.endIf()
+
+ def genInternalArray(param, countParamName, outArrayName, inArrayName, loopVar):
+ cgen.beginFor("uint32_t %s = 0" % loopVar, "%s < %s" % (loopVar, countParamName), "++%s" % loopVar)
+ if param.isOptional:
+ cgen.beginIf(inArrayName)
+ if isCompoundType(param.typeName):
+ genInternalCompoundType(param, ("%s[%s]" % (outArrayName, loopVar)), "%s[%s]" % (inArrayName, loopVar), loopVar)
+ else:
+ gfxstreamObject = genVkFromHandle(param, "%s[%s]" % (inArrayName, loopVar))
+ cgen.stmt("%s[%s] = %s->%s" % (outArrayName, loopVar, gfxstreamObject, INTERNAL_OBJECT_NAME))
+ if param.isOptional:
+ cgen.endIf()
+ cgen.endFor()
+ return "%s.data()" % outArrayName
+
+ # Translate params into params needed for gfxstream-internal
+ # encoder/resource-tracker calls
+ def getEncoderOrResourceTrackerParams():
+ createParam = getCreateParam(api)
+ outParams = copy.deepcopy(api.parameters)
+ nextLoopVar = getNextLoopVar()
+ for param in outParams:
+ if not translationRequired(param.typeName):
+ continue
+ elif isArrayParam(param) or isCompoundType(param.typeName):
+ if param.possiblyOutput():
+ print("ERROR: Unhandled CompoundType / Array output for API %s (param %s)" % (api.name, param.paramName))
+ raise
+ if 1 != param.pointerIndirectionLevels or not param.isConst:
+ print("ERROR: Compound type / array input is not 'const <type>*' (API: %s, paramName: %s)" % (api.name, param.paramName))
+ raise
+ countParamName = "1"
+ if "len" in param.attribs:
+ countParamName = param.attribs["len"]
+ internalArrayName = genInternalArrayDeclarations(param, countParamName)
+ param.paramName = genInternalArray(param, countParamName, internalArrayName, param.paramName, nextLoopVar)
+ elif 0 == param.pointerIndirectionLevels:
+ if param.isOptional:
+ param.paramName = ("%s ? %s->%s : VK_NULL_HANDLE" % (paramNameToObjectName(param.paramName), paramNameToObjectName(param.paramName), INTERNAL_OBJECT_NAME))
+ else:
+ param.paramName = ("%s->%s" % (paramNameToObjectName(param.paramName), INTERNAL_OBJECT_NAME))
+ elif createParam and param.paramName == createParam.paramName:
+ param.paramName = ("&%s->%s" % (paramNameToObjectName(param.paramName), INTERNAL_OBJECT_NAME))
+ else:
+ print("ERROR: Unknown handling for param: %s (API: %s)" % (param, api.name))
+ raise
+ return outParams
+
+ def genEncoderOrResourceTrackerCall(declareResources=True):
+ if is_cmdbuf_dispatch(api):
+ cgen.stmt("auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(%s->%s)" % (paramNameToObjectName(api.parameters[0].paramName), INTERNAL_OBJECT_NAME))
+ elif is_queue_dispatch(api):
+ cgen.stmt("auto vkEnc = gfxstream::vk::ResourceTracker::getQueueEncoder(%s->%s)" % (paramNameToObjectName(api.parameters[0].paramName), INTERNAL_OBJECT_NAME))
+ else:
+ cgen.stmt("auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder()")
callLhs = None
retTypeName = api.getRetTypeExpr()
if retTypeName != "void":
- retVar = api.getRetVarExpr()
- cgen.stmt("%s %s = (%s)0" % (retTypeName, retVar, retTypeName))
- callLhs = retVar
+ callLhs = api.getRetVarExpr()
+ # Get parameter list modded for gfxstream-internal call
+ parameters = getEncoderOrResourceTrackerParams()
if name in RESOURCE_TRACKER_ENTRIES:
if declareResources:
- cgen.stmt("auto resources = ResourceTracker::get()")
+ cgen.stmt("auto resources = gfxstream::vk::ResourceTracker::get()")
cgen.funcCall(
callLhs, "resources->" + "on_" + api.name,
["vkEnc"] + SUCCESS_VAL.get(retTypeName, []) + \
- [p.paramName for p in api.parameters])
+ [p.paramName for p in parameters])
else:
cgen.funcCall(
- callLhs, "vkEnc->" + api.name, [p.paramName for p in api.parameters] + ["true /* do lock */"])
+ callLhs, "vkEnc->" + api.name, [p.paramName for p in parameters] + ["true /* do lock */"])
- if name in POSTPROCESSES:
- cgen.line(POSTPROCESSES[name])
+ def genReturnExpression():
+ retTypeName = api.getRetTypeExpr()
+ # Set the createParam output, if applicable
+ createParam = getCreateParam(api)
+ if createParam and handleTranslationRequired(createParam.typeName):
+ if 1 != createParam.pointerIndirectionLevels:
+ print("ERROR: Unhandled pointerIndirectionLevels != 1 in return for API %s (createParam %s)" % api.name, createParam.paramName)
+ raise
+ # ex: *pBuffer = gfxstream_vk_buffer_to_handle(gfxstream_buffer)
+ cgen.funcCall(
+ "*%s" % createParam.paramName,
+ "%s_to_handle" % typeNameToObjectType(createParam.typeName),
+ [paramNameToObjectName(createParam.paramName)]
+ )
if retTypeName != "void":
- cgen.stmt("return %s" % retVar)
+ cgen.stmt("return %s" % api.getRetVarExpr())
-
- api_entry = api.withModifiedName("entry_" + api.name)
-
- cgen.line("static " + self.cgen.makeFuncProto(api_entry))
- cgen.beginBlock()
- genEncoderOrResourceTrackerCall(cgen, api)
- cgen.endBlock()
-
- if self.isDeviceDispatch(api) and self.feature != "VK_VERSION_1_0":
- api_entry_dyn_check = api.withModifiedName("dynCheck_entry_" + api.name)
- cgen.line("static " + self.cgen.makeFuncProto(api_entry_dyn_check))
- cgen.beginBlock()
- if self.feature == "VK_VERSION_1_3":
- cgen.stmt("auto resources = ResourceTracker::get()")
- if "VkCommandBuffer" == api.parameters[0].typeName:
- cgen.stmt("VkDevice device = resources->getDevice(commandBuffer)")
- cgen.beginIf("resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3")
- cgen.stmt("sOnInvalidDynamicallyCheckedCall(\"%s\", \"%s\")" % (api.name, self.feature))
+ def genGfxstreamEntry(declareResources=True):
+ cgen.stmt("AEMU_SCOPED_TRACE(\"%s\")" % api.name)
+ # declare returnVar
+ retTypeName = api.getRetTypeExpr()
+ retVar = api.getRetVarExpr()
+ if retVar:
+ cgen.stmt("%s %s = (%s)0" % (retTypeName, retVar, retTypeName))
+ # Check non-null destroy param for free/destroy calls
+ destroyParam = getDestroyParam(api)
+ if destroyParam:
+ cgen.beginIf("VK_NULL_HANDLE == %s" % destroyParam.paramName)
+ if api.getRetTypeExpr() != "void":
+ cgen.stmt("return %s" % api.getRetVarExpr())
+ else:
+ cgen.stmt("return")
cgen.endIf()
- elif self.feature == "VK_VERSION_1_2":
- cgen.stmt("auto resources = ResourceTracker::get()")
- if "VkCommandBuffer" == api.parameters[0].typeName:
- cgen.stmt("VkDevice device = resources->getDevice(commandBuffer)")
- cgen.beginIf("resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2")
- cgen.stmt("sOnInvalidDynamicallyCheckedCall(\"%s\", \"%s\")" % (api.name, self.feature))
- cgen.endIf()
- elif self.feature == "VK_VERSION_1_1":
- cgen.stmt("auto resources = ResourceTracker::get()")
- if "VkCommandBuffer" == api.parameters[0].typeName:
- cgen.stmt("VkDevice device = resources->getDevice(commandBuffer)")
- cgen.beginIf("resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1")
- cgen.stmt("sOnInvalidDynamicallyCheckedCall(\"%s\", \"%s\")" % (api.name, self.feature))
- cgen.endIf()
- elif self.feature != "VK_VERSION_1_0":
- cgen.stmt("auto resources = ResourceTracker::get()")
- if "VkCommandBuffer" == api.parameters[0].typeName:
- cgen.stmt("VkDevice device = resources->getDevice(commandBuffer);")
- cgen.beginIf("!resources->hasDeviceExtension(device, \"%s\")" % self.feature)
- cgen.stmt("sOnInvalidDynamicallyCheckedCall(\"%s\", \"%s\")" % (api.name, self.feature))
- cgen.endIf()
+ # Translate handles
+ genGetGfxstreamHandles()
+ # Translation/creation of objects
+ createdObject = genCreateGfxstreamObjects()
+ # Make encoder/resource-tracker call
+ if retVar and createdObject:
+ cgen.beginIf("%s == %s" % (SUCCESS_VAL[retTypeName][0], retVar))
else:
- print("About to generate a frivolous api!: dynCheck entry: %s" % api.name)
- raise
- genEncoderOrResourceTrackerCall(cgen, api, declareResources = False)
+ cgen.beginBlock()
+ genEncoderOrResourceTrackerCall()
cgen.endBlock()
+ # Destroy gfxstream objects
+ genDestroyGfxstreamObjects()
+ # Set output / return variables
+ genReturnExpression()
- self.module.appendImpl(cgen.swapCode())
+ api_entry = api.withModifiedName("gfxstream_vk_" + api.name[2:])
+ if api.name not in HANDWRITTEN_ENTRY_POINTS:
+ cgen.line(self.cgen.makeFuncProto(api_entry))
+ cgen.beginBlock()
+ genGfxstreamEntry()
+ cgen.endBlock()
+ self.module.appendImpl(cgen.swapCode())
+
def onEnd(self,):
- getProcAddressDecl = "void* goldfish_vulkan_get_proc_address(const char* name)"
- self.module.appendHeader(getProcAddressDecl + ";\n")
- self.module.appendImpl(getProcAddressDecl)
- self.cgen.beginBlock()
-
- prevFeature = None
- for e, f in zip(self.entries, self.entryFeatures):
- featureEndif = prevFeature is not None and (f != prevFeature)
- featureif = not featureEndif and (f != prevFeature)
-
- if featureEndif:
- self.cgen.leftline("#endif")
- self.cgen.leftline("#ifdef %s" % f)
-
- if featureif:
- self.cgen.leftline("#ifdef %s" % f)
-
- self.cgen.beginIf("!strcmp(name, \"%s\")" % e.name)
- if e.name in EXCLUDED_APIS:
- self.cgen.stmt("return nullptr")
- elif f == "VK_VERSION_1_3":
- self.cgen.stmt("return nullptr")
- elif f == "VK_VERSION_1_2":
- self.cgen.stmt("return nullptr")
- elif f == "VK_VERSION_1_1":
- self.cgen.stmt("return nullptr")
- elif f != "VK_VERSION_1_0":
- self.cgen.stmt("return nullptr")
- else:
- self.cgen.stmt("return (void*)%s" % ("entry_" + e.name))
- self.cgen.endIf()
- prevFeature = f
-
- self.cgen.leftline("#endif")
-
- self.cgen.stmt("return nullptr")
- self.cgen.endBlock()
- self.module.appendImpl(self.cgen.swapCode())
-
- getInstanceProcAddressDecl = "void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char* name)"
- self.module.appendHeader(getInstanceProcAddressDecl + ";\n")
- self.module.appendImpl(getInstanceProcAddressDecl)
- self.cgen.beginBlock()
-
- self.cgen.stmt(
- "auto resources = ResourceTracker::get()")
- self.cgen.stmt(
- "bool has1_1OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_1")
- self.cgen.stmt(
- "bool has1_2OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_2")
- self.cgen.stmt(
- "bool has1_3OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_3")
-
- prevFeature = None
- for e, f in zip(self.entries, self.entryFeatures):
- featureEndif = prevFeature is not None and (f != prevFeature)
- featureif = not featureEndif and (f != prevFeature)
-
- if featureEndif:
- self.cgen.leftline("#endif")
- self.cgen.leftline("#ifdef %s" % f)
-
- if featureif:
- self.cgen.leftline("#ifdef %s" % f)
-
- self.cgen.beginIf("!strcmp(name, \"%s\")" % e.name)
-
- entryPointExpr = "(void*)%s" % ("entry_" + e.name)
-
- if e.name in EXCLUDED_APIS:
- self.cgen.stmt("return nullptr")
- elif f == "VK_VERSION_1_3":
- if self.isDeviceDispatch(e):
- self.cgen.stmt("return (void*)dynCheck_entry_%s" % e.name)
- else:
- self.cgen.stmt( \
- "return has1_3OrHigher ? %s : nullptr" % \
- entryPointExpr)
- elif f == "VK_VERSION_1_2":
- if self.isDeviceDispatch(e):
- self.cgen.stmt("return (void*)dynCheck_entry_%s" % e.name)
- else:
- self.cgen.stmt( \
- "return has1_2OrHigher ? %s : nullptr" % \
- entryPointExpr)
- elif f == "VK_VERSION_1_1":
- if self.isDeviceDispatch(e):
- self.cgen.stmt("return (void*)dynCheck_entry_%s" % e.name)
- else:
- self.cgen.stmt( \
- "return has1_1OrHigher ? %s : nullptr" % \
- entryPointExpr)
- elif f != "VK_VERSION_1_0":
- entryNeedsInstanceExtensionCheck = self.cmdToFeatureType[e.name] == "instance"
-
- entryPrefix = "dynCheck_" if self.isDeviceDispatch(e) else ""
- entryPointExpr = "(void*)%sentry_%s" % (entryPrefix, e.name)
-
- if entryNeedsInstanceExtensionCheck:
- self.cgen.stmt("bool hasExt = resources->hasInstanceExtension(instance, \"%s\")" % f)
- self.cgen.stmt("return hasExt ? %s : nullptr" % entryPointExpr)
- else:
- # TODO(b/236246382): We need to check the device extension support here.
- self.cgen.stmt("// TODO(b/236246382): Check support for device extension");
- self.cgen.stmt("return %s" % entryPointExpr)
-
- else:
- self.cgen.stmt("return %s" % entryPointExpr)
- self.cgen.endIf()
- prevFeature = f
-
- self.cgen.leftline("#endif")
-
- self.cgen.stmt("return nullptr")
- self.cgen.endBlock()
- self.module.appendImpl(self.cgen.swapCode())
-
- getDeviceProcAddressDecl = "void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name)"
- self.module.appendHeader(getDeviceProcAddressDecl + ";\n")
- self.module.appendImpl(getDeviceProcAddressDecl)
- self.cgen.beginBlock()
-
- self.cgen.stmt(
- "auto resources = ResourceTracker::get()")
- self.cgen.stmt(
- "bool has1_1OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_1")
- self.cgen.stmt(
- "bool has1_2OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_2")
- self.cgen.stmt(
- "bool has1_3OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_3")
- prevFeature = None
- for e, f in zip(self.entries, self.entryFeatures):
- featureEndif = prevFeature is not None and (f != prevFeature)
- featureif = not featureEndif and (f != prevFeature)
-
- if featureEndif:
- self.cgen.leftline("#endif")
- self.cgen.leftline("#ifdef %s" % f)
-
- if featureif:
- self.cgen.leftline("#ifdef %s" % f)
-
- self.cgen.beginIf("!strcmp(name, \"%s\")" % e.name)
-
- entryPointExpr = "(void*)%s" % ("entry_" + e.name)
-
- if e.name in EXCLUDED_APIS:
- self.cgen.stmt("return nullptr")
- elif f == "VK_VERSION_1_3":
- self.cgen.stmt( \
- "return has1_3OrHigher ? %s : nullptr" % \
- entryPointExpr)
- elif f == "VK_VERSION_1_2":
- self.cgen.stmt( \
- "return has1_2OrHigher ? %s : nullptr" % \
- entryPointExpr)
- elif f == "VK_VERSION_1_1":
- self.cgen.stmt( \
- "return has1_1OrHigher ? %s : nullptr" % \
- entryPointExpr)
- elif f != "VK_VERSION_1_0":
- self.cgen.stmt( \
- "bool hasExt = resources->hasDeviceExtension(device, \"%s\")" % f)
- self.cgen.stmt("return hasExt ? %s : nullptr" % entryPointExpr)
- else:
- self.cgen.stmt("return %s" % entryPointExpr)
- self.cgen.endIf()
- prevFeature = f
-
- self.cgen.leftline("#endif")
-
- self.cgen.stmt("return nullptr")
- self.cgen.endBlock()
-
- self.module.appendImpl(self.cgen.swapCode())
+ pass
def isDeviceDispatch(self, api):
# TODO(230793667): improve the heuristic and just use "cmdToFeatureType"
diff --git a/codegen/vulkan/vulkan-docs-next/scripts/cereal/mesa_functable.py b/codegen/vulkan/vulkan-docs-next/scripts/cereal/mesa_functable.py
deleted file mode 100644
index 34e1edd..0000000
--- a/codegen/vulkan/vulkan-docs-next/scripts/cereal/mesa_functable.py
+++ /dev/null
@@ -1,629 +0,0 @@
-from .common.codegen import CodeGen, VulkanWrapperGenerator
-from .common.vulkantypes import \
- VulkanAPI, makeVulkanTypeSimple, iterateVulkanType
-from .common.vulkantypes import EXCLUDED_APIS
-from .common.vulkantypes import HANDLE_TYPES
-
-import copy
-import re
-
-RESOURCE_TRACKER_ENTRIES = [
- "vkEnumerateInstanceExtensionProperties",
- "vkEnumerateDeviceExtensionProperties",
- "vkEnumeratePhysicalDevices",
- "vkAllocateMemory",
- "vkFreeMemory",
- "vkCreateImage",
- "vkDestroyImage",
- "vkGetImageMemoryRequirements",
- "vkGetImageMemoryRequirements2",
- "vkGetImageMemoryRequirements2KHR",
- "vkBindImageMemory",
- "vkBindImageMemory2",
- "vkBindImageMemory2KHR",
- "vkCreateBuffer",
- "vkDestroyBuffer",
- "vkGetBufferMemoryRequirements",
- "vkGetBufferMemoryRequirements2",
- "vkGetBufferMemoryRequirements2KHR",
- "vkBindBufferMemory",
- "vkBindBufferMemory2",
- "vkBindBufferMemory2KHR",
- "vkCreateSemaphore",
- "vkDestroySemaphore",
- "vkQueueSubmit",
- "vkQueueSubmit2",
- "vkQueueWaitIdle",
- "vkImportSemaphoreFdKHR",
- "vkGetSemaphoreFdKHR",
- # Warning: These need to be defined in vk.xml (currently no-op) {
- "vkGetMemoryFuchsiaHandleKHR",
- "vkGetMemoryFuchsiaHandlePropertiesKHR",
- "vkGetSemaphoreFuchsiaHandleKHR",
- "vkImportSemaphoreFuchsiaHandleKHR",
- # } end Warning: These need to be defined in vk.xml (currently no-op)
- "vkGetAndroidHardwareBufferPropertiesANDROID",
- "vkGetMemoryAndroidHardwareBufferANDROID",
- "vkCreateSamplerYcbcrConversion",
- "vkDestroySamplerYcbcrConversion",
- "vkCreateSamplerYcbcrConversionKHR",
- "vkDestroySamplerYcbcrConversionKHR",
- "vkUpdateDescriptorSetWithTemplate",
- "vkUpdateDescriptorSetWithTemplateKHR",
- "vkGetPhysicalDeviceImageFormatProperties2",
- "vkGetPhysicalDeviceImageFormatProperties2KHR",
- "vkBeginCommandBuffer",
- "vkEndCommandBuffer",
- "vkResetCommandBuffer",
- "vkCreateImageView",
- "vkCreateSampler",
- "vkGetPhysicalDeviceExternalFenceProperties",
- "vkGetPhysicalDeviceExternalFencePropertiesKHR",
- "vkGetPhysicalDeviceExternalBufferProperties",
- "vkGetPhysicalDeviceExternalBufferPropertiesKHR",
- "vkCreateFence",
- "vkResetFences",
- "vkImportFenceFdKHR",
- "vkGetFenceFdKHR",
- "vkWaitForFences",
- "vkCreateDescriptorPool",
- "vkDestroyDescriptorPool",
- "vkResetDescriptorPool",
- "vkAllocateDescriptorSets",
- "vkFreeDescriptorSets",
- "vkCreateDescriptorSetLayout",
- "vkCmdExecuteCommands",
- "vkCmdBindDescriptorSets",
- "vkDestroyDescriptorSetLayout",
- "vkAllocateCommandBuffers",
- "vkQueueSignalReleaseImageANDROID",
- "vkCmdPipelineBarrier",
- "vkCreateGraphicsPipelines",
- # Fuchsia
- "vkGetMemoryZirconHandleFUCHSIA",
- "vkGetMemoryZirconHandlePropertiesFUCHSIA",
- "vkGetSemaphoreZirconHandleFUCHSIA",
- "vkImportSemaphoreZirconHandleFUCHSIA",
- "vkCreateBufferCollectionFUCHSIA",
- "vkDestroyBufferCollectionFUCHSIA",
- "vkSetBufferCollectionImageConstraintsFUCHSIA",
- "vkSetBufferCollectionBufferConstraintsFUCHSIA",
- "vkGetBufferCollectionPropertiesFUCHSIA",
-]
-
-SUCCESS_VAL = {
- "VkResult" : ["VK_SUCCESS"],
-}
-
-HANDWRITTEN_ENTRY_POINTS = [
- # Instance/device/physical-device special-handling, dispatch tables, etc..
- "vkCreateInstance",
- "vkDestroyInstance",
- "vkGetInstanceProcAddr",
- "vkEnumerateInstanceVersion",
- "vkEnumerateInstanceLayerProperties",
- "vkEnumerateInstanceExtensionProperties",
- "vkEnumerateDeviceExtensionProperties",
- "vkGetDeviceProcAddr",
- "vkEnumeratePhysicalDevices",
- "vkEnumeratePhysicalDeviceGroups",
- "vkCreateDevice",
- "vkDestroyDevice",
- "vkCreateComputePipelines",
- # Manual alloc/free + vk_*_init/free() call w/ special params
- "vkGetDeviceQueue",
- "vkGetDeviceQueue2",
- # Command pool/buffer handling
- "vkCreateCommandPool",
- "vkDestroyCommandPool",
- "vkAllocateCommandBuffers",
- "vkResetCommandPool",
- "vkFreeCommandBuffers",
- "vkResetCommandPool",
- # Special cases to handle struct translations in the pNext chain
- # TODO: Make a codegen module (use deepcopy as reference) to make this more robust
- "vkCmdBeginRenderPass2KHR",
- "vkCmdBeginRenderPass",
- "vkAllocateMemory",
- "vkUpdateDescriptorSets",
- "vkQueueCommitDescriptorSetUpdatesGOOGLE",
-]
-
-# TODO: handles with no equivalent gfxstream objects (yet).
-# Might need some special handling.
-HANDLES_DONT_TRANSLATE = {
- "VkSurfaceKHR",
- ## The following objects have no need for mesa counterparts
- # Allows removal of handwritten create/destroy (for array).
- "VkDescriptorSet",
- # Bug in translation
- "VkSampler",
- "VkSamplerYcbcrConversion",
-}
-
-# Handles whose gfxstream object have non-base-object vk_ structs
-# Optionally includes array of pairs of extraParams: {index, extraParam}
-# -1 means drop parameter of paramName specified by extraParam
-HANDLES_MESA_VK = {
- # Handwritten handlers (added here for completeness)
- "VkInstance" : None,
- "VkPhysicalDevice" : None,
- "VkDevice" : None,
- "VkQueue" : None,
- "VkCommandPool" : None,
- "VkCommandBuffer" : None,
- # Auto-generated creation/destroy
- "VkDeviceMemory" : None,
- "VkQueryPool" : None,
- "VkBuffer" : [[-1, "pMemoryRequirements"]],
- "VkBufferView" : None,
- "VkImage" : [[-1, "pMemoryRequirements"]],
- "VkImageView": [[1, "false /* driver_internal */"]],
- "VkSampler" : None,
-}
-
-# Types that have a corresponding method for transforming
-# an input list to its internal counterpart
-TYPES_TRANSFORM_LIST_METHOD = {
- "VkSemaphore",
- "VkSemaphoreSubmitInfo",
-}
-
-def is_cmdbuf_dispatch(api):
- return "VkCommandBuffer" == api.parameters[0].typeName
-
-def is_queue_dispatch(api):
- return "VkQueue" == api.parameters[0].typeName
-
-def getCreateParam(api):
- for param in api.parameters:
- if param.isCreatedBy(api):
- return param
- return None
-
-def getDestroyParam(api):
- for param in api.parameters:
- if param.isDestroyedBy(api):
- return param
- return None
-
-# i.e. VkQueryPool --> vk_query_pool
-def typeNameToMesaType(typeName):
- vkTypeNameRegex = "(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])"
- words = re.split(vkTypeNameRegex, typeName)
- outputType = "vk"
- for word in words[1:]:
- outputType += "_"
- outputType += word.lower()
- return outputType
-
-def typeNameToBaseName(typeName):
- return typeNameToMesaType(typeName)[len("vk_"):]
-
-def paramNameToObjectName(paramName):
- return "gfxstream_%s" % paramName
-
-def typeNameToVkObjectType(typeName):
- return "VK_OBJECT_TYPE_%s" % typeNameToBaseName(typeName).upper()
-
-def typeNameToObjectType(typeName):
- return "gfxstream_vk_%s" % typeNameToBaseName(typeName)
-
-def transformListFuncName(typeName):
- return "transform%sList" % (typeName)
-
-def hasMesaVkObject(typeName):
- return typeName in HANDLES_MESA_VK
-
-def isAllocatorParam(param):
- ALLOCATOR_TYPE_NAME = "VkAllocationCallbacks"
- return (param.pointerIndirectionLevels == 1
- and param.isConst
- and param.typeName == ALLOCATOR_TYPE_NAME)
-
-def isArrayParam(param):
- return (1 == param.pointerIndirectionLevels
- and param.isConst
- and "len" in param.attribs)
-
-INTERNAL_OBJECT_NAME = "internal_object"
-
-class VulkanMesaFuncTable(VulkanWrapperGenerator):
- def __init__(self, module, typeInfo):
- VulkanWrapperGenerator.__init__(self, module, typeInfo)
- self.typeInfo = typeInfo
- self.cgen = CodeGen()
- self.entries = []
- self.entryFeatures = []
- self.cmdToFeatureType = {}
- self.feature = None
- self.featureType = None
-
- def onBegin(self,):
- cgen = self.cgen
- self.module.appendImpl(cgen.swapCode())
- pass
-
- def onBeginFeature(self, featureName, featureType):
- self.feature = featureName
- self.featureType = featureType
-
- def onEndFeature(self):
- self.feature = None
- self.featureType = None
-
- def onFeatureNewCmd(self, name):
- self.cmdToFeatureType[name] = self.featureType
-
- def onGenCmd(self, cmdinfo, name, alias):
- typeInfo = self.typeInfo
- cgen = self.cgen
- api = typeInfo.apis[name]
- self.entries.append(api)
- self.entryFeatures.append(self.feature)
- self.loopVars = ["i", "j", "k", "l", "m", "n"]
- self.loopVarIndex = 0
-
- def getNextLoopVar():
- if self.loopVarIndex >= len(self.loopVars):
- raise
- loopVar = self.loopVars[self.loopVarIndex]
- self.loopVarIndex += 1
- return loopVar
-
- def isCompoundType(typeName):
- return typeInfo.isCompoundType(typeName)
-
- def handleTranslationRequired(typeName):
- return typeName in HANDLE_TYPES and typeName not in HANDLES_DONT_TRANSLATE
-
- def translationRequired(typeName):
- if isCompoundType(typeName):
- struct = typeInfo.structs[typeName]
- for member in struct.members:
- if translationRequired(member.typeName):
- return True
- return False
- else:
- return handleTranslationRequired(typeName)
-
- def genDestroyGfxstreamObjects():
- destroyParam = getDestroyParam(api)
- if not destroyParam:
- return
- if not translationRequired(destroyParam.typeName):
- return
- objectName = paramNameToObjectName(destroyParam.paramName)
- allocatorParam = "NULL"
- for p in api.parameters:
- if isAllocatorParam(p):
- allocatorParam = p.paramName
- if not hasMesaVkObject(destroyParam.typeName):
- deviceParam = api.parameters[0]
- if "VkDevice" != deviceParam.typeName:
- print("ERROR: Unhandled non-VkDevice parameters[0]: %s (for API: %s)" %(deviceParam.typeName, api.name))
- raise
- # call vk_object_free() directly
- mesaObjectDestroy = "(void *)%s" % objectName
- cgen.funcCall(
- None,
- "vk_object_free",
- ["&%s->vk" % paramNameToObjectName(deviceParam.paramName), allocatorParam, mesaObjectDestroy]
- )
- else:
- baseName = typeNameToBaseName(destroyParam.typeName)
- # objectName for destroy always at the back
- mesaObjectPrimary = "&%s->vk" % paramNameToObjectName(api.parameters[0].paramName)
- mesaObjectDestroy = "&%s->vk" % objectName
- cgen.funcCall(
- None,
- "vk_%s_destroy" % (baseName),
- [mesaObjectPrimary, allocatorParam, mesaObjectDestroy]
- )
-
- def genMesaObjectAlloc(allocCallLhs):
- deviceParam = api.parameters[0]
- if "VkDevice" != deviceParam.typeName:
- print("ERROR: Unhandled non-VkDevice parameters[0]: %s (for API: %s)" %(deviceParam.typeName, api.name))
- raise
- allocatorParam = "NULL"
- for p in api.parameters:
- if isAllocatorParam(p):
- allocatorParam = p.paramName
- createParam = getCreateParam(api)
- objectType = typeNameToObjectType(createParam.typeName)
- # Call vk_object_zalloc directly
- cgen.funcCall(
- allocCallLhs,
- "(%s *)vk_object_zalloc" % objectType,
- ["&%s->vk" % paramNameToObjectName(deviceParam.paramName), allocatorParam, ("sizeof(%s)" % objectType), typeNameToVkObjectType(createParam.typeName)]
- )
-
- def genMesaObjectCreate(createCallLhs):
- def dropParam(params, drop):
- for p in params:
- if p == drop:
- params.remove(p)
- return params
- createParam = getCreateParam(api)
- objectType = "struct %s" % typeNameToObjectType(createParam.typeName)
- modParams = copy.deepcopy(api.parameters)
- # Mod params for the vk_%s_create() call i.e. vk_buffer_create()
- for p in modParams:
- if p.paramName == createParam.paramName:
- modParams.remove(p)
- elif handleTranslationRequired(p.typeName):
- # Cast handle to the mesa type
- p.paramName = ("(%s*)%s" % (typeNameToMesaType(p.typeName), paramNameToObjectName(p.paramName)))
- mesaCreateParams = [p.paramName for p in modParams] + ["sizeof(%s)" % objectType]
- # Some special handling
- extraParams = HANDLES_MESA_VK[createParam.typeName]
- if extraParams:
- for pair in extraParams:
- if -1 == pair[0]:
- mesaCreateParams = dropParam(mesaCreateParams, pair[1])
- else:
- mesaCreateParams.insert(pair[0], pair[1])
- cgen.funcCall(
- createCallLhs,
- "(%s *)vk_%s_create" % (objectType, typeNameToBaseName(createParam.typeName)),
- mesaCreateParams
- )
-
- # Alloc/create gfxstream_vk_* object
- def genCreateGfxstreamObjects():
- createParam = getCreateParam(api)
- if not createParam:
- return False
- if not handleTranslationRequired(createParam.typeName):
- return False
- objectType = "struct %s" % typeNameToObjectType(createParam.typeName)
- callLhs = "%s *%s" % (objectType, paramNameToObjectName(createParam.paramName))
- if hasMesaVkObject(createParam.typeName):
- genMesaObjectCreate(callLhs)
- else:
- genMesaObjectAlloc(callLhs)
-
- retVar = api.getRetVarExpr()
- if retVar:
- retTypeName = api.getRetTypeExpr()
- # ex: vkCreateBuffer_VkResult_return = gfxstream_buffer ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- cgen.stmt("%s = %s ? %s : %s" %
- (retVar, paramNameToObjectName(createParam.paramName), SUCCESS_VAL[retTypeName][0], "VK_ERROR_OUT_OF_HOST_MEMORY"))
- return True
-
- def genVkFromHandle(param, fromName):
- objectName = paramNameToObjectName(param.paramName)
- cgen.stmt("VK_FROM_HANDLE(%s, %s, %s)" %
- (typeNameToObjectType(param.typeName), objectName, fromName))
- return objectName
-
- def genGetGfxstreamHandles():
- createParam = getCreateParam(api)
- for param in api.parameters:
- if not handleTranslationRequired(param.typeName):
- continue
- elif isArrayParam(param):
- continue
- elif param != createParam:
- if param.pointerIndirectionLevels > 0:
- print("ERROR: Unhandled pointerIndirectionLevels > 1 for API %s (param %s)" % (api.name, param.paramName))
- raise
- genVkFromHandle(param, param.paramName)
-
- def internalNestedParamName(param):
- parentName = ""
- if param.parent:
- parentName = "_%s" % param.parent.typeName
- return "internal%s_%s" % (parentName, param.paramName)
-
- def genInternalArrayDeclarations(param, countParamName, nestLevel=0):
- internalArray = None
- if 0 == nestLevel:
- internalArray = "internal_%s" % param.paramName
- cgen.stmt("std::vector<%s> %s(%s)" % (param.typeName, internalArray, countParamName))
- elif 1 == nestLevel or 2 == nestLevel:
- internalArray = internalNestedParamName(param)
- if isArrayParam(param):
- cgen.stmt("std::vector<std::vector<%s>> %s" % (param.typeName, internalArray))
- else:
- cgen.stmt("std::vector<%s> %s" % (param.typeName, internalArray))
- else:
- print("ERROR: nestLevel > 2 not verified.")
- raise
- if isCompoundType(param.typeName):
- for member in typeInfo.structs[param.typeName].members:
- if translationRequired(member.typeName):
- if handleTranslationRequired(member.typeName) and not isArrayParam(member):
- # No declarations for non-array handleType
- continue
- genInternalArrayDeclarations(member, countParamName, nestLevel + 1)
- return internalArray
-
- def genInternalCompoundType(param, outName, inName, currLoopVar):
- nextLoopVar = None
- cgen.stmt("%s = %s" % (outName, inName))
- for member in typeInfo.structs[param.typeName].members:
- if not translationRequired(member.typeName):
- continue
- cgen.line("/* %s::%s */" % (param.typeName, member.paramName))
- nestedOutName = ("%s[%s]" % (internalNestedParamName(member), currLoopVar))
- if isArrayParam(member):
- countParamName = "%s.%s" % (outName, member.attribs["len"])
- inArrayName = "%s.%s" % (outName, member.paramName)
- cgen.stmt("%s.push_back(std::vector<%s>())" % (internalNestedParamName(member), member.typeName))
- if member.typeName in TYPES_TRANSFORM_LIST_METHOD:
- # Use the corresponding transformList call
- cgen.funcCall(nestedOutName, transformListFuncName(member.typeName), [inArrayName, countParamName])
- cgen.stmt("%s = %s.data()" % (inArrayName, nestedOutName))
- cgen.stmt("%s = %s.size()" % (countParamName, nestedOutName))
- else:
- # Standard translation
- cgen.stmt("%s.reserve(%s)" % (nestedOutName, countParamName))
- cgen.stmt("memset(&%s[0], 0, sizeof(%s) * %s)" % (nestedOutName, member.typeName, countParamName))
- if not nextLoopVar:
- nextLoopVar = getNextLoopVar()
- internalArray = genInternalArray(member, countParamName, nestedOutName, inArrayName, nextLoopVar)
- cgen.stmt("%s = %s" %(inArrayName, internalArray))
- elif isCompoundType(member.typeName):
- memberFullName = "%s.%s" % (outName, member.paramName)
- if 1 == member.pointerIndirectionLevels:
- cgen.beginIf(memberFullName)
- inParamName = "%s[0]" % memberFullName
- genInternalCompoundType(member, nestedOutName, inParamName, currLoopVar)
- cgen.stmt("%s.%s = &%s" % (outName, member.paramName, nestedOutName))
- else:
- cgen.beginBlock()
- genInternalCompoundType(member, nestedOutName, memberFullName, currLoopVar)
- cgen.stmt("%s.%s = %s" % (outName, member.paramName, nestedOutName))
- cgen.endBlock()
- else:
- # Replace member with internal object
- replaceName = "%s.%s" % (outName, member.paramName)
- if member.isOptional:
- cgen.beginIf(replaceName)
- gfxstreamObject = genVkFromHandle(member, replaceName)
- cgen.stmt("%s = %s->%s" % (replaceName, gfxstreamObject, INTERNAL_OBJECT_NAME))
- if member.isOptional:
- cgen.endIf()
-
- def genInternalArray(param, countParamName, outArrayName, inArrayName, loopVar):
- cgen.beginFor("uint32_t %s = 0" % loopVar, "%s < %s" % (loopVar, countParamName), "++%s" % loopVar)
- if param.isOptional:
- cgen.beginIf(inArrayName)
- if isCompoundType(param.typeName):
- genInternalCompoundType(param, ("%s[%s]" % (outArrayName, loopVar)), "%s[%s]" % (inArrayName, loopVar), loopVar)
- else:
- gfxstreamObject = genVkFromHandle(param, "%s[%s]" % (inArrayName, loopVar))
- cgen.stmt("%s[%s] = %s->%s" % (outArrayName, loopVar, gfxstreamObject, INTERNAL_OBJECT_NAME))
- if param.isOptional:
- cgen.endIf()
- cgen.endFor()
- return "%s.data()" % outArrayName
-
- # Translate params into params needed for gfxstream-internal
- # encoder/resource-tracker calls
- def getEncoderOrResourceTrackerParams():
- createParam = getCreateParam(api)
- outParams = copy.deepcopy(api.parameters)
- nextLoopVar = getNextLoopVar()
- for param in outParams:
- if not translationRequired(param.typeName):
- continue
- elif isArrayParam(param) or isCompoundType(param.typeName):
- if param.possiblyOutput():
- print("ERROR: Unhandled CompoundType / Array output for API %s (param %s)" % (api.name, param.paramName))
- raise
- if 1 != param.pointerIndirectionLevels or not param.isConst:
- print("ERROR: Compound type / array input is not 'const <type>*' (API: %s, paramName: %s)" % (api.name, param.paramName))
- raise
- countParamName = "1"
- if "len" in param.attribs:
- countParamName = param.attribs["len"]
- internalArrayName = genInternalArrayDeclarations(param, countParamName)
- param.paramName = genInternalArray(param, countParamName, internalArrayName, param.paramName, nextLoopVar)
- elif 0 == param.pointerIndirectionLevels:
- if param.isOptional:
- param.paramName = ("%s ? %s->%s : VK_NULL_HANDLE" % (paramNameToObjectName(param.paramName), paramNameToObjectName(param.paramName), INTERNAL_OBJECT_NAME))
- else:
- param.paramName = ("%s->%s" % (paramNameToObjectName(param.paramName), INTERNAL_OBJECT_NAME))
- elif createParam and param.paramName == createParam.paramName:
- param.paramName = ("&%s->%s" % (paramNameToObjectName(param.paramName), INTERNAL_OBJECT_NAME))
- else:
- print("ERROR: Unknown handling for param: %s (API: %s)" % (param, api.name))
- raise
- return outParams
-
- def genEncoderOrResourceTrackerCall(declareResources=True):
- if is_cmdbuf_dispatch(api):
- cgen.stmt("auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(%s->%s)" % (paramNameToObjectName(api.parameters[0].paramName), INTERNAL_OBJECT_NAME))
- elif is_queue_dispatch(api):
- cgen.stmt("auto vkEnc = gfxstream::vk::ResourceTracker::getQueueEncoder(%s->%s)" % (paramNameToObjectName(api.parameters[0].paramName), INTERNAL_OBJECT_NAME))
- else:
- cgen.stmt("auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder()")
- callLhs = None
- retTypeName = api.getRetTypeExpr()
- if retTypeName != "void":
- callLhs = api.getRetVarExpr()
-
- # Get parameter list modded for gfxstream-internal call
- parameters = getEncoderOrResourceTrackerParams()
- if name in RESOURCE_TRACKER_ENTRIES:
- if declareResources:
- cgen.stmt("auto resources = gfxstream::vk::ResourceTracker::get()")
- cgen.funcCall(
- callLhs, "resources->" + "on_" + api.name,
- ["vkEnc"] + SUCCESS_VAL.get(retTypeName, []) + \
- [p.paramName for p in parameters])
- else:
- cgen.funcCall(
- callLhs, "vkEnc->" + api.name, [p.paramName for p in parameters] + ["true /* do lock */"])
-
- def genReturnExpression():
- retTypeName = api.getRetTypeExpr()
- # Set the createParam output, if applicable
- createParam = getCreateParam(api)
- if createParam and handleTranslationRequired(createParam.typeName):
- if 1 != createParam.pointerIndirectionLevels:
- print("ERROR: Unhandled pointerIndirectionLevels != 1 in return for API %s (createParam %s)" % api.name, createParam.paramName)
- raise
- # ex: *pBuffer = gfxstream_vk_buffer_to_handle(gfxstream_buffer)
- cgen.funcCall(
- "*%s" % createParam.paramName,
- "%s_to_handle" % typeNameToObjectType(createParam.typeName),
- [paramNameToObjectName(createParam.paramName)]
- )
-
- if retTypeName != "void":
- cgen.stmt("return %s" % api.getRetVarExpr())
-
- def genGfxstreamEntry(declareResources=True):
- cgen.stmt("AEMU_SCOPED_TRACE(\"%s\")" % api.name)
- # declare returnVar
- retTypeName = api.getRetTypeExpr()
- retVar = api.getRetVarExpr()
- if retVar:
- cgen.stmt("%s %s = (%s)0" % (retTypeName, retVar, retTypeName))
- # Check non-null destroy param for free/destroy calls
- destroyParam = getDestroyParam(api)
- if destroyParam:
- cgen.beginIf("VK_NULL_HANDLE == %s" % destroyParam.paramName)
- if api.getRetTypeExpr() != "void":
- cgen.stmt("return %s" % api.getRetVarExpr())
- else:
- cgen.stmt("return")
- cgen.endIf()
- # Translate handles
- genGetGfxstreamHandles()
- # Translation/creation of objects
- createdObject = genCreateGfxstreamObjects()
- # Make encoder/resource-tracker call
- if retVar and createdObject:
- cgen.beginIf("%s == %s" % (SUCCESS_VAL[retTypeName][0], retVar))
- else:
- cgen.beginBlock()
- genEncoderOrResourceTrackerCall()
- cgen.endBlock()
- # Destroy gfxstream objects
- genDestroyGfxstreamObjects()
- # Set output / return variables
- genReturnExpression()
-
- api_entry = api.withModifiedName("gfxstream_vk_" + api.name[2:])
- if api.name not in HANDWRITTEN_ENTRY_POINTS:
- cgen.line(self.cgen.makeFuncProto(api_entry))
- cgen.beginBlock()
- genGfxstreamEntry()
- cgen.endBlock()
- self.module.appendImpl(cgen.swapCode())
-
-
- def onEnd(self,):
- pass
-
- def isDeviceDispatch(self, api):
- # TODO(230793667): improve the heuristic and just use "cmdToFeatureType"
- return (len(api.parameters) > 0 and
- "VkDevice" == api.parameters[0].typeName) or (
- "VkCommandBuffer" == api.parameters[0].typeName and
- self.cmdToFeatureType.get(api.name, "") == "device")
diff --git a/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py b/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py
index ad4bf1d..aa957f8 100644
--- a/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py
+++ b/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py
@@ -334,26 +334,6 @@
#include "VkEncoder.h"
#include "../OpenglSystemCommon/HostConnection.h"
#include "ResourceTracker.h"
-
-#include "goldfish_vk_private_defs.h"
-
-#include <log/log.h>
-#include <cstring>
-
-// Stuff we are not going to use but if included,
-// will cause compile errors. These are Android Vulkan
-// required extensions, but the approach will be to
-// implement them completely on the guest side.
-#undef VK_KHR_android_surface
-#if defined(LINUX_GUEST_BUILD) || defined(__Fuchsia__)
-#undef VK_ANDROID_native_buffer
-#endif
-"""
-
- mesaFunctableImplInclude = """
-#include "VkEncoder.h"
-#include "../OpenglSystemCommon/HostConnection.h"
-#include "ResourceTracker.h"
#include "gfxstream_vk_entrypoints.h"
#include "gfxstream_vk_private.h"
@@ -371,7 +351,6 @@
#undef VK_ANDROID_native_buffer
#endif
"""
-
marshalIncludeGuest = """
#include "goldfish_vk_marshaling_guest.h"
#include "goldfish_vk_private_defs.h"
@@ -614,9 +593,8 @@
suppressVulkanHeaders=True,
extraHeader=createVkExtensionStructureTypePreamble('VK_GOOGLE_GFXSTREAM'))
- self.addGuestEncoderModule("func_table", extraImpl=functableImplInclude)
- self.addGuestEncoderModule("mesa_func_table", extraImpl=mesaFunctableImplInclude, implOnly = True,
- useNamespace = False)
+ self.addGuestEncoderModule("func_table", extraImpl=functableImplInclude, implOnly = True,
+ useNamespace = False)
self.addWrapper(cereal.VulkanEncoder, "VkEncoder")
self.addWrapper(cereal.VulkanExtensionStructs, "goldfish_vk_extension_structs_guest", variant = "guest")
@@ -626,7 +604,6 @@
self.addWrapper(cereal.VulkanCounting, "goldfish_vk_counting_guest")
self.addWrapper(cereal.VulkanTransform, "goldfish_vk_transform_guest")
self.addWrapper(cereal.VulkanFuncTable, "func_table")
- self.addWrapper(cereal.VulkanMesaFuncTable, "mesa_func_table")
self.addWrapper(cereal.VulkanGfxstreamStructureType,
"vulkan_gfxstream_structure_type_guest")
diff --git a/common/end2end/GfxstreamEnd2EndVkTests.cpp b/common/end2end/GfxstreamEnd2EndVkTests.cpp
index 319b7ee..2400994 100644
--- a/common/end2end/GfxstreamEnd2EndVkTests.cpp
+++ b/common/end2end/GfxstreamEnd2EndVkTests.cpp
@@ -626,30 +626,6 @@
}
}
-TEST_P(GfxstreamEnd2EndVkTest, PhysicalDeviceGroup) {
- auto [instance, physicalDevice, device, queue, queueFamilyIndex] =
- VK_ASSERT(SetUpTypicalVkTestEnvironment());
-
- const vkhpp::DeviceGroupDeviceCreateInfo deviceGroupDeviceCreateInfo = {
- .physicalDeviceCount = 1,
- .pPhysicalDevices = &physicalDevice,
- };
-
- const float queuePriority = 1.0f;
- const vkhpp::DeviceQueueCreateInfo deviceQueueCreateInfo = {
- .queueFamilyIndex = 0,
- .queueCount = 1,
- .pQueuePriorities = &queuePriority,
- };
- const vkhpp::DeviceCreateInfo deviceCreateInfo = {
- .pNext = &deviceGroupDeviceCreateInfo,
- .pQueueCreateInfos = &deviceQueueCreateInfo,
- .queueCreateInfoCount = 1,
- };
- auto device2 = VK_ASSERT_RV(physicalDevice.createDeviceUnique(deviceCreateInfo));
- ASSERT_THAT(device2, IsValidHandle());
-}
-
std::vector<TestParams> GenerateTestCases() {
std::vector<TestParams> cases = {TestParams{
.with_gl = false,
diff --git a/guest/vulkan/gfxstream_vk_android.cpp b/guest/vulkan/gfxstream_vk_android.cpp
index 9a180af..9b07c2b 100644
--- a/guest/vulkan/gfxstream_vk_android.cpp
+++ b/guest/vulkan/gfxstream_vk_android.cpp
@@ -4,175 +4,65 @@
*/
#include <errno.h>
+#include <hardware/hardware.h>
#include <hardware/hwvulkan.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <vulkan/vk_icd.h>
-#include "HostConnection.h"
-#include "ProcessPipe.h"
-#include "ResourceTracker.h"
-#include "VkEncoder.h"
-#include "func_table.h"
+#include "gfxstream_vk_entrypoints.h"
+#include "util/macros.h"
-namespace {
+static int gfxstream_vk_hal_open(const struct hw_module_t* mod, const char* id,
+ struct hw_device_t** dev);
+static int gfxstream_vk_hal_close(struct hw_device_t* dev);
-#define VK_HOST_CONNECTION(ret) \
- HostConnection* hostCon = HostConnection::getOrCreate(kCapsetGfxStreamVulkan); \
- gfxstream::vk::VkEncoder* vkEnc = hostCon->vkEncoder(); \
- if (!vkEnc) { \
- ALOGE("vulkan: Failed to get Vulkan encoder\n"); \
- return ret; \
- }
+static_assert(HWVULKAN_DISPATCH_MAGIC == ICD_LOADER_MAGIC, "");
-HostConnection* getConnection(void) {
- auto hostCon = HostConnection::get();
- return hostCon;
-}
-
-gfxstream::vk::VkEncoder* getVkEncoder(HostConnection* con) { return con->vkEncoder(); }
-
-gfxstream::vk::ResourceTracker::ThreadingCallbacks threadingCallbacks = {
- .hostConnectionGetFunc = getConnection,
- .vkEncoderGetFunc = getVkEncoder,
+hw_module_methods_t gfxstream_vk_hal_ops = {
+ .open = gfxstream_vk_hal_open,
};
-VkResult SetupInstance(void) {
- HostConnection* hostCon = HostConnection::getOrCreate(kCapsetGfxStreamVulkan);
- if (!hostCon) {
- ALOGE("vulkan: Failed to get host connection\n");
- return VK_ERROR_DEVICE_LOST;
- }
-
- uint32_t noRenderControlEnc = 0;
- gfxstream::vk::ResourceTracker::get()->setupCaps(noRenderControlEnc);
- // Legacy goldfish path: could be deleted once goldfish not used guest-side.
- if (!noRenderControlEnc) {
- // Implicitly sets up sequence number
- ExtendedRCEncoderContext* rcEnc = hostCon->rcEncoder();
- if (!rcEnc) {
- ALOGE("vulkan: Failed to get renderControl encoder context\n");
- return VK_ERROR_DEVICE_LOST;
- }
-
- gfxstream::vk::ResourceTracker::get()->setupFeatures(rcEnc->featureInfo_const());
- }
-
- gfxstream::vk::ResourceTracker::get()->setThreadingCallbacks(threadingCallbacks);
- gfxstream::vk::ResourceTracker::get()->setSeqnoPtr(getSeqnoPtrForProcess());
- gfxstream::vk::VkEncoder* vkEnc = hostCon->vkEncoder();
- if (!vkEnc) {
- ALOGE("vulkan: Failed to get Vulkan encoder\n");
- return VK_ERROR_DEVICE_LOST;
- }
-
- return VK_SUCCESS;
-}
-
-VKAPI_ATTR
-VkResult EnumerateInstanceExtensionProperties(const char* layer_name, uint32_t* count,
- VkExtensionProperties* properties) {
- VkResult res = SetupInstance();
- if (res != VK_SUCCESS) {
- return res;
- }
-
- VK_HOST_CONNECTION(VK_ERROR_DEVICE_LOST)
-
- res = gfxstream::vk::ResourceTracker::get()->on_vkEnumerateInstanceExtensionProperties(
- vkEnc, VK_SUCCESS, layer_name, count, properties);
-
- return res;
-}
-
-VKAPI_ATTR
-VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
- const VkAllocationCallbacks* allocator, VkInstance* out_instance) {
- VkResult res = SetupInstance();
- if (res != VK_SUCCESS) {
- return res;
- }
-
- VK_HOST_CONNECTION(VK_ERROR_DEVICE_LOST)
- res = vkEnc->vkCreateInstance(create_info, nullptr, out_instance, true /* do lock */);
-
- return res;
-}
-
-PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* name) {
- VK_HOST_CONNECTION(nullptr)
-
- if (!strcmp(name, "vkGetDeviceProcAddr")) {
- return (PFN_vkVoidFunction)(GetDeviceProcAddr);
- }
- return (
- PFN_vkVoidFunction)(gfxstream::vk::goldfish_vulkan_get_device_proc_address(device, name));
-}
-
-VKAPI_ATTR
-PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name) {
- VkResult res = SetupInstance();
- if (res != VK_SUCCESS) {
- return nullptr;
- }
-
- VK_HOST_CONNECTION(nullptr)
-
- if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
- return (PFN_vkVoidFunction)EnumerateInstanceExtensionProperties;
- }
- if (!strcmp(name, "vkCreateInstance")) {
- return (PFN_vkVoidFunction)CreateInstance;
- }
- if (!strcmp(name, "vkGetDeviceProcAddr")) {
- return (PFN_vkVoidFunction)(GetDeviceProcAddr);
- }
- return (PFN_vkVoidFunction)(gfxstream::vk::goldfish_vulkan_get_instance_proc_address(instance,
- name));
-}
-
-} // namespace
-
-int OpenDevice(const hw_module_t* /*module*/, const char* id, hw_device_t** device);
-int CloseDevice(struct hw_device_t* /*device*/);
-
-hw_module_methods_t gfxstream_vulkan_module_methods = {
- .open = OpenDevice,
-};
-
-__attribute__((visibility("default"))) hwvulkan_module_t HAL_MODULE_INFO_SYM = {
+PUBLIC struct hwvulkan_module_t HAL_MODULE_INFO_SYM = {
.common =
{
.tag = HARDWARE_MODULE_TAG,
.module_api_version = HWVULKAN_MODULE_API_VERSION_0_1,
- .hal_api_version = HARDWARE_HAL_API_VERSION,
+ .hal_api_version = HARDWARE_MAKE_API_VERSION(1, 0),
.id = HWVULKAN_HARDWARE_MODULE_ID,
- .name = "Gfxstream Vulkan Driver",
- .author = "The Android Open Source Project",
- .methods = &gfxstream_vulkan_module_methods,
+ .name = "gfxstream Vulkan HAL",
+ .author = "Android Open Source Project",
+ .methods = &(gfxstream_vk_hal_ops),
},
};
-hwvulkan_device_t gfxstream_vulkan_device = {
- .common =
- {
- .tag = HARDWARE_DEVICE_TAG,
- .version = HWVULKAN_DEVICE_API_VERSION_0_1,
- .module = &HAL_MODULE_INFO_SYM.common,
- .close = CloseDevice,
- },
- .EnumerateInstanceExtensionProperties = EnumerateInstanceExtensionProperties,
- .CreateInstance = CreateInstance,
- .GetInstanceProcAddr = GetInstanceProcAddr,
-};
+static int gfxstream_vk_hal_open(const struct hw_module_t* mod, const char* id,
+ struct hw_device_t** dev) {
+ assert(mod == &HAL_MODULE_INFO_SYM.common);
+ assert(strcmp(id, HWVULKAN_DEVICE_0) == 0);
-int OpenDevice(const hw_module_t* /*module*/, const char* id, hw_device_t** device) {
- if (strcmp(id, HWVULKAN_DEVICE_0) == 0) {
- *device = &gfxstream_vulkan_device.common;
- gfxstream::vk::ResourceTracker::get();
- return 0;
- }
- return -ENOENT;
+ hwvulkan_device_t* hal_dev = (hwvulkan_device_t*)calloc(1, sizeof(*hal_dev));
+ if (!hal_dev) return -1;
+
+ *hal_dev = (hwvulkan_device_t){
+ .common =
+ {
+ .tag = HARDWARE_DEVICE_TAG,
+ .version = HWVULKAN_DEVICE_API_VERSION_0_1,
+ .module = &HAL_MODULE_INFO_SYM.common,
+ .close = gfxstream_vk_hal_close,
+ },
+ .EnumerateInstanceExtensionProperties = gfxstream_vk_EnumerateInstanceExtensionProperties,
+ .CreateInstance = gfxstream_vk_CreateInstance,
+ .GetInstanceProcAddr = gfxstream_vk_GetInstanceProcAddr,
+ };
+
+ *dev = &hal_dev->common;
+ return 0;
}
-int CloseDevice(struct hw_device_t* /*device*/) { return 0; }
+static int gfxstream_vk_hal_close(struct hw_device_t* dev) {
+ /* hwvulkan.h claims that hw_device_t::close() is never called. */
+ return -1;
+}
diff --git a/guest/vulkan_enc/func_table.cpp b/guest/vulkan_enc/func_table.cpp
index 8f626c7..6cccf3f 100644
--- a/guest/vulkan_enc/func_table.cpp
+++ b/guest/vulkan_enc/func_table.cpp
@@ -30,8 +30,6 @@
// $CEREAL_OUTPUT_DIR
//
-#include "func_table.h"
-
#include <log/log.h>
#include <cstring>
@@ -39,6 +37,8 @@
#include "../OpenglSystemCommon/HostConnection.h"
#include "ResourceTracker.h"
#include "VkEncoder.h"
+#include "gfxstream_vk_entrypoints.h"
+#include "gfxstream_vk_private.h"
#include "goldfish_vk_private_defs.h"
// Stuff we are not going to use but if included,
@@ -49,2119 +49,3587 @@
#if defined(LINUX_GUEST_BUILD) || defined(__Fuchsia__)
#undef VK_ANDROID_native_buffer
#endif
-
-namespace gfxstream {
-namespace vk {
-
-static void sOnInvalidDynamicallyCheckedCall(const char* apiname, const char* neededFeature) {
- ALOGE("invalid call to %s: %s not supported", apiname, neededFeature);
- abort();
-}
#ifdef VK_VERSION_1_0
-static VkResult entry_vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkInstance* pInstance) {
- AEMU_SCOPED_TRACE("vkCreateInstance");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateInstance_VkResult_return = (VkResult)0;
- vkCreateInstance_VkResult_return =
- vkEnc->vkCreateInstance(pCreateInfo, pAllocator, pInstance, true /* do lock */);
- return vkCreateInstance_VkResult_return;
-}
-static void entry_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyInstance");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyInstance(instance, pAllocator, true /* do lock */);
-}
-static VkResult entry_vkEnumeratePhysicalDevices(VkInstance instance,
- uint32_t* pPhysicalDeviceCount,
- VkPhysicalDevice* pPhysicalDevices) {
- AEMU_SCOPED_TRACE("vkEnumeratePhysicalDevices");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkEnumeratePhysicalDevices_VkResult_return = resources->on_vkEnumeratePhysicalDevices(
- vkEnc, VK_SUCCESS, instance, pPhysicalDeviceCount, pPhysicalDevices);
- return vkEnumeratePhysicalDevices_VkResult_return;
-}
-static void entry_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures* pFeatures) {
+void gfxstream_vk_GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures* pFeatures) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceFeatures(gfxstream_physicalDevice->internal_object, pFeatures,
+ true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties* pFormatProperties) {
+void gfxstream_vk_GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties* pFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceFormatProperties(gfxstream_physicalDevice->internal_object,
+ format, pFormatProperties, true /* do lock */);
+ }
}
-static VkResult entry_vkGetPhysicalDeviceImageFormatProperties(
+VkResult gfxstream_vk_GetPhysicalDeviceImageFormatProperties(
VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling,
VkImageUsageFlags usage, VkImageCreateFlags flags,
VkImageFormatProperties* pImageFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceImageFormatProperties_VkResult_return =
- vkEnc->vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage,
- flags, pImageFormatProperties,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetPhysicalDeviceImageFormatProperties_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceImageFormatProperties(
+ gfxstream_physicalDevice->internal_object, format, type, tiling, usage, flags,
+ pImageFormatProperties, true /* do lock */);
+ }
return vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
}
-static void entry_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties* pProperties) {
+void gfxstream_vk_GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceProperties(physicalDevice, pProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceProperties(gfxstream_physicalDevice->internal_object, pProperties,
+ true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceQueueFamilyProperties(
+void gfxstream_vk_GetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties* pQueueFamilyProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount,
- pQueueFamilyProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceQueueFamilyProperties(gfxstream_physicalDevice->internal_object,
+ pQueueFamilyPropertyCount,
+ pQueueFamilyProperties, true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceMemoryProperties(
+void gfxstream_vk_GetPhysicalDeviceMemoryProperties(
VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceMemoryProperties(gfxstream_physicalDevice->internal_object,
+ pMemoryProperties, true /* do lock */);
+ }
}
-static PFN_vkVoidFunction entry_vkGetInstanceProcAddr(VkInstance instance, const char* pName) {
- AEMU_SCOPED_TRACE("vkGetInstanceProcAddr");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
- vkGetInstanceProcAddr_PFN_vkVoidFunction_return =
- vkEnc->vkGetInstanceProcAddr(instance, pName, true /* do lock */);
- return vkGetInstanceProcAddr_PFN_vkVoidFunction_return;
-}
-static PFN_vkVoidFunction entry_vkGetDeviceProcAddr(VkDevice device, const char* pName) {
- AEMU_SCOPED_TRACE("vkGetDeviceProcAddr");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
- vkGetDeviceProcAddr_PFN_vkVoidFunction_return =
- vkEnc->vkGetDeviceProcAddr(device, pName, true /* do lock */);
- return vkGetDeviceProcAddr_PFN_vkVoidFunction_return;
-}
-static VkResult entry_vkCreateDevice(VkPhysicalDevice physicalDevice,
- const VkDeviceCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
- AEMU_SCOPED_TRACE("vkCreateDevice");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateDevice_VkResult_return = (VkResult)0;
- vkCreateDevice_VkResult_return =
- vkEnc->vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice, true /* do lock */);
- return vkCreateDevice_VkResult_return;
-}
-static void entry_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyDevice");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyDevice(device, pAllocator, true /* do lock */);
-}
-static VkResult entry_vkEnumerateInstanceExtensionProperties(const char* pLayerName,
- uint32_t* pPropertyCount,
- VkExtensionProperties* pProperties) {
- AEMU_SCOPED_TRACE("vkEnumerateInstanceExtensionProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkEnumerateInstanceExtensionProperties_VkResult_return =
- resources->on_vkEnumerateInstanceExtensionProperties(vkEnc, VK_SUCCESS, pLayerName,
- pPropertyCount, pProperties);
- return vkEnumerateInstanceExtensionProperties_VkResult_return;
-}
-static VkResult entry_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
- const char* pLayerName,
- uint32_t* pPropertyCount,
- VkExtensionProperties* pProperties) {
- AEMU_SCOPED_TRACE("vkEnumerateDeviceExtensionProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkEnumerateDeviceExtensionProperties_VkResult_return =
- resources->on_vkEnumerateDeviceExtensionProperties(vkEnc, VK_SUCCESS, physicalDevice,
- pLayerName, pPropertyCount, pProperties);
- return vkEnumerateDeviceExtensionProperties_VkResult_return;
-}
-static VkResult entry_vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
- VkLayerProperties* pProperties) {
- AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
- vkEnumerateInstanceLayerProperties_VkResult_return =
- vkEnc->vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties, true /* do lock */);
- return vkEnumerateInstanceLayerProperties_VkResult_return;
-}
-static VkResult entry_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkLayerProperties* pProperties) {
+VkResult gfxstream_vk_EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties) {
AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
- vkEnumerateDeviceLayerProperties_VkResult_return = vkEnc->vkEnumerateDeviceLayerProperties(
- physicalDevice, pPropertyCount, pProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnumerateDeviceLayerProperties_VkResult_return = vkEnc->vkEnumerateDeviceLayerProperties(
+ gfxstream_physicalDevice->internal_object, pPropertyCount, pProperties,
+ true /* do lock */);
+ }
return vkEnumerateDeviceLayerProperties_VkResult_return;
}
-static void entry_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex,
- VkQueue* pQueue) {
- AEMU_SCOPED_TRACE("vkGetDeviceQueue");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue, true /* do lock */);
-}
-static VkResult entry_vkQueueSubmit(VkQueue queue, uint32_t submitCount,
- const VkSubmitInfo* pSubmits, VkFence fence) {
+VkResult gfxstream_vk_QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits,
+ VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueSubmit");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkQueueSubmit_VkResult_return =
- resources->on_vkQueueSubmit(vkEnc, VK_SUCCESS, queue, submitCount, pSubmits, fence);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkSubmitInfo> internal_pSubmits(submitCount);
+ std::vector<std::vector<VkSemaphore>> internal_VkSubmitInfo_pWaitSemaphores;
+ std::vector<std::vector<VkCommandBuffer>> internal_VkSubmitInfo_pCommandBuffers;
+ std::vector<std::vector<VkSemaphore>> internal_VkSubmitInfo_pSignalSemaphores;
+ for (uint32_t i = 0; i < submitCount; ++i) {
+ internal_pSubmits[i] = pSubmits[i];
+ /* VkSubmitInfo::pWaitSemaphores */
+ internal_VkSubmitInfo_pWaitSemaphores.push_back(std::vector<VkSemaphore>());
+ internal_VkSubmitInfo_pWaitSemaphores[i] = transformVkSemaphoreList(
+ internal_pSubmits[i].pWaitSemaphores, internal_pSubmits[i].waitSemaphoreCount);
+ internal_pSubmits[i].pWaitSemaphores = internal_VkSubmitInfo_pWaitSemaphores[i].data();
+ internal_pSubmits[i].waitSemaphoreCount =
+ internal_VkSubmitInfo_pWaitSemaphores[i].size();
+ /* VkSubmitInfo::pCommandBuffers */
+ internal_VkSubmitInfo_pCommandBuffers.push_back(std::vector<VkCommandBuffer>());
+ internal_VkSubmitInfo_pCommandBuffers[i].reserve(
+ internal_pSubmits[i].commandBufferCount);
+ memset(&internal_VkSubmitInfo_pCommandBuffers[i][0], 0,
+ sizeof(VkCommandBuffer) * internal_pSubmits[i].commandBufferCount);
+ for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferCount; ++j) {
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_pCommandBuffers,
+ internal_pSubmits[i].pCommandBuffers[j]);
+ internal_VkSubmitInfo_pCommandBuffers[i][j] =
+ gfxstream_pCommandBuffers->internal_object;
+ }
+ internal_pSubmits[i].pCommandBuffers = internal_VkSubmitInfo_pCommandBuffers[i].data();
+ /* VkSubmitInfo::pSignalSemaphores */
+ internal_VkSubmitInfo_pSignalSemaphores.push_back(std::vector<VkSemaphore>());
+ internal_VkSubmitInfo_pSignalSemaphores[i] = transformVkSemaphoreList(
+ internal_pSubmits[i].pSignalSemaphores, internal_pSubmits[i].signalSemaphoreCount);
+ internal_pSubmits[i].pSignalSemaphores =
+ internal_VkSubmitInfo_pSignalSemaphores[i].data();
+ internal_pSubmits[i].signalSemaphoreCount =
+ internal_VkSubmitInfo_pSignalSemaphores[i].size();
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkQueueSubmit_VkResult_return = resources->on_vkQueueSubmit(
+ vkEnc, VK_SUCCESS, gfxstream_queue->internal_object, submitCount,
+ internal_pSubmits.data(),
+ gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE);
+ }
return vkQueueSubmit_VkResult_return;
}
-static VkResult entry_vkQueueWaitIdle(VkQueue queue) {
+VkResult gfxstream_vk_QueueWaitIdle(VkQueue queue) {
AEMU_SCOPED_TRACE("vkQueueWaitIdle");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkQueueWaitIdle_VkResult_return = resources->on_vkQueueWaitIdle(vkEnc, VK_SUCCESS, queue);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkQueueWaitIdle_VkResult_return =
+ resources->on_vkQueueWaitIdle(vkEnc, VK_SUCCESS, gfxstream_queue->internal_object);
+ }
return vkQueueWaitIdle_VkResult_return;
}
-static VkResult entry_vkDeviceWaitIdle(VkDevice device) {
+VkResult gfxstream_vk_DeviceWaitIdle(VkDevice device) {
AEMU_SCOPED_TRACE("vkDeviceWaitIdle");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
- vkDeviceWaitIdle_VkResult_return = vkEnc->vkDeviceWaitIdle(device, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkDeviceWaitIdle_VkResult_return =
+ vkEnc->vkDeviceWaitIdle(gfxstream_device->internal_object, true /* do lock */);
+ }
return vkDeviceWaitIdle_VkResult_return;
}
-static VkResult entry_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDeviceMemory* pMemory) {
- AEMU_SCOPED_TRACE("vkAllocateMemory");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkAllocateMemory_VkResult_return = resources->on_vkAllocateMemory(
- vkEnc, VK_SUCCESS, device, pAllocateInfo, pAllocator, pMemory);
- return vkAllocateMemory_VkResult_return;
-}
-static void entry_vkFreeMemory(VkDevice device, VkDeviceMemory memory,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_FreeMemory(VkDevice device, VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkFreeMemory");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkFreeMemory(vkEnc, device, memory, pAllocator);
+ if (VK_NULL_HANDLE == memory) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkFreeMemory(
+ vkEnc, gfxstream_device->internal_object,
+ gfxstream_memory ? gfxstream_memory->internal_object : VK_NULL_HANDLE, pAllocator);
+ }
+ vk_device_memory_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_memory->vk);
}
-static VkResult entry_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset,
- VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
+VkResult gfxstream_vk_MapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset,
+ VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
AEMU_SCOPED_TRACE("vkMapMemory");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkMapMemory_VkResult_return = (VkResult)0;
- vkMapMemory_VkResult_return =
- vkEnc->vkMapMemory(device, memory, offset, size, flags, ppData, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkMapMemory_VkResult_return =
+ vkEnc->vkMapMemory(gfxstream_device->internal_object, gfxstream_memory->internal_object,
+ offset, size, flags, ppData, true /* do lock */);
+ }
return vkMapMemory_VkResult_return;
}
-static void entry_vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
+void gfxstream_vk_UnmapMemory(VkDevice device, VkDeviceMemory memory) {
AEMU_SCOPED_TRACE("vkUnmapMemory");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUnmapMemory(device, memory, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkUnmapMemory(gfxstream_device->internal_object, gfxstream_memory->internal_object,
+ true /* do lock */);
+ }
}
-static VkResult entry_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
- const VkMappedMemoryRange* pMemoryRanges) {
+VkResult gfxstream_vk_FlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges) {
AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
- vkFlushMappedMemoryRanges_VkResult_return = vkEnc->vkFlushMappedMemoryRanges(
- device, memoryRangeCount, pMemoryRanges, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkMappedMemoryRange> internal_pMemoryRanges(memoryRangeCount);
+ for (uint32_t i = 0; i < memoryRangeCount; ++i) {
+ internal_pMemoryRanges[i] = pMemoryRanges[i];
+ /* VkMappedMemoryRange::memory */
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_pMemoryRanges[i].memory);
+ internal_pMemoryRanges[i].memory = gfxstream_memory->internal_object;
+ }
+ vkFlushMappedMemoryRanges_VkResult_return =
+ vkEnc->vkFlushMappedMemoryRanges(gfxstream_device->internal_object, memoryRangeCount,
+ internal_pMemoryRanges.data(), true /* do lock */);
+ }
return vkFlushMappedMemoryRanges_VkResult_return;
}
-static VkResult entry_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
- const VkMappedMemoryRange* pMemoryRanges) {
+VkResult gfxstream_vk_InvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges) {
AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
- vkInvalidateMappedMemoryRanges_VkResult_return = vkEnc->vkInvalidateMappedMemoryRanges(
- device, memoryRangeCount, pMemoryRanges, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkMappedMemoryRange> internal_pMemoryRanges(memoryRangeCount);
+ for (uint32_t i = 0; i < memoryRangeCount; ++i) {
+ internal_pMemoryRanges[i] = pMemoryRanges[i];
+ /* VkMappedMemoryRange::memory */
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_pMemoryRanges[i].memory);
+ internal_pMemoryRanges[i].memory = gfxstream_memory->internal_object;
+ }
+ vkInvalidateMappedMemoryRanges_VkResult_return = vkEnc->vkInvalidateMappedMemoryRanges(
+ gfxstream_device->internal_object, memoryRangeCount, internal_pMemoryRanges.data(),
+ true /* do lock */);
+ }
return vkInvalidateMappedMemoryRanges_VkResult_return;
}
-static void entry_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
- VkDeviceSize* pCommittedMemoryInBytes) {
+void gfxstream_vk_GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
+ VkDeviceSize* pCommittedMemoryInBytes) {
AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceMemoryCommitment(gfxstream_device->internal_object,
+ gfxstream_memory->internal_object,
+ pCommittedMemoryInBytes, true /* do lock */);
+ }
}
-static VkResult entry_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
- VkDeviceSize memoryOffset) {
+VkResult gfxstream_vk_BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
+ VkDeviceSize memoryOffset) {
AEMU_SCOPED_TRACE("vkBindBufferMemory");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkBindBufferMemory_VkResult_return =
- resources->on_vkBindBufferMemory(vkEnc, VK_SUCCESS, device, buffer, memory, memoryOffset);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkBindBufferMemory_VkResult_return = resources->on_vkBindBufferMemory(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, gfxstream_buffer->internal_object,
+ gfxstream_memory->internal_object, memoryOffset);
+ }
return vkBindBufferMemory_VkResult_return;
}
-static VkResult entry_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory,
- VkDeviceSize memoryOffset) {
+VkResult gfxstream_vk_BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory,
+ VkDeviceSize memoryOffset) {
AEMU_SCOPED_TRACE("vkBindImageMemory");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkBindImageMemory_VkResult_return =
- resources->on_vkBindImageMemory(vkEnc, VK_SUCCESS, device, image, memory, memoryOffset);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkBindImageMemory_VkResult_return = resources->on_vkBindImageMemory(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, gfxstream_image->internal_object,
+ gfxstream_memory->internal_object, memoryOffset);
+ }
return vkBindImageMemory_VkResult_return;
}
-static void entry_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
- VkMemoryRequirements* pMemoryRequirements) {
+void gfxstream_vk_GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetBufferMemoryRequirements(vkEnc, device, buffer, pMemoryRequirements);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetBufferMemoryRequirements(vkEnc, gfxstream_device->internal_object,
+ gfxstream_buffer->internal_object,
+ pMemoryRequirements);
+ }
}
-static void entry_vkGetImageMemoryRequirements(VkDevice device, VkImage image,
- VkMemoryRequirements* pMemoryRequirements) {
+void gfxstream_vk_GetImageMemoryRequirements(VkDevice device, VkImage image,
+ VkMemoryRequirements* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetImageMemoryRequirements(vkEnc, device, image, pMemoryRequirements);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetImageMemoryRequirements(vkEnc, gfxstream_device->internal_object,
+ gfxstream_image->internal_object,
+ pMemoryRequirements);
+ }
}
-static void entry_vkGetImageSparseMemoryRequirements(
+void gfxstream_vk_GetImageSparseMemoryRequirements(
VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetImageSparseMemoryRequirements(
+ gfxstream_device->internal_object, gfxstream_image->internal_object,
+ pSparseMemoryRequirementCount, pSparseMemoryRequirements, true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceSparseImageFormatProperties(
+void gfxstream_vk_GetPhysicalDeviceSparseImageFormatProperties(
VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling,
uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples,
- usage, tiling, pPropertyCount,
- pProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties(
+ gfxstream_physicalDevice->internal_object, format, type, samples, usage, tiling,
+ pPropertyCount, pProperties, true /* do lock */);
+ }
}
-static VkResult entry_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
- const VkBindSparseInfo* pBindInfo, VkFence fence) {
+VkResult gfxstream_vk_QueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueBindSparse");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
- vkQueueBindSparse_VkResult_return =
- vkEnc->vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkBindSparseInfo> internal_pBindInfo(bindInfoCount);
+ std::vector<std::vector<VkSemaphore>> internal_VkBindSparseInfo_pWaitSemaphores;
+ std::vector<std::vector<VkSparseBufferMemoryBindInfo>>
+ internal_VkBindSparseInfo_pBufferBinds;
+ std::vector<std::vector<VkSparseMemoryBind>> internal_VkSparseBufferMemoryBindInfo_pBinds;
+ std::vector<std::vector<VkSparseImageOpaqueMemoryBindInfo>>
+ internal_VkBindSparseInfo_pImageOpaqueBinds;
+ std::vector<std::vector<VkSparseMemoryBind>>
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds;
+ std::vector<std::vector<VkSparseImageMemoryBindInfo>> internal_VkBindSparseInfo_pImageBinds;
+ std::vector<std::vector<VkSparseImageMemoryBind>>
+ internal_VkSparseImageMemoryBindInfo_pBinds;
+ std::vector<std::vector<VkSemaphore>> internal_VkBindSparseInfo_pSignalSemaphores;
+ for (uint32_t i = 0; i < bindInfoCount; ++i) {
+ internal_pBindInfo[i] = pBindInfo[i];
+ /* VkBindSparseInfo::pWaitSemaphores */
+ internal_VkBindSparseInfo_pWaitSemaphores.push_back(std::vector<VkSemaphore>());
+ internal_VkBindSparseInfo_pWaitSemaphores[i] = transformVkSemaphoreList(
+ internal_pBindInfo[i].pWaitSemaphores, internal_pBindInfo[i].waitSemaphoreCount);
+ internal_pBindInfo[i].pWaitSemaphores =
+ internal_VkBindSparseInfo_pWaitSemaphores[i].data();
+ internal_pBindInfo[i].waitSemaphoreCount =
+ internal_VkBindSparseInfo_pWaitSemaphores[i].size();
+ /* VkBindSparseInfo::pBufferBinds */
+ internal_VkBindSparseInfo_pBufferBinds.push_back(
+ std::vector<VkSparseBufferMemoryBindInfo>());
+ internal_VkBindSparseInfo_pBufferBinds[i].reserve(
+ internal_pBindInfo[i].bufferBindCount);
+ memset(&internal_VkBindSparseInfo_pBufferBinds[i][0], 0,
+ sizeof(VkSparseBufferMemoryBindInfo) * internal_pBindInfo[i].bufferBindCount);
+ for (uint32_t j = 0; j < internal_pBindInfo[i].bufferBindCount; ++j) {
+ internal_VkBindSparseInfo_pBufferBinds[i][j] =
+ internal_pBindInfo[i].pBufferBinds[j];
+ /* VkSparseBufferMemoryBindInfo::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkBindSparseInfo_pBufferBinds[i][j].buffer);
+ internal_VkBindSparseInfo_pBufferBinds[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ /* VkSparseBufferMemoryBindInfo::pBinds */
+ internal_VkSparseBufferMemoryBindInfo_pBinds.push_back(
+ std::vector<VkSparseMemoryBind>());
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j].reserve(
+ internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount);
+ memset(&internal_VkSparseBufferMemoryBindInfo_pBinds[j][0], 0,
+ sizeof(VkSparseMemoryBind) *
+ internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount);
+ for (uint32_t k = 0; k < internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount;
+ ++k) {
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j][k] =
+ internal_VkBindSparseInfo_pBufferBinds[i][j].pBinds[k];
+ /* VkSparseMemoryBind::memory */
+ if (internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory) {
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory);
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory =
+ gfxstream_memory->internal_object;
+ }
+ }
+ internal_VkBindSparseInfo_pBufferBinds[i][j].pBinds =
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j].data();
+ }
+ internal_pBindInfo[i].pBufferBinds = internal_VkBindSparseInfo_pBufferBinds[i].data();
+ /* VkBindSparseInfo::pImageOpaqueBinds */
+ internal_VkBindSparseInfo_pImageOpaqueBinds.push_back(
+ std::vector<VkSparseImageOpaqueMemoryBindInfo>());
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i].reserve(
+ internal_pBindInfo[i].imageOpaqueBindCount);
+ memset(&internal_VkBindSparseInfo_pImageOpaqueBinds[i][0], 0,
+ sizeof(VkSparseImageOpaqueMemoryBindInfo) *
+ internal_pBindInfo[i].imageOpaqueBindCount);
+ for (uint32_t j = 0; j < internal_pBindInfo[i].imageOpaqueBindCount; ++j) {
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j] =
+ internal_pBindInfo[i].pImageOpaqueBinds[j];
+ /* VkSparseImageOpaqueMemoryBindInfo::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].image);
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].image =
+ gfxstream_image->internal_object;
+ /* VkSparseImageOpaqueMemoryBindInfo::pBinds */
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds.push_back(
+ std::vector<VkSparseMemoryBind>());
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j].reserve(
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount);
+ memset(&internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][0], 0,
+ sizeof(VkSparseMemoryBind) *
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount);
+ for (uint32_t l = 0;
+ l < internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount; ++l) {
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l] =
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].pBinds[l];
+ /* VkSparseMemoryBind::memory */
+ if (internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory) {
+ VK_FROM_HANDLE(
+ gfxstream_vk_device_memory, gfxstream_memory,
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory);
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory =
+ gfxstream_memory->internal_object;
+ }
+ }
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].pBinds =
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j].data();
+ }
+ internal_pBindInfo[i].pImageOpaqueBinds =
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i].data();
+ /* VkBindSparseInfo::pImageBinds */
+ internal_VkBindSparseInfo_pImageBinds.push_back(
+ std::vector<VkSparseImageMemoryBindInfo>());
+ internal_VkBindSparseInfo_pImageBinds[i].reserve(internal_pBindInfo[i].imageBindCount);
+ memset(&internal_VkBindSparseInfo_pImageBinds[i][0], 0,
+ sizeof(VkSparseImageMemoryBindInfo) * internal_pBindInfo[i].imageBindCount);
+ for (uint32_t j = 0; j < internal_pBindInfo[i].imageBindCount; ++j) {
+ internal_VkBindSparseInfo_pImageBinds[i][j] = internal_pBindInfo[i].pImageBinds[j];
+ /* VkSparseImageMemoryBindInfo::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkBindSparseInfo_pImageBinds[i][j].image);
+ internal_VkBindSparseInfo_pImageBinds[i][j].image =
+ gfxstream_image->internal_object;
+ /* VkSparseImageMemoryBindInfo::pBinds */
+ internal_VkSparseImageMemoryBindInfo_pBinds.push_back(
+ std::vector<VkSparseImageMemoryBind>());
+ internal_VkSparseImageMemoryBindInfo_pBinds[j].reserve(
+ internal_VkBindSparseInfo_pImageBinds[i][j].bindCount);
+ memset(&internal_VkSparseImageMemoryBindInfo_pBinds[j][0], 0,
+ sizeof(VkSparseImageMemoryBind) *
+ internal_VkBindSparseInfo_pImageBinds[i][j].bindCount);
+ for (uint32_t m = 0; m < internal_VkBindSparseInfo_pImageBinds[i][j].bindCount;
+ ++m) {
+ internal_VkSparseImageMemoryBindInfo_pBinds[j][m] =
+ internal_VkBindSparseInfo_pImageBinds[i][j].pBinds[m];
+ /* VkSparseImageMemoryBind::memory */
+ if (internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory) {
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory);
+ internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory =
+ gfxstream_memory->internal_object;
+ }
+ }
+ internal_VkBindSparseInfo_pImageBinds[i][j].pBinds =
+ internal_VkSparseImageMemoryBindInfo_pBinds[j].data();
+ }
+ internal_pBindInfo[i].pImageBinds = internal_VkBindSparseInfo_pImageBinds[i].data();
+ /* VkBindSparseInfo::pSignalSemaphores */
+ internal_VkBindSparseInfo_pSignalSemaphores.push_back(std::vector<VkSemaphore>());
+ internal_VkBindSparseInfo_pSignalSemaphores[i] =
+ transformVkSemaphoreList(internal_pBindInfo[i].pSignalSemaphores,
+ internal_pBindInfo[i].signalSemaphoreCount);
+ internal_pBindInfo[i].pSignalSemaphores =
+ internal_VkBindSparseInfo_pSignalSemaphores[i].data();
+ internal_pBindInfo[i].signalSemaphoreCount =
+ internal_VkBindSparseInfo_pSignalSemaphores[i].size();
+ }
+ vkQueueBindSparse_VkResult_return = vkEnc->vkQueueBindSparse(
+ gfxstream_queue->internal_object, bindInfoCount, internal_pBindInfo.data(),
+ gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+ true /* do lock */);
+ }
return vkQueueBindSparse_VkResult_return;
}
-static VkResult entry_vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
+VkResult gfxstream_vk_CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
AEMU_SCOPED_TRACE("vkCreateFence");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateFence_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateFence_VkResult_return =
- resources->on_vkCreateFence(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pFence);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_fence* gfxstream_pFence = (gfxstream_vk_fence*)vk_object_zalloc(
+ &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_fence), VK_OBJECT_TYPE_FENCE);
+ vkCreateFence_VkResult_return = gfxstream_pFence ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateFence_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateFence_VkResult_return = resources->on_vkCreateFence(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pFence->internal_object);
+ }
+ *pFence = gfxstream_vk_fence_to_handle(gfxstream_pFence);
return vkCreateFence_VkResult_return;
}
-static void entry_vkDestroyFence(VkDevice device, VkFence fence,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyFence(VkDevice device, VkFence fence,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyFence");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyFence(device, fence, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == fence) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyFence(gfxstream_device->internal_object,
+ gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_fence);
}
-static VkResult entry_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
+VkResult gfxstream_vk_ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
AEMU_SCOPED_TRACE("vkResetFences");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkResetFences_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkResetFences_VkResult_return =
- resources->on_vkResetFences(vkEnc, VK_SUCCESS, device, fenceCount, pFences);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkFence> internal_pFences(fenceCount);
+ for (uint32_t i = 0; i < fenceCount; ++i) {
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_pFences, pFences[i]);
+ internal_pFences[i] = gfxstream_pFences->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkResetFences_VkResult_return =
+ resources->on_vkResetFences(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ fenceCount, internal_pFences.data());
+ }
return vkResetFences_VkResult_return;
}
-static VkResult entry_vkGetFenceStatus(VkDevice device, VkFence fence) {
+VkResult gfxstream_vk_GetFenceStatus(VkDevice device, VkFence fence) {
AEMU_SCOPED_TRACE("vkGetFenceStatus");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
- vkGetFenceStatus_VkResult_return = vkEnc->vkGetFenceStatus(device, fence, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetFenceStatus_VkResult_return =
+ vkEnc->vkGetFenceStatus(gfxstream_device->internal_object,
+ gfxstream_fence->internal_object, true /* do lock */);
+ }
return vkGetFenceStatus_VkResult_return;
}
-static VkResult entry_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences,
- VkBool32 waitAll, uint64_t timeout) {
+VkResult gfxstream_vk_WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences,
+ VkBool32 waitAll, uint64_t timeout) {
AEMU_SCOPED_TRACE("vkWaitForFences");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkWaitForFences_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkWaitForFences_VkResult_return = resources->on_vkWaitForFences(
- vkEnc, VK_SUCCESS, device, fenceCount, pFences, waitAll, timeout);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkFence> internal_pFences(fenceCount);
+ for (uint32_t i = 0; i < fenceCount; ++i) {
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_pFences, pFences[i]);
+ internal_pFences[i] = gfxstream_pFences->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkWaitForFences_VkResult_return =
+ resources->on_vkWaitForFences(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ fenceCount, internal_pFences.data(), waitAll, timeout);
+ }
return vkWaitForFences_VkResult_return;
}
-static VkResult entry_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSemaphore* pSemaphore) {
+VkResult gfxstream_vk_CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSemaphore* pSemaphore) {
AEMU_SCOPED_TRACE("vkCreateSemaphore");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateSemaphore_VkResult_return = resources->on_vkCreateSemaphore(
- vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSemaphore);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_semaphore* gfxstream_pSemaphore = (gfxstream_vk_semaphore*)vk_object_zalloc(
+ &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_semaphore),
+ VK_OBJECT_TYPE_SEMAPHORE);
+ vkCreateSemaphore_VkResult_return =
+ gfxstream_pSemaphore ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateSemaphore_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateSemaphore_VkResult_return = resources->on_vkCreateSemaphore(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pSemaphore->internal_object);
+ }
+ *pSemaphore = gfxstream_vk_semaphore_to_handle(gfxstream_pSemaphore);
return vkCreateSemaphore_VkResult_return;
}
-static void entry_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroySemaphore(VkDevice device, VkSemaphore semaphore,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySemaphore");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkDestroySemaphore(vkEnc, device, semaphore, pAllocator);
+ if (VK_NULL_HANDLE == semaphore) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore, semaphore);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkDestroySemaphore(
+ vkEnc, gfxstream_device->internal_object,
+ gfxstream_semaphore ? gfxstream_semaphore->internal_object : VK_NULL_HANDLE,
+ pAllocator);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_semaphore);
}
-static VkResult entry_vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
+VkResult gfxstream_vk_CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
AEMU_SCOPED_TRACE("vkCreateEvent");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateEvent_VkResult_return = (VkResult)0;
- vkCreateEvent_VkResult_return =
- vkEnc->vkCreateEvent(device, pCreateInfo, pAllocator, pEvent, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_event* gfxstream_pEvent = (gfxstream_vk_event*)vk_object_zalloc(
+ &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_event), VK_OBJECT_TYPE_EVENT);
+ vkCreateEvent_VkResult_return = gfxstream_pEvent ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateEvent_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreateEvent_VkResult_return =
+ vkEnc->vkCreateEvent(gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pEvent->internal_object, true /* do lock */);
+ }
+ *pEvent = gfxstream_vk_event_to_handle(gfxstream_pEvent);
return vkCreateEvent_VkResult_return;
}
-static void entry_vkDestroyEvent(VkDevice device, VkEvent event,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyEvent(VkDevice device, VkEvent event,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyEvent");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyEvent(device, event, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == event) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyEvent(gfxstream_device->internal_object,
+ gfxstream_event ? gfxstream_event->internal_object : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_event);
}
-static VkResult entry_vkGetEventStatus(VkDevice device, VkEvent event) {
+VkResult gfxstream_vk_GetEventStatus(VkDevice device, VkEvent event) {
AEMU_SCOPED_TRACE("vkGetEventStatus");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
- vkGetEventStatus_VkResult_return = vkEnc->vkGetEventStatus(device, event, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetEventStatus_VkResult_return =
+ vkEnc->vkGetEventStatus(gfxstream_device->internal_object,
+ gfxstream_event->internal_object, true /* do lock */);
+ }
return vkGetEventStatus_VkResult_return;
}
-static VkResult entry_vkSetEvent(VkDevice device, VkEvent event) {
+VkResult gfxstream_vk_SetEvent(VkDevice device, VkEvent event) {
AEMU_SCOPED_TRACE("vkSetEvent");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetEvent_VkResult_return = (VkResult)0;
- vkSetEvent_VkResult_return = vkEnc->vkSetEvent(device, event, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkSetEvent_VkResult_return =
+ vkEnc->vkSetEvent(gfxstream_device->internal_object, gfxstream_event->internal_object,
+ true /* do lock */);
+ }
return vkSetEvent_VkResult_return;
}
-static VkResult entry_vkResetEvent(VkDevice device, VkEvent event) {
+VkResult gfxstream_vk_ResetEvent(VkDevice device, VkEvent event) {
AEMU_SCOPED_TRACE("vkResetEvent");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkResetEvent_VkResult_return = (VkResult)0;
- vkResetEvent_VkResult_return = vkEnc->vkResetEvent(device, event, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkResetEvent_VkResult_return =
+ vkEnc->vkResetEvent(gfxstream_device->internal_object, gfxstream_event->internal_object,
+ true /* do lock */);
+ }
return vkResetEvent_VkResult_return;
}
-static VkResult entry_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkQueryPool* pQueryPool) {
+VkResult gfxstream_vk_CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkQueryPool* pQueryPool) {
AEMU_SCOPED_TRACE("vkCreateQueryPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_query_pool* gfxstream_pQueryPool =
+ (struct gfxstream_vk_query_pool*)vk_query_pool_create(
+ (vk_device*)gfxstream_device, pCreateInfo, pAllocator,
+ sizeof(struct gfxstream_vk_query_pool));
vkCreateQueryPool_VkResult_return =
- vkEnc->vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool, true /* do lock */);
+ gfxstream_pQueryPool ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateQueryPool_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreateQueryPool_VkResult_return =
+ vkEnc->vkCreateQueryPool(gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pQueryPool->internal_object, true /* do lock */);
+ }
+ *pQueryPool = gfxstream_vk_query_pool_to_handle(gfxstream_pQueryPool);
return vkCreateQueryPool_VkResult_return;
}
-static void entry_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyQueryPool(VkDevice device, VkQueryPool queryPool,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyQueryPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyQueryPool(device, queryPool, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == queryPool) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyQueryPool(
+ gfxstream_device->internal_object,
+ gfxstream_queryPool ? gfxstream_queryPool->internal_object : VK_NULL_HANDLE, pAllocator,
+ true /* do lock */);
+ }
+ vk_query_pool_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_queryPool->vk);
}
-static VkResult entry_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool,
- uint32_t firstQuery, uint32_t queryCount,
- size_t dataSize, void* pData, VkDeviceSize stride,
- VkQueryResultFlags flags) {
+VkResult gfxstream_vk_GetQueryPoolResults(VkDevice device, VkQueryPool queryPool,
+ uint32_t firstQuery, uint32_t queryCount, size_t dataSize,
+ void* pData, VkDeviceSize stride,
+ VkQueryResultFlags flags) {
AEMU_SCOPED_TRACE("vkGetQueryPoolResults");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
- vkGetQueryPoolResults_VkResult_return =
- vkEnc->vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData,
- stride, flags, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetQueryPoolResults_VkResult_return = vkEnc->vkGetQueryPoolResults(
+ gfxstream_device->internal_object, gfxstream_queryPool->internal_object, firstQuery,
+ queryCount, dataSize, pData, stride, flags, true /* do lock */);
+ }
return vkGetQueryPoolResults_VkResult_return;
}
-static VkResult entry_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
+VkResult gfxstream_vk_CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
AEMU_SCOPED_TRACE("vkCreateBuffer");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateBuffer_VkResult_return =
- resources->on_vkCreateBuffer(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_buffer* gfxstream_pBuffer = (struct gfxstream_vk_buffer*)vk_buffer_create(
+ (vk_device*)gfxstream_device, pCreateInfo, pAllocator, sizeof(struct gfxstream_vk_buffer));
+ vkCreateBuffer_VkResult_return = gfxstream_pBuffer ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateBuffer_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateBuffer_VkResult_return = resources->on_vkCreateBuffer(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pBuffer->internal_object);
+ }
+ *pBuffer = gfxstream_vk_buffer_to_handle(gfxstream_pBuffer);
return vkCreateBuffer_VkResult_return;
}
-static void entry_vkDestroyBuffer(VkDevice device, VkBuffer buffer,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyBuffer(VkDevice device, VkBuffer buffer,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyBuffer");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkDestroyBuffer(vkEnc, device, buffer, pAllocator);
+ if (VK_NULL_HANDLE == buffer) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkDestroyBuffer(
+ vkEnc, gfxstream_device->internal_object,
+ gfxstream_buffer ? gfxstream_buffer->internal_object : VK_NULL_HANDLE, pAllocator);
+ }
+ vk_buffer_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_buffer->vk);
}
-static VkResult entry_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBufferView* pView) {
+VkResult gfxstream_vk_CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferView* pView) {
AEMU_SCOPED_TRACE("vkCreateBufferView");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
- vkCreateBufferView_VkResult_return =
- vkEnc->vkCreateBufferView(device, pCreateInfo, pAllocator, pView, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_buffer_view* gfxstream_pView =
+ (struct gfxstream_vk_buffer_view*)vk_buffer_view_create(
+ (vk_device*)gfxstream_device, pCreateInfo, pAllocator,
+ sizeof(struct gfxstream_vk_buffer_view));
+ vkCreateBufferView_VkResult_return = gfxstream_pView ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateBufferView_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBufferViewCreateInfo> internal_pCreateInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCreateInfo[i] = pCreateInfo[i];
+ /* VkBufferViewCreateInfo::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pCreateInfo[i].buffer);
+ internal_pCreateInfo[i].buffer = gfxstream_buffer->internal_object;
+ }
+ vkCreateBufferView_VkResult_return = vkEnc->vkCreateBufferView(
+ gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
+ &gfxstream_pView->internal_object, true /* do lock */);
+ }
+ *pView = gfxstream_vk_buffer_view_to_handle(gfxstream_pView);
return vkCreateBufferView_VkResult_return;
}
-static void entry_vkDestroyBufferView(VkDevice device, VkBufferView bufferView,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyBufferView(VkDevice device, VkBufferView bufferView,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyBufferView");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyBufferView(device, bufferView, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == bufferView) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_bufferView, bufferView);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyBufferView(
+ gfxstream_device->internal_object,
+ gfxstream_bufferView ? gfxstream_bufferView->internal_object : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_buffer_view_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_bufferView->vk);
}
-static VkResult entry_vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
+VkResult gfxstream_vk_CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
AEMU_SCOPED_TRACE("vkCreateImage");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateImage_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateImage_VkResult_return =
- resources->on_vkCreateImage(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pImage);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_image* gfxstream_pImage = (struct gfxstream_vk_image*)vk_image_create(
+ (vk_device*)gfxstream_device, pCreateInfo, pAllocator, sizeof(struct gfxstream_vk_image));
+ vkCreateImage_VkResult_return = gfxstream_pImage ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateImage_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateImage_VkResult_return = resources->on_vkCreateImage(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pImage->internal_object);
+ }
+ *pImage = gfxstream_vk_image_to_handle(gfxstream_pImage);
return vkCreateImage_VkResult_return;
}
-static void entry_vkDestroyImage(VkDevice device, VkImage image,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyImage(VkDevice device, VkImage image,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyImage");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkDestroyImage(vkEnc, device, image, pAllocator);
+ if (VK_NULL_HANDLE == image) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkDestroyImage(
+ vkEnc, gfxstream_device->internal_object,
+ gfxstream_image ? gfxstream_image->internal_object : VK_NULL_HANDLE, pAllocator);
+ }
+ vk_image_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_image->vk);
}
-static void entry_vkGetImageSubresourceLayout(VkDevice device, VkImage image,
- const VkImageSubresource* pSubresource,
- VkSubresourceLayout* pLayout) {
+void gfxstream_vk_GetImageSubresourceLayout(VkDevice device, VkImage image,
+ const VkImageSubresource* pSubresource,
+ VkSubresourceLayout* pLayout) {
AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSubresourceLayout(device, image, pSubresource, pLayout, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetImageSubresourceLayout(gfxstream_device->internal_object,
+ gfxstream_image->internal_object, pSubresource, pLayout,
+ true /* do lock */);
+ }
}
-static VkResult entry_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkImageView* pView) {
+VkResult gfxstream_vk_CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
AEMU_SCOPED_TRACE("vkCreateImageView");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateImageView_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateImageView_VkResult_return =
- resources->on_vkCreateImageView(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pView);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_image_view* gfxstream_pView =
+ (struct gfxstream_vk_image_view*)vk_image_view_create(
+ (vk_device*)gfxstream_device, false /* driver_internal */, pCreateInfo, pAllocator,
+ sizeof(struct gfxstream_vk_image_view));
+ vkCreateImageView_VkResult_return = gfxstream_pView ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateImageView_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkImageViewCreateInfo> internal_pCreateInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCreateInfo[i] = pCreateInfo[i];
+ /* VkImageViewCreateInfo::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pCreateInfo[i].image);
+ internal_pCreateInfo[i].image = gfxstream_image->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateImageView_VkResult_return = resources->on_vkCreateImageView(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, internal_pCreateInfo.data(),
+ pAllocator, &gfxstream_pView->internal_object);
+ }
+ *pView = gfxstream_vk_image_view_to_handle(gfxstream_pView);
return vkCreateImageView_VkResult_return;
}
-static void entry_vkDestroyImageView(VkDevice device, VkImageView imageView,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyImageView(VkDevice device, VkImageView imageView,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyImageView");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyImageView(device, imageView, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == imageView) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView, imageView);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyImageView(
+ gfxstream_device->internal_object,
+ gfxstream_imageView ? gfxstream_imageView->internal_object : VK_NULL_HANDLE, pAllocator,
+ true /* do lock */);
+ }
+ vk_image_view_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_imageView->vk);
}
-static VkResult entry_vkCreateShaderModule(VkDevice device,
- const VkShaderModuleCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkShaderModule* pShaderModule) {
+VkResult gfxstream_vk_CreateShaderModule(VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkShaderModule* pShaderModule) {
AEMU_SCOPED_TRACE("vkCreateShaderModule");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
- vkCreateShaderModule_VkResult_return = vkEnc->vkCreateShaderModule(
- device, pCreateInfo, pAllocator, pShaderModule, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_shader_module* gfxstream_pShaderModule =
+ (gfxstream_vk_shader_module*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+ sizeof(gfxstream_vk_shader_module),
+ VK_OBJECT_TYPE_SHADER_MODULE);
+ vkCreateShaderModule_VkResult_return =
+ gfxstream_pShaderModule ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateShaderModule_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreateShaderModule_VkResult_return = vkEnc->vkCreateShaderModule(
+ gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pShaderModule->internal_object, true /* do lock */);
+ }
+ *pShaderModule = gfxstream_vk_shader_module_to_handle(gfxstream_pShaderModule);
return vkCreateShaderModule_VkResult_return;
}
-static void entry_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyShaderModule");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyShaderModule(device, shaderModule, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == shaderModule) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_shader_module, gfxstream_shaderModule, shaderModule);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyShaderModule(
+ gfxstream_device->internal_object,
+ gfxstream_shaderModule ? gfxstream_shaderModule->internal_object : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_shaderModule);
}
-static VkResult entry_vkCreatePipelineCache(VkDevice device,
- const VkPipelineCacheCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPipelineCache* pPipelineCache) {
+VkResult gfxstream_vk_CreatePipelineCache(VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache) {
AEMU_SCOPED_TRACE("vkCreatePipelineCache");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
- vkCreatePipelineCache_VkResult_return = vkEnc->vkCreatePipelineCache(
- device, pCreateInfo, pAllocator, pPipelineCache, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_pipeline_cache* gfxstream_pPipelineCache =
+ (gfxstream_vk_pipeline_cache*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+ sizeof(gfxstream_vk_pipeline_cache),
+ VK_OBJECT_TYPE_PIPELINE_CACHE);
+ vkCreatePipelineCache_VkResult_return =
+ gfxstream_pPipelineCache ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreatePipelineCache_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreatePipelineCache_VkResult_return = vkEnc->vkCreatePipelineCache(
+ gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pPipelineCache->internal_object, true /* do lock */);
+ }
+ *pPipelineCache = gfxstream_vk_pipeline_cache_to_handle(gfxstream_pPipelineCache);
return vkCreatePipelineCache_VkResult_return;
}
-static void entry_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyPipelineCache");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPipelineCache(device, pipelineCache, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == pipelineCache) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_pipelineCache, pipelineCache);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyPipelineCache(
+ gfxstream_device->internal_object,
+ gfxstream_pipelineCache ? gfxstream_pipelineCache->internal_object : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_pipelineCache);
}
-static VkResult entry_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
- size_t* pDataSize, void* pData) {
+VkResult gfxstream_vk_GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
+ size_t* pDataSize, void* pData) {
AEMU_SCOPED_TRACE("vkGetPipelineCacheData");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0;
- vkGetPipelineCacheData_VkResult_return =
- vkEnc->vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_pipelineCache, pipelineCache);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetPipelineCacheData_VkResult_return = vkEnc->vkGetPipelineCacheData(
+ gfxstream_device->internal_object, gfxstream_pipelineCache->internal_object, pDataSize,
+ pData, true /* do lock */);
+ }
return vkGetPipelineCacheData_VkResult_return;
}
-static VkResult entry_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
- uint32_t srcCacheCount,
- const VkPipelineCache* pSrcCaches) {
+VkResult gfxstream_vk_MergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
+ uint32_t srcCacheCount,
+ const VkPipelineCache* pSrcCaches) {
AEMU_SCOPED_TRACE("vkMergePipelineCaches");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
- vkMergePipelineCaches_VkResult_return = vkEnc->vkMergePipelineCaches(
- device, dstCache, srcCacheCount, pSrcCaches, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_dstCache, dstCache);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkPipelineCache> internal_pSrcCaches(srcCacheCount);
+ for (uint32_t i = 0; i < srcCacheCount; ++i) {
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_pSrcCaches, pSrcCaches[i]);
+ internal_pSrcCaches[i] = gfxstream_pSrcCaches->internal_object;
+ }
+ vkMergePipelineCaches_VkResult_return = vkEnc->vkMergePipelineCaches(
+ gfxstream_device->internal_object, gfxstream_dstCache->internal_object, srcCacheCount,
+ internal_pSrcCaches.data(), true /* do lock */);
+ }
return vkMergePipelineCaches_VkResult_return;
}
-static VkResult entry_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkGraphicsPipelineCreateInfo* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines) {
+VkResult gfxstream_vk_CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines) {
AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateGraphicsPipelines_VkResult_return = resources->on_vkCreateGraphicsPipelines(
- vkEnc, VK_SUCCESS, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
- pPipelines);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_pipelineCache, pipelineCache);
+ struct gfxstream_vk_pipeline* gfxstream_pPipelines = (gfxstream_vk_pipeline*)vk_object_zalloc(
+ &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_pipeline), VK_OBJECT_TYPE_PIPELINE);
+ vkCreateGraphicsPipelines_VkResult_return =
+ gfxstream_pPipelines ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateGraphicsPipelines_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkGraphicsPipelineCreateInfo> internal_pCreateInfos(createInfoCount);
+ std::vector<std::vector<VkPipelineShaderStageCreateInfo>>
+ internal_VkGraphicsPipelineCreateInfo_pStages;
+ for (uint32_t i = 0; i < createInfoCount; ++i) {
+ internal_pCreateInfos[i] = pCreateInfos[i];
+ /* VkGraphicsPipelineCreateInfo::pStages */
+ internal_VkGraphicsPipelineCreateInfo_pStages.push_back(
+ std::vector<VkPipelineShaderStageCreateInfo>());
+ internal_VkGraphicsPipelineCreateInfo_pStages[i].reserve(
+ internal_pCreateInfos[i].stageCount);
+ memset(&internal_VkGraphicsPipelineCreateInfo_pStages[i][0], 0,
+ sizeof(VkPipelineShaderStageCreateInfo) * internal_pCreateInfos[i].stageCount);
+ for (uint32_t j = 0; j < internal_pCreateInfos[i].stageCount; ++j) {
+ if (internal_pCreateInfos[i].pStages) {
+ internal_VkGraphicsPipelineCreateInfo_pStages[i][j] =
+ internal_pCreateInfos[i].pStages[j];
+ /* VkPipelineShaderStageCreateInfo::module */
+ if (internal_VkGraphicsPipelineCreateInfo_pStages[i][j].module) {
+ VK_FROM_HANDLE(gfxstream_vk_shader_module, gfxstream_module,
+ internal_VkGraphicsPipelineCreateInfo_pStages[i][j].module);
+ internal_VkGraphicsPipelineCreateInfo_pStages[i][j].module =
+ gfxstream_module->internal_object;
+ }
+ }
+ }
+ internal_pCreateInfos[i].pStages =
+ internal_VkGraphicsPipelineCreateInfo_pStages[i].data();
+ /* VkGraphicsPipelineCreateInfo::layout */
+ if (internal_pCreateInfos[i].layout) {
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_layout,
+ internal_pCreateInfos[i].layout);
+ internal_pCreateInfos[i].layout = gfxstream_layout->internal_object;
+ }
+ /* VkGraphicsPipelineCreateInfo::renderPass */
+ if (internal_pCreateInfos[i].renderPass) {
+ VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass,
+ internal_pCreateInfos[i].renderPass);
+ internal_pCreateInfos[i].renderPass = gfxstream_renderPass->internal_object;
+ }
+ /* VkGraphicsPipelineCreateInfo::basePipelineHandle */
+ if (internal_pCreateInfos[i].basePipelineHandle) {
+ VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_basePipelineHandle,
+ internal_pCreateInfos[i].basePipelineHandle);
+ internal_pCreateInfos[i].basePipelineHandle =
+ gfxstream_basePipelineHandle->internal_object;
+ }
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateGraphicsPipelines_VkResult_return = resources->on_vkCreateGraphicsPipelines(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ gfxstream_pipelineCache ? gfxstream_pipelineCache->internal_object : VK_NULL_HANDLE,
+ createInfoCount, internal_pCreateInfos.data(), pAllocator,
+ &gfxstream_pPipelines->internal_object);
+ }
+ *pPipelines = gfxstream_vk_pipeline_to_handle(gfxstream_pPipelines);
return vkCreateGraphicsPipelines_VkResult_return;
}
-static VkResult entry_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkComputePipelineCreateInfo* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines) {
- AEMU_SCOPED_TRACE("vkCreateComputePipelines");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
- vkCreateComputePipelines_VkResult_return =
- vkEnc->vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos,
- pAllocator, pPipelines, true /* do lock */);
- return vkCreateComputePipelines_VkResult_return;
-}
-static void entry_vkDestroyPipeline(VkDevice device, VkPipeline pipeline,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyPipeline(VkDevice device, VkPipeline pipeline,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyPipeline");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPipeline(device, pipeline, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == pipeline) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline, pipeline);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyPipeline(
+ gfxstream_device->internal_object,
+ gfxstream_pipeline ? gfxstream_pipeline->internal_object : VK_NULL_HANDLE, pAllocator,
+ true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_pipeline);
}
-static VkResult entry_vkCreatePipelineLayout(VkDevice device,
- const VkPipelineLayoutCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPipelineLayout* pPipelineLayout) {
+VkResult gfxstream_vk_CreatePipelineLayout(VkDevice device,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout) {
AEMU_SCOPED_TRACE("vkCreatePipelineLayout");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
- vkCreatePipelineLayout_VkResult_return = vkEnc->vkCreatePipelineLayout(
- device, pCreateInfo, pAllocator, pPipelineLayout, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_pipeline_layout* gfxstream_pPipelineLayout =
+ (gfxstream_vk_pipeline_layout*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+ sizeof(gfxstream_vk_pipeline_layout),
+ VK_OBJECT_TYPE_PIPELINE_LAYOUT);
+ vkCreatePipelineLayout_VkResult_return =
+ gfxstream_pPipelineLayout ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreatePipelineLayout_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkPipelineLayoutCreateInfo> internal_pCreateInfo(1);
+ std::vector<std::vector<VkDescriptorSetLayout>>
+ internal_VkPipelineLayoutCreateInfo_pSetLayouts;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCreateInfo[i] = pCreateInfo[i];
+ /* VkPipelineLayoutCreateInfo::pSetLayouts */
+ internal_VkPipelineLayoutCreateInfo_pSetLayouts.push_back(
+ std::vector<VkDescriptorSetLayout>());
+ internal_VkPipelineLayoutCreateInfo_pSetLayouts[i].reserve(
+ internal_pCreateInfo[i].setLayoutCount);
+ memset(&internal_VkPipelineLayoutCreateInfo_pSetLayouts[i][0], 0,
+ sizeof(VkDescriptorSetLayout) * internal_pCreateInfo[i].setLayoutCount);
+ for (uint32_t j = 0; j < internal_pCreateInfo[i].setLayoutCount; ++j) {
+ if (internal_pCreateInfo[i].pSetLayouts) {
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_pSetLayouts,
+ internal_pCreateInfo[i].pSetLayouts[j]);
+ internal_VkPipelineLayoutCreateInfo_pSetLayouts[i][j] =
+ gfxstream_pSetLayouts->internal_object;
+ }
+ }
+ internal_pCreateInfo[i].pSetLayouts =
+ internal_VkPipelineLayoutCreateInfo_pSetLayouts[i].data();
+ }
+ vkCreatePipelineLayout_VkResult_return = vkEnc->vkCreatePipelineLayout(
+ gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
+ &gfxstream_pPipelineLayout->internal_object, true /* do lock */);
+ }
+ *pPipelineLayout = gfxstream_vk_pipeline_layout_to_handle(gfxstream_pPipelineLayout);
return vkCreatePipelineLayout_VkResult_return;
}
-static void entry_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyPipelineLayout");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPipelineLayout(device, pipelineLayout, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == pipelineLayout) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_pipelineLayout, pipelineLayout);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyPipelineLayout(
+ gfxstream_device->internal_object,
+ gfxstream_pipelineLayout ? gfxstream_pipelineLayout->internal_object : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_pipelineLayout);
}
-static VkResult entry_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSampler* pSampler) {
+VkResult gfxstream_vk_CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
AEMU_SCOPED_TRACE("vkCreateSampler");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSampler_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateSampler_VkResult_return =
- resources->on_vkCreateSampler(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSampler);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateSampler_VkResult_return =
+ resources->on_vkCreateSampler(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ pCreateInfo, pAllocator, pSampler);
+ }
return vkCreateSampler_VkResult_return;
}
-static void entry_vkDestroySampler(VkDevice device, VkSampler sampler,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroySampler(VkDevice device, VkSampler sampler,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySampler");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroySampler(device, sampler, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == sampler) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroySampler(gfxstream_device->internal_object, sampler, pAllocator,
+ true /* do lock */);
+ }
}
-static VkResult entry_vkCreateDescriptorSetLayout(
- VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
+VkResult gfxstream_vk_CreateDescriptorSetLayout(VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout) {
AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateDescriptorSetLayout_VkResult_return = resources->on_vkCreateDescriptorSetLayout(
- vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSetLayout);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_descriptor_set_layout* gfxstream_pSetLayout =
+ (gfxstream_vk_descriptor_set_layout*)vk_object_zalloc(
+ &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_descriptor_set_layout),
+ VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT);
+ vkCreateDescriptorSetLayout_VkResult_return =
+ gfxstream_pSetLayout ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateDescriptorSetLayout_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateDescriptorSetLayout_VkResult_return = resources->on_vkCreateDescriptorSetLayout(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pSetLayout->internal_object);
+ }
+ *pSetLayout = gfxstream_vk_descriptor_set_layout_to_handle(gfxstream_pSetLayout);
return vkCreateDescriptorSetLayout_VkResult_return;
}
-static void entry_vkDestroyDescriptorSetLayout(VkDevice device,
- VkDescriptorSetLayout descriptorSetLayout,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyDescriptorSetLayout(VkDevice device,
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkDestroyDescriptorSetLayout(vkEnc, device, descriptorSetLayout, pAllocator);
+ if (VK_NULL_HANDLE == descriptorSetLayout) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_descriptorSetLayout,
+ descriptorSetLayout);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkDestroyDescriptorSetLayout(
+ vkEnc, gfxstream_device->internal_object,
+ gfxstream_descriptorSetLayout ? gfxstream_descriptorSetLayout->internal_object
+ : VK_NULL_HANDLE,
+ pAllocator);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_descriptorSetLayout);
}
-static VkResult entry_vkCreateDescriptorPool(VkDevice device,
- const VkDescriptorPoolCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorPool* pDescriptorPool) {
+VkResult gfxstream_vk_CreateDescriptorPool(VkDevice device,
+ const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool) {
AEMU_SCOPED_TRACE("vkCreateDescriptorPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateDescriptorPool_VkResult_return = resources->on_vkCreateDescriptorPool(
- vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pDescriptorPool);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_descriptor_pool* gfxstream_pDescriptorPool =
+ (gfxstream_vk_descriptor_pool*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+ sizeof(gfxstream_vk_descriptor_pool),
+ VK_OBJECT_TYPE_DESCRIPTOR_POOL);
+ vkCreateDescriptorPool_VkResult_return =
+ gfxstream_pDescriptorPool ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateDescriptorPool_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateDescriptorPool_VkResult_return = resources->on_vkCreateDescriptorPool(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pDescriptorPool->internal_object);
+ }
+ *pDescriptorPool = gfxstream_vk_descriptor_pool_to_handle(gfxstream_pDescriptorPool);
return vkCreateDescriptorPool_VkResult_return;
}
-static void entry_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDescriptorPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkDestroyDescriptorPool(vkEnc, device, descriptorPool, pAllocator);
+ if (VK_NULL_HANDLE == descriptorPool) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool, descriptorPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkDestroyDescriptorPool(
+ vkEnc, gfxstream_device->internal_object,
+ gfxstream_descriptorPool ? gfxstream_descriptorPool->internal_object : VK_NULL_HANDLE,
+ pAllocator);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_descriptorPool);
}
-static VkResult entry_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
- VkDescriptorPoolResetFlags flags) {
+VkResult gfxstream_vk_ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+ VkDescriptorPoolResetFlags flags) {
AEMU_SCOPED_TRACE("vkResetDescriptorPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkResetDescriptorPool_VkResult_return =
- resources->on_vkResetDescriptorPool(vkEnc, VK_SUCCESS, device, descriptorPool, flags);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool, descriptorPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkResetDescriptorPool_VkResult_return = resources->on_vkResetDescriptorPool(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ gfxstream_descriptorPool->internal_object, flags);
+ }
return vkResetDescriptorPool_VkResult_return;
}
-static VkResult entry_vkAllocateDescriptorSets(VkDevice device,
- const VkDescriptorSetAllocateInfo* pAllocateInfo,
- VkDescriptorSet* pDescriptorSets) {
+VkResult gfxstream_vk_AllocateDescriptorSets(VkDevice device,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
+ VkDescriptorSet* pDescriptorSets) {
AEMU_SCOPED_TRACE("vkAllocateDescriptorSets");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkAllocateDescriptorSets_VkResult_return = resources->on_vkAllocateDescriptorSets(
- vkEnc, VK_SUCCESS, device, pAllocateInfo, pDescriptorSets);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkDescriptorSetAllocateInfo> internal_pAllocateInfo(1);
+ std::vector<std::vector<VkDescriptorSetLayout>>
+ internal_VkDescriptorSetAllocateInfo_pSetLayouts;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pAllocateInfo[i] = pAllocateInfo[i];
+ /* VkDescriptorSetAllocateInfo::descriptorPool */
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool,
+ internal_pAllocateInfo[i].descriptorPool);
+ internal_pAllocateInfo[i].descriptorPool = gfxstream_descriptorPool->internal_object;
+ /* VkDescriptorSetAllocateInfo::pSetLayouts */
+ internal_VkDescriptorSetAllocateInfo_pSetLayouts.push_back(
+ std::vector<VkDescriptorSetLayout>());
+ internal_VkDescriptorSetAllocateInfo_pSetLayouts[i].reserve(
+ internal_pAllocateInfo[i].descriptorSetCount);
+ memset(&internal_VkDescriptorSetAllocateInfo_pSetLayouts[i][0], 0,
+ sizeof(VkDescriptorSetLayout) * internal_pAllocateInfo[i].descriptorSetCount);
+ for (uint32_t j = 0; j < internal_pAllocateInfo[i].descriptorSetCount; ++j) {
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_pSetLayouts,
+ internal_pAllocateInfo[i].pSetLayouts[j]);
+ internal_VkDescriptorSetAllocateInfo_pSetLayouts[i][j] =
+ gfxstream_pSetLayouts->internal_object;
+ }
+ internal_pAllocateInfo[i].pSetLayouts =
+ internal_VkDescriptorSetAllocateInfo_pSetLayouts[i].data();
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkAllocateDescriptorSets_VkResult_return = resources->on_vkAllocateDescriptorSets(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, internal_pAllocateInfo.data(),
+ pDescriptorSets);
+ }
return vkAllocateDescriptorSets_VkResult_return;
}
-static VkResult entry_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
- uint32_t descriptorSetCount,
- const VkDescriptorSet* pDescriptorSets) {
+VkResult gfxstream_vk_FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets) {
AEMU_SCOPED_TRACE("vkFreeDescriptorSets");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkFreeDescriptorSets_VkResult_return = resources->on_vkFreeDescriptorSets(
- vkEnc, VK_SUCCESS, device, descriptorPool, descriptorSetCount, pDescriptorSets);
+ if (VK_NULL_HANDLE == pDescriptorSets) {
+ return vkFreeDescriptorSets_VkResult_return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool, descriptorPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkFreeDescriptorSets_VkResult_return = resources->on_vkFreeDescriptorSets(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ gfxstream_descriptorPool->internal_object, descriptorSetCount, pDescriptorSets);
+ }
return vkFreeDescriptorSets_VkResult_return;
}
-static void entry_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
- const VkWriteDescriptorSet* pDescriptorWrites,
- uint32_t descriptorCopyCount,
- const VkCopyDescriptorSet* pDescriptorCopies) {
- AEMU_SCOPED_TRACE("vkUpdateDescriptorSets");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkUpdateDescriptorSets(vkEnc, device, descriptorWriteCount, pDescriptorWrites,
- descriptorCopyCount, pDescriptorCopies);
-}
-static VkResult entry_vkCreateFramebuffer(VkDevice device,
- const VkFramebufferCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkFramebuffer* pFramebuffer) {
+VkResult gfxstream_vk_CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer) {
AEMU_SCOPED_TRACE("vkCreateFramebuffer");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
- vkCreateFramebuffer_VkResult_return = vkEnc->vkCreateFramebuffer(
- device, pCreateInfo, pAllocator, pFramebuffer, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_framebuffer* gfxstream_pFramebuffer =
+ (gfxstream_vk_framebuffer*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+ sizeof(gfxstream_vk_framebuffer),
+ VK_OBJECT_TYPE_FRAMEBUFFER);
+ vkCreateFramebuffer_VkResult_return =
+ gfxstream_pFramebuffer ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateFramebuffer_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkFramebufferCreateInfo> internal_pCreateInfo(1);
+ std::vector<std::vector<VkImageView>> internal_VkFramebufferCreateInfo_pAttachments;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCreateInfo[i] = pCreateInfo[i];
+ /* VkFramebufferCreateInfo::renderPass */
+ VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass,
+ internal_pCreateInfo[i].renderPass);
+ internal_pCreateInfo[i].renderPass = gfxstream_renderPass->internal_object;
+ /* VkFramebufferCreateInfo::pAttachments */
+ internal_VkFramebufferCreateInfo_pAttachments.push_back(std::vector<VkImageView>());
+ internal_VkFramebufferCreateInfo_pAttachments[i].reserve(
+ internal_pCreateInfo[i].attachmentCount);
+ memset(&internal_VkFramebufferCreateInfo_pAttachments[i][0], 0,
+ sizeof(VkImageView) * internal_pCreateInfo[i].attachmentCount);
+ for (uint32_t j = 0; j < internal_pCreateInfo[i].attachmentCount; ++j) {
+ if (internal_pCreateInfo[i].pAttachments) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_pAttachments,
+ internal_pCreateInfo[i].pAttachments[j]);
+ internal_VkFramebufferCreateInfo_pAttachments[i][j] =
+ gfxstream_pAttachments->internal_object;
+ }
+ }
+ internal_pCreateInfo[i].pAttachments =
+ internal_VkFramebufferCreateInfo_pAttachments[i].data();
+ }
+ vkCreateFramebuffer_VkResult_return = vkEnc->vkCreateFramebuffer(
+ gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
+ &gfxstream_pFramebuffer->internal_object, true /* do lock */);
+ }
+ *pFramebuffer = gfxstream_vk_framebuffer_to_handle(gfxstream_pFramebuffer);
return vkCreateFramebuffer_VkResult_return;
}
-static void entry_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyFramebuffer");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyFramebuffer(device, framebuffer, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == framebuffer) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_framebuffer, gfxstream_framebuffer, framebuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyFramebuffer(
+ gfxstream_device->internal_object,
+ gfxstream_framebuffer ? gfxstream_framebuffer->internal_object : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_framebuffer);
}
-static VkResult entry_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass) {
+VkResult gfxstream_vk_CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass) {
AEMU_SCOPED_TRACE("vkCreateRenderPass");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_render_pass* gfxstream_pRenderPass =
+ (gfxstream_vk_render_pass*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+ sizeof(gfxstream_vk_render_pass),
+ VK_OBJECT_TYPE_RENDER_PASS);
vkCreateRenderPass_VkResult_return =
- vkEnc->vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
+ gfxstream_pRenderPass ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateRenderPass_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreateRenderPass_VkResult_return =
+ vkEnc->vkCreateRenderPass(gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pRenderPass->internal_object, true /* do lock */);
+ }
+ *pRenderPass = gfxstream_vk_render_pass_to_handle(gfxstream_pRenderPass);
return vkCreateRenderPass_VkResult_return;
}
-static void entry_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyRenderPass(VkDevice device, VkRenderPass renderPass,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyRenderPass");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyRenderPass(device, renderPass, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == renderPass) {
+ return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass, renderPass);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyRenderPass(
+ gfxstream_device->internal_object,
+ gfxstream_renderPass ? gfxstream_renderPass->internal_object : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_renderPass);
}
-static void entry_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
- VkExtent2D* pGranularity) {
+void gfxstream_vk_GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
+ VkExtent2D* pGranularity) {
AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetRenderAreaGranularity(device, renderPass, pGranularity, true /* do lock */);
-}
-static VkResult entry_vkCreateCommandPool(VkDevice device,
- const VkCommandPoolCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkCommandPool* pCommandPool) {
- AEMU_SCOPED_TRACE("vkCreateCommandPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
- vkCreateCommandPool_VkResult_return = vkEnc->vkCreateCommandPool(
- device, pCreateInfo, pAllocator, pCommandPool, true /* do lock */);
- return vkCreateCommandPool_VkResult_return;
-}
-static void entry_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyCommandPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyCommandPool(device, commandPool, pAllocator, true /* do lock */);
-}
-static VkResult entry_vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
- VkCommandPoolResetFlags flags) {
- AEMU_SCOPED_TRACE("vkResetCommandPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
- vkResetCommandPool_VkResult_return =
- vkEnc->vkResetCommandPool(device, commandPool, flags, true /* do lock */);
- if (vkResetCommandPool_VkResult_return == VK_SUCCESS) {
- ResourceTracker::get()->resetCommandPoolStagingInfo(commandPool);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass, renderPass);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetRenderAreaGranularity(gfxstream_device->internal_object,
+ gfxstream_renderPass->internal_object, pGranularity,
+ true /* do lock */);
}
- return vkResetCommandPool_VkResult_return;
}
-static VkResult entry_vkAllocateCommandBuffers(VkDevice device,
- const VkCommandBufferAllocateInfo* pAllocateInfo,
- VkCommandBuffer* pCommandBuffers) {
- AEMU_SCOPED_TRACE("vkAllocateCommandBuffers");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkAllocateCommandBuffers_VkResult_return = resources->on_vkAllocateCommandBuffers(
- vkEnc, VK_SUCCESS, device, pAllocateInfo, pCommandBuffers);
- if (vkAllocateCommandBuffers_VkResult_return == VK_SUCCESS) {
- ResourceTracker::get()->addToCommandPool(
- pAllocateInfo->commandPool, pAllocateInfo->commandBufferCount, pCommandBuffers);
- }
- return vkAllocateCommandBuffers_VkResult_return;
-}
-static void entry_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
- uint32_t commandBufferCount,
- const VkCommandBuffer* pCommandBuffers) {
- AEMU_SCOPED_TRACE("vkFreeCommandBuffers");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers,
- true /* do lock */);
-}
-static VkResult entry_vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
- const VkCommandBufferBeginInfo* pBeginInfo) {
+VkResult gfxstream_vk_BeginCommandBuffer(VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo) {
AEMU_SCOPED_TRACE("vkBeginCommandBuffer");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkBeginCommandBuffer_VkResult_return =
- resources->on_vkBeginCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, pBeginInfo);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCommandBufferBeginInfo> internal_pBeginInfo(1);
+ std::vector<VkCommandBufferInheritanceInfo>
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pBeginInfo[i] = pBeginInfo[i];
+ /* VkCommandBufferBeginInfo::pInheritanceInfo */
+ if (internal_pBeginInfo[i].pInheritanceInfo) {
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i] =
+ internal_pBeginInfo[i].pInheritanceInfo[0];
+ /* VkCommandBufferInheritanceInfo::renderPass */
+ if (internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass) {
+ VK_FROM_HANDLE(
+ gfxstream_vk_render_pass, gfxstream_renderPass,
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass);
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass =
+ gfxstream_renderPass->internal_object;
+ }
+ /* VkCommandBufferInheritanceInfo::framebuffer */
+ if (internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer) {
+ VK_FROM_HANDLE(
+ gfxstream_vk_framebuffer, gfxstream_framebuffer,
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer);
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer =
+ gfxstream_framebuffer->internal_object;
+ }
+ internal_pBeginInfo[i].pInheritanceInfo =
+ &internal_VkCommandBufferBeginInfo_pInheritanceInfo[i];
+ }
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkBeginCommandBuffer_VkResult_return = resources->on_vkBeginCommandBuffer(
+ vkEnc, VK_SUCCESS, gfxstream_commandBuffer->internal_object,
+ internal_pBeginInfo.data());
+ }
return vkBeginCommandBuffer_VkResult_return;
}
-static VkResult entry_vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
+VkResult gfxstream_vk_EndCommandBuffer(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkEndCommandBuffer");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkEndCommandBuffer_VkResult_return =
- resources->on_vkEndCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkEndCommandBuffer_VkResult_return = resources->on_vkEndCommandBuffer(
+ vkEnc, VK_SUCCESS, gfxstream_commandBuffer->internal_object);
+ }
return vkEndCommandBuffer_VkResult_return;
}
-static VkResult entry_vkResetCommandBuffer(VkCommandBuffer commandBuffer,
- VkCommandBufferResetFlags flags) {
+VkResult gfxstream_vk_ResetCommandBuffer(VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags) {
AEMU_SCOPED_TRACE("vkResetCommandBuffer");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkResetCommandBuffer_VkResult_return =
- resources->on_vkResetCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, flags);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkResetCommandBuffer_VkResult_return = resources->on_vkResetCommandBuffer(
+ vkEnc, VK_SUCCESS, gfxstream_commandBuffer->internal_object, flags);
+ }
return vkResetCommandBuffer_VkResult_return;
}
-static void entry_vkCmdBindPipeline(VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
+void gfxstream_vk_CmdBindPipeline(VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
AEMU_SCOPED_TRACE("vkCmdBindPipeline");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline, pipeline);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdBindPipeline(gfxstream_commandBuffer->internal_object, pipelineBindPoint,
+ gfxstream_pipeline->internal_object, true /* do lock */);
+ }
}
-static void entry_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
- uint32_t viewportCount, const VkViewport* pViewports) {
+void gfxstream_vk_CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+ uint32_t viewportCount, const VkViewport* pViewports) {
AEMU_SCOPED_TRACE("vkCmdSetViewport");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetViewport(gfxstream_commandBuffer->internal_object, firstViewport,
+ viewportCount, pViewports, true /* do lock */);
+ }
}
-static void entry_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
- uint32_t scissorCount, const VkRect2D* pScissors) {
+void gfxstream_vk_CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
+ uint32_t scissorCount, const VkRect2D* pScissors) {
AEMU_SCOPED_TRACE("vkCmdSetScissor");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetScissor(gfxstream_commandBuffer->internal_object, firstScissor, scissorCount,
+ pScissors, true /* do lock */);
+ }
}
-static void entry_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
+void gfxstream_vk_CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
AEMU_SCOPED_TRACE("vkCmdSetLineWidth");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetLineWidth(commandBuffer, lineWidth, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetLineWidth(gfxstream_commandBuffer->internal_object, lineWidth,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
- float depthBiasClamp, float depthBiasSlopeFactor) {
+void gfxstream_vk_CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
+ float depthBiasClamp, float depthBiasSlopeFactor) {
AEMU_SCOPED_TRACE("vkCmdSetDepthBias");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp,
- depthBiasSlopeFactor, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthBias(gfxstream_commandBuffer->internal_object, depthBiasConstantFactor,
+ depthBiasClamp, depthBiasSlopeFactor, true /* do lock */);
+ }
}
-static void entry_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer,
- const float blendConstants[4]) {
+void gfxstream_vk_CmdSetBlendConstants(VkCommandBuffer commandBuffer,
+ const float blendConstants[4]) {
AEMU_SCOPED_TRACE("vkCmdSetBlendConstants");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetBlendConstants(commandBuffer, blendConstants, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetBlendConstants(gfxstream_commandBuffer->internal_object, blendConstants,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
- float maxDepthBounds) {
+void gfxstream_vk_CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
+ float maxDepthBounds) {
AEMU_SCOPED_TRACE("vkCmdSetDepthBounds");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthBounds(gfxstream_commandBuffer->internal_object, minDepthBounds,
+ maxDepthBounds, true /* do lock */);
+ }
}
-static void entry_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask, uint32_t compareMask) {
+void gfxstream_vk_CmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask, uint32_t compareMask) {
AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetStencilCompareMask(gfxstream_commandBuffer->internal_object, faceMask,
+ compareMask, true /* do lock */);
+ }
}
-static void entry_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask, uint32_t writeMask) {
+void gfxstream_vk_CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+ uint32_t writeMask) {
AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetStencilWriteMask(gfxstream_commandBuffer->internal_object, faceMask,
+ writeMask, true /* do lock */);
+ }
}
-static void entry_vkCmdSetStencilReference(VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask, uint32_t reference) {
+void gfxstream_vk_CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+ uint32_t reference) {
AEMU_SCOPED_TRACE("vkCmdSetStencilReference");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilReference(commandBuffer, faceMask, reference, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetStencilReference(gfxstream_commandBuffer->internal_object, faceMask,
+ reference, true /* do lock */);
+ }
}
-static void entry_vkCmdBindDescriptorSets(
+void gfxstream_vk_CmdBindDescriptorSets(
VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets,
uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- auto resources = ResourceTracker::get();
- resources->on_vkCmdBindDescriptorSets(vkEnc, commandBuffer, pipelineBindPoint, layout, firstSet,
- descriptorSetCount, pDescriptorSets, dynamicOffsetCount,
- pDynamicOffsets);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_layout, layout);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkCmdBindDescriptorSets(vkEnc, gfxstream_commandBuffer->internal_object,
+ pipelineBindPoint, gfxstream_layout->internal_object,
+ firstSet, descriptorSetCount, pDescriptorSets,
+ dynamicOffsetCount, pDynamicOffsets);
+ }
}
-static void entry_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, VkIndexType indexType) {
+void gfxstream_vk_CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkIndexType indexType) {
AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType, true /* do lock */);
-}
-static void entry_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
- uint32_t bindingCount, const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets) {
- AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
- true /* do lock */);
-}
-static void entry_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
- uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
- AEMU_SCOPED_TRACE("vkCmdDraw");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance,
- true /* do lock */);
-}
-static void entry_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
- uint32_t instanceCount, uint32_t firstIndex,
- int32_t vertexOffset, uint32_t firstInstance) {
- AEMU_SCOPED_TRACE("vkCmdDrawIndexed");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset,
- firstInstance, true /* do lock */);
-}
-static void entry_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
- AEMU_SCOPED_TRACE("vkCmdDrawIndirect");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride, true /* do lock */);
-}
-static void entry_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, uint32_t drawCount,
- uint32_t stride) {
- AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride,
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdBindIndexBuffer(gfxstream_commandBuffer->internal_object,
+ gfxstream_buffer->internal_object, offset, indexType,
true /* do lock */);
+ }
}
-static void entry_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX,
- uint32_t groupCountY, uint32_t groupCountZ) {
- AEMU_SCOPED_TRACE("vkCmdDispatch");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ, true /* do lock */);
+void gfxstream_vk_CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+ uint32_t bindingCount, const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets) {
+ AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkBuffer> internal_pBuffers(bindingCount);
+ for (uint32_t i = 0; i < bindingCount; ++i) {
+ if (pBuffers) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pBuffers, pBuffers[i]);
+ internal_pBuffers[i] = gfxstream_pBuffers->internal_object;
+ }
+ }
+ vkEnc->vkCmdBindVertexBuffers(gfxstream_commandBuffer->internal_object, firstBinding,
+ bindingCount, internal_pBuffers.data(), pOffsets,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset) {
- AEMU_SCOPED_TRACE("vkCmdDispatchIndirect");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDispatchIndirect(commandBuffer, buffer, offset, true /* do lock */);
+void gfxstream_vk_CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
+ uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
+ AEMU_SCOPED_TRACE("vkCmdDraw");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDraw(gfxstream_commandBuffer->internal_object, vertexCount, instanceCount,
+ firstVertex, firstInstance, true /* do lock */);
+ }
}
-static void entry_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
- VkBuffer dstBuffer, uint32_t regionCount,
- const VkBufferCopy* pRegions) {
- AEMU_SCOPED_TRACE("vkCmdCopyBuffer");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions,
- true /* do lock */);
+void gfxstream_vk_CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
+ uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset,
+ uint32_t firstInstance) {
+ AEMU_SCOPED_TRACE("vkCmdDrawIndexed");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDrawIndexed(gfxstream_commandBuffer->internal_object, indexCount, instanceCount,
+ firstIndex, vertexOffset, firstInstance, true /* do lock */);
+ }
}
-static void entry_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
- VkImageLayout srcImageLayout, VkImage dstImage,
- VkImageLayout dstImageLayout, uint32_t regionCount,
- const VkImageCopy* pRegions) {
- AEMU_SCOPED_TRACE("vkCmdCopyImage");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
- regionCount, pRegions, true /* do lock */);
-}
-static void entry_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
- VkImageLayout srcImageLayout, VkImage dstImage,
- VkImageLayout dstImageLayout, uint32_t regionCount,
- const VkImageBlit* pRegions, VkFilter filter) {
- AEMU_SCOPED_TRACE("vkCmdBlitImage");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
- regionCount, pRegions, filter, true /* do lock */);
-}
-static void entry_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
- VkImage dstImage, VkImageLayout dstImageLayout,
- uint32_t regionCount, const VkBufferImageCopy* pRegions) {
- AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount,
- pRegions, true /* do lock */);
-}
-static void entry_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
- VkImageLayout srcImageLayout, VkBuffer dstBuffer,
- uint32_t regionCount, const VkBufferImageCopy* pRegions) {
- AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount,
- pRegions, true /* do lock */);
-}
-static void entry_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
- VkDeviceSize dstOffset, VkDeviceSize dataSize,
- const void* pData) {
- AEMU_SCOPED_TRACE("vkCmdUpdateBuffer");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData,
- true /* do lock */);
-}
-static void entry_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
- VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
- AEMU_SCOPED_TRACE("vkCmdFillBuffer");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data, true /* do lock */);
-}
-static void entry_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
- VkImageLayout imageLayout, const VkClearColorValue* pColor,
- uint32_t rangeCount,
- const VkImageSubresourceRange* pRanges) {
- AEMU_SCOPED_TRACE("vkCmdClearColorImage");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges,
- true /* do lock */);
-}
-static void entry_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
- VkImageLayout imageLayout,
- const VkClearDepthStencilValue* pDepthStencil,
- uint32_t rangeCount,
- const VkImageSubresourceRange* pRanges) {
- AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount,
- pRanges, true /* do lock */);
-}
-static void entry_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
- const VkClearAttachment* pAttachments, uint32_t rectCount,
- const VkClearRect* pRects) {
- AEMU_SCOPED_TRACE("vkCmdClearAttachments");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects,
+void gfxstream_vk_CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+ AEMU_SCOPED_TRACE("vkCmdDrawIndirect");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDrawIndirect(gfxstream_commandBuffer->internal_object,
+ gfxstream_buffer->internal_object, offset, drawCount, stride,
true /* do lock */);
+ }
}
-static void entry_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
- VkImageLayout srcImageLayout, VkImage dstImage,
- VkImageLayout dstImageLayout, uint32_t regionCount,
- const VkImageResolve* pRegions) {
+void gfxstream_vk_CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+ AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDrawIndexedIndirect(gfxstream_commandBuffer->internal_object,
+ gfxstream_buffer->internal_object, offset, drawCount,
+ stride, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX,
+ uint32_t groupCountY, uint32_t groupCountZ) {
+ AEMU_SCOPED_TRACE("vkCmdDispatch");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDispatch(gfxstream_commandBuffer->internal_object, groupCountX, groupCountY,
+ groupCountZ, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset) {
+ AEMU_SCOPED_TRACE("vkCmdDispatchIndirect");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDispatchIndirect(gfxstream_commandBuffer->internal_object,
+ gfxstream_buffer->internal_object, offset, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
+ VkBuffer dstBuffer, uint32_t regionCount,
+ const VkBufferCopy* pRegions) {
+ AEMU_SCOPED_TRACE("vkCmdCopyBuffer");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer, srcBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdCopyBuffer(
+ gfxstream_commandBuffer->internal_object, gfxstream_srcBuffer->internal_object,
+ gfxstream_dstBuffer->internal_object, regionCount, pRegions, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkImage dstImage,
+ VkImageLayout dstImageLayout, uint32_t regionCount,
+ const VkImageCopy* pRegions) {
+ AEMU_SCOPED_TRACE("vkCmdCopyImage");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage, srcImage);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage, dstImage);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdCopyImage(gfxstream_commandBuffer->internal_object,
+ gfxstream_srcImage->internal_object, srcImageLayout,
+ gfxstream_dstImage->internal_object, dstImageLayout, regionCount,
+ pRegions, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkImage dstImage,
+ VkImageLayout dstImageLayout, uint32_t regionCount,
+ const VkImageBlit* pRegions, VkFilter filter) {
+ AEMU_SCOPED_TRACE("vkCmdBlitImage");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage, srcImage);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage, dstImage);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdBlitImage(gfxstream_commandBuffer->internal_object,
+ gfxstream_srcImage->internal_object, srcImageLayout,
+ gfxstream_dstImage->internal_object, dstImageLayout, regionCount,
+ pRegions, filter, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
+ VkImage dstImage, VkImageLayout dstImageLayout,
+ uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+ AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer, srcBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage, dstImage);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdCopyBufferToImage(gfxstream_commandBuffer->internal_object,
+ gfxstream_srcBuffer->internal_object,
+ gfxstream_dstImage->internal_object, dstImageLayout,
+ regionCount, pRegions, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkBuffer dstBuffer,
+ uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+ AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage, srcImage);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdCopyImageToBuffer(gfxstream_commandBuffer->internal_object,
+ gfxstream_srcImage->internal_object, srcImageLayout,
+ gfxstream_dstBuffer->internal_object, regionCount, pRegions,
+ true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+ VkDeviceSize dstOffset, VkDeviceSize dataSize,
+ const void* pData) {
+ AEMU_SCOPED_TRACE("vkCmdUpdateBuffer");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdUpdateBuffer(gfxstream_commandBuffer->internal_object,
+ gfxstream_dstBuffer->internal_object, dstOffset, dataSize, pData,
+ true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+ VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
+ AEMU_SCOPED_TRACE("vkCmdFillBuffer");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdFillBuffer(gfxstream_commandBuffer->internal_object,
+ gfxstream_dstBuffer->internal_object, dstOffset, size, data,
+ true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
+ VkImageLayout imageLayout, const VkClearColorValue* pColor,
+ uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+ AEMU_SCOPED_TRACE("vkCmdClearColorImage");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdClearColorImage(gfxstream_commandBuffer->internal_object,
+ gfxstream_image->internal_object, imageLayout, pColor,
+ rangeCount, pRanges, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearDepthStencilValue* pDepthStencil,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges) {
+ AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdClearDepthStencilImage(gfxstream_commandBuffer->internal_object,
+ gfxstream_image->internal_object, imageLayout,
+ pDepthStencil, rangeCount, pRanges, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
+ const VkClearAttachment* pAttachments, uint32_t rectCount,
+ const VkClearRect* pRects) {
+ AEMU_SCOPED_TRACE("vkCmdClearAttachments");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdClearAttachments(gfxstream_commandBuffer->internal_object, attachmentCount,
+ pAttachments, rectCount, pRects, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkImage dstImage,
+ VkImageLayout dstImageLayout, uint32_t regionCount,
+ const VkImageResolve* pRegions) {
AEMU_SCOPED_TRACE("vkCmdResolveImage");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
- regionCount, pRegions, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage, srcImage);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage, dstImage);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdResolveImage(gfxstream_commandBuffer->internal_object,
+ gfxstream_srcImage->internal_object, srcImageLayout,
+ gfxstream_dstImage->internal_object, dstImageLayout, regionCount,
+ pRegions, true /* do lock */);
+ }
}
-static void entry_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
- VkPipelineStageFlags stageMask) {
+void gfxstream_vk_CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+ VkPipelineStageFlags stageMask) {
AEMU_SCOPED_TRACE("vkCmdSetEvent");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetEvent(commandBuffer, event, stageMask, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetEvent(gfxstream_commandBuffer->internal_object,
+ gfxstream_event->internal_object, stageMask, true /* do lock */);
+ }
}
-static void entry_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
- VkPipelineStageFlags stageMask) {
+void gfxstream_vk_CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+ VkPipelineStageFlags stageMask) {
AEMU_SCOPED_TRACE("vkCmdResetEvent");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResetEvent(commandBuffer, event, stageMask, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdResetEvent(gfxstream_commandBuffer->internal_object,
+ gfxstream_event->internal_object, stageMask, true /* do lock */);
+ }
}
-static void entry_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount,
- const VkEvent* pEvents, VkPipelineStageFlags srcStageMask,
- VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount,
- const VkMemoryBarrier* pMemoryBarriers,
- uint32_t bufferMemoryBarrierCount,
- const VkBufferMemoryBarrier* pBufferMemoryBarriers,
- uint32_t imageMemoryBarrierCount,
- const VkImageMemoryBarrier* pImageMemoryBarriers) {
+void gfxstream_vk_CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount,
+ const VkEvent* pEvents, VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers) {
AEMU_SCOPED_TRACE("vkCmdWaitEvents");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask,
- memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
- pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkEvent> internal_pEvents(eventCount);
+ for (uint32_t i = 0; i < eventCount; ++i) {
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_pEvents, pEvents[i]);
+ internal_pEvents[i] = gfxstream_pEvents->internal_object;
+ }
+ std::vector<VkBufferMemoryBarrier> internal_pBufferMemoryBarriers(bufferMemoryBarrierCount);
+ for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
+ internal_pBufferMemoryBarriers[i] = pBufferMemoryBarriers[i];
+ /* VkBufferMemoryBarrier::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_pBufferMemoryBarriers[i].buffer);
+ internal_pBufferMemoryBarriers[i].buffer = gfxstream_buffer->internal_object;
+ }
+ std::vector<VkImageMemoryBarrier> internal_pImageMemoryBarriers(imageMemoryBarrierCount);
+ for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
+ internal_pImageMemoryBarriers[i] = pImageMemoryBarriers[i];
+ /* VkImageMemoryBarrier::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_pImageMemoryBarriers[i].image);
+ internal_pImageMemoryBarriers[i].image = gfxstream_image->internal_object;
+ }
+ vkEnc->vkCmdWaitEvents(gfxstream_commandBuffer->internal_object, eventCount,
+ internal_pEvents.data(), srcStageMask, dstStageMask,
+ memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
+ internal_pBufferMemoryBarriers.data(), imageMemoryBarrierCount,
+ internal_pImageMemoryBarriers.data(), true /* do lock */);
+ }
}
-static void entry_vkCmdPipelineBarrier(
+void gfxstream_vk_CmdPipelineBarrier(
VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
AEMU_SCOPED_TRACE("vkCmdPipelineBarrier");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- auto resources = ResourceTracker::get();
- resources->on_vkCmdPipelineBarrier(vkEnc, commandBuffer, srcStageMask, dstStageMask,
- dependencyFlags, memoryBarrierCount, pMemoryBarriers,
- bufferMemoryBarrierCount, pBufferMemoryBarriers,
- imageMemoryBarrierCount, pImageMemoryBarriers);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkBufferMemoryBarrier> internal_pBufferMemoryBarriers(bufferMemoryBarrierCount);
+ for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
+ internal_pBufferMemoryBarriers[i] = pBufferMemoryBarriers[i];
+ /* VkBufferMemoryBarrier::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_pBufferMemoryBarriers[i].buffer);
+ internal_pBufferMemoryBarriers[i].buffer = gfxstream_buffer->internal_object;
+ }
+ std::vector<VkImageMemoryBarrier> internal_pImageMemoryBarriers(imageMemoryBarrierCount);
+ for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
+ internal_pImageMemoryBarriers[i] = pImageMemoryBarriers[i];
+ /* VkImageMemoryBarrier::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_pImageMemoryBarriers[i].image);
+ internal_pImageMemoryBarriers[i].image = gfxstream_image->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkCmdPipelineBarrier(
+ vkEnc, gfxstream_commandBuffer->internal_object, srcStageMask, dstStageMask,
+ dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
+ internal_pBufferMemoryBarriers.data(), imageMemoryBarrierCount,
+ internal_pImageMemoryBarriers.data());
+ }
}
-static void entry_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
- uint32_t query, VkQueryControlFlags flags) {
+void gfxstream_vk_CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t query, VkQueryControlFlags flags) {
AEMU_SCOPED_TRACE("vkCmdBeginQuery");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginQuery(commandBuffer, queryPool, query, flags, true /* do lock */);
-}
-static void entry_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
- uint32_t query) {
- AEMU_SCOPED_TRACE("vkCmdEndQuery");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndQuery(commandBuffer, queryPool, query, true /* do lock */);
-}
-static void entry_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
- uint32_t firstQuery, uint32_t queryCount) {
- AEMU_SCOPED_TRACE("vkCmdResetQueryPool");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount,
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdBeginQuery(gfxstream_commandBuffer->internal_object,
+ gfxstream_queryPool->internal_object, query, flags,
true /* do lock */);
+ }
}
-static void entry_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,
- VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool,
- uint32_t query) {
+void gfxstream_vk_CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t query) {
+ AEMU_SCOPED_TRACE("vkCmdEndQuery");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdEndQuery(gfxstream_commandBuffer->internal_object,
+ gfxstream_queryPool->internal_object, query, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t firstQuery, uint32_t queryCount) {
+ AEMU_SCOPED_TRACE("vkCmdResetQueryPool");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdResetQueryPool(gfxstream_commandBuffer->internal_object,
+ gfxstream_queryPool->internal_object, firstQuery, queryCount,
+ true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdWriteTimestamp(VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool,
+ uint32_t query) {
AEMU_SCOPED_TRACE("vkCmdWriteTimestamp");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdWriteTimestamp(gfxstream_commandBuffer->internal_object, pipelineStage,
+ gfxstream_queryPool->internal_object, query, true /* do lock */);
+ }
}
-static void entry_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
- uint32_t firstQuery, uint32_t queryCount,
- VkBuffer dstBuffer, VkDeviceSize dstOffset,
- VkDeviceSize stride, VkQueryResultFlags flags) {
+void gfxstream_vk_CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t firstQuery, uint32_t queryCount,
+ VkBuffer dstBuffer, VkDeviceSize dstOffset,
+ VkDeviceSize stride, VkQueryResultFlags flags) {
AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer,
- dstOffset, stride, flags, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdCopyQueryPoolResults(gfxstream_commandBuffer->internal_object,
+ gfxstream_queryPool->internal_object, firstQuery,
+ queryCount, gfxstream_dstBuffer->internal_object,
+ dstOffset, stride, flags, true /* do lock */);
+ }
}
-static void entry_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
- VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
- const void* pValues) {
+void gfxstream_vk_CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
+ const void* pValues) {
AEMU_SCOPED_TRACE("vkCmdPushConstants");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_layout, layout);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdPushConstants(gfxstream_commandBuffer->internal_object,
+ gfxstream_layout->internal_object, stageFlags, offset, size,
+ pValues, true /* do lock */);
+ }
}
-static void entry_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- VkSubpassContents contents) {
- AEMU_SCOPED_TRACE("vkCmdBeginRenderPass");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents, true /* do lock */);
-}
-static void entry_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
+void gfxstream_vk_CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
AEMU_SCOPED_TRACE("vkCmdNextSubpass");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdNextSubpass(commandBuffer, contents, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdNextSubpass(gfxstream_commandBuffer->internal_object, contents,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
+void gfxstream_vk_CmdEndRenderPass(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkCmdEndRenderPass");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndRenderPass(commandBuffer, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdEndRenderPass(gfxstream_commandBuffer->internal_object, true /* do lock */);
+ }
}
-static void entry_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
- const VkCommandBuffer* pCommandBuffers) {
+void gfxstream_vk_CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers) {
AEMU_SCOPED_TRACE("vkCmdExecuteCommands");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- auto resources = ResourceTracker::get();
- resources->on_vkCmdExecuteCommands(vkEnc, commandBuffer, commandBufferCount, pCommandBuffers);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCommandBuffer> internal_pCommandBuffers(commandBufferCount);
+ for (uint32_t i = 0; i < commandBufferCount; ++i) {
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_pCommandBuffers,
+ pCommandBuffers[i]);
+ internal_pCommandBuffers[i] = gfxstream_pCommandBuffers->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkCmdExecuteCommands(vkEnc, gfxstream_commandBuffer->internal_object,
+ commandBufferCount, internal_pCommandBuffers.data());
+ }
}
#endif
#ifdef VK_VERSION_1_1
-static VkResult entry_vkEnumerateInstanceVersion(uint32_t* pApiVersion) {
- AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
- vkEnumerateInstanceVersion_VkResult_return =
- vkEnc->vkEnumerateInstanceVersion(pApiVersion, true /* do lock */);
- return vkEnumerateInstanceVersion_VkResult_return;
-}
-static VkResult entry_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
- const VkBindBufferMemoryInfo* pBindInfos) {
+VkResult gfxstream_vk_BindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos) {
AEMU_SCOPED_TRACE("vkBindBufferMemory2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkBindBufferMemory2_VkResult_return =
- resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBindBufferMemoryInfo> internal_pBindInfos(bindInfoCount);
+ for (uint32_t i = 0; i < bindInfoCount; ++i) {
+ internal_pBindInfos[i] = pBindInfos[i];
+ /* VkBindBufferMemoryInfo::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pBindInfos[i].buffer);
+ internal_pBindInfos[i].buffer = gfxstream_buffer->internal_object;
+ /* VkBindBufferMemoryInfo::memory */
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_pBindInfos[i].memory);
+ internal_pBindInfos[i].memory = gfxstream_memory->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkBindBufferMemory2_VkResult_return =
+ resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ bindInfoCount, internal_pBindInfos.data());
+ }
return vkBindBufferMemory2_VkResult_return;
}
-static VkResult dynCheck_entry_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
- const VkBindBufferMemoryInfo* pBindInfos) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkBindBufferMemory2", "VK_VERSION_1_1");
- }
- AEMU_SCOPED_TRACE("vkBindBufferMemory2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
- vkBindBufferMemory2_VkResult_return =
- resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
- return vkBindBufferMemory2_VkResult_return;
-}
-static VkResult entry_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
- const VkBindImageMemoryInfo* pBindInfos) {
+VkResult gfxstream_vk_BindImageMemory2(VkDevice device, uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos) {
AEMU_SCOPED_TRACE("vkBindImageMemory2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkBindImageMemory2_VkResult_return =
- resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBindImageMemoryInfo> internal_pBindInfos(bindInfoCount);
+ for (uint32_t i = 0; i < bindInfoCount; ++i) {
+ internal_pBindInfos[i] = pBindInfos[i];
+ /* VkBindImageMemoryInfo::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pBindInfos[i].image);
+ internal_pBindInfos[i].image = gfxstream_image->internal_object;
+ /* VkBindImageMemoryInfo::memory */
+ if (internal_pBindInfos[i].memory) {
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_pBindInfos[i].memory);
+ internal_pBindInfos[i].memory = gfxstream_memory->internal_object;
+ }
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkBindImageMemory2_VkResult_return =
+ resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ bindInfoCount, internal_pBindInfos.data());
+ }
return vkBindImageMemory2_VkResult_return;
}
-static VkResult dynCheck_entry_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
- const VkBindImageMemoryInfo* pBindInfos) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkBindImageMemory2", "VK_VERSION_1_1");
- }
- AEMU_SCOPED_TRACE("vkBindImageMemory2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
- vkBindImageMemory2_VkResult_return =
- resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
- return vkBindImageMemory2_VkResult_return;
-}
-static void entry_vkGetDeviceGroupPeerMemoryFeatures(
- VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
- VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
+void gfxstream_vk_GetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex,
- remoteDeviceIndex, pPeerMemoryFeatures,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceGroupPeerMemoryFeatures(
- VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
- VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupPeerMemoryFeatures", "VK_VERSION_1_1");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceGroupPeerMemoryFeatures(gfxstream_device->internal_object, heapIndex,
+ localDeviceIndex, remoteDeviceIndex,
+ pPeerMemoryFeatures, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex,
- remoteDeviceIndex, pPeerMemoryFeatures,
- true /* do lock */);
}
-static void entry_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) {
+void gfxstream_vk_CmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) {
AEMU_SCOPED_TRACE("vkCmdSetDeviceMask");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDeviceMask(commandBuffer, deviceMask, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDeviceMask(gfxstream_commandBuffer->internal_object, deviceMask,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX,
- uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX,
- uint32_t groupCountY, uint32_t groupCountZ) {
+void gfxstream_vk_CmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX,
+ uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX,
+ uint32_t groupCountY, uint32_t groupCountZ) {
AEMU_SCOPED_TRACE("vkCmdDispatchBase");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX,
- groupCountY, groupCountZ, true /* do lock */);
-}
-static VkResult entry_vkEnumeratePhysicalDeviceGroups(
- VkInstance instance, uint32_t* pPhysicalDeviceGroupCount,
- VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
- AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroups");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
- vkEnumeratePhysicalDeviceGroups_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroups(
- instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, true /* do lock */);
- return vkEnumeratePhysicalDeviceGroups_VkResult_return;
-}
-static void entry_vkGetImageMemoryRequirements2(VkDevice device,
- const VkImageMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetImageMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
-}
-static void dynCheck_entry_vkGetImageMemoryRequirements2(
- VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkGetImageMemoryRequirements2", "VK_VERSION_1_1");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDispatchBase(gfxstream_commandBuffer->internal_object, baseGroupX, baseGroupY,
+ baseGroupZ, groupCountX, groupCountY, groupCountZ,
+ true /* do lock */);
}
+}
+void gfxstream_vk_GetImageMemoryRequirements2(VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- resources->on_vkGetImageMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
-}
-static void entry_vkGetBufferMemoryRequirements2(VkDevice device,
- const VkBufferMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetBufferMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
-}
-static void dynCheck_entry_vkGetBufferMemoryRequirements2(
- VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkGetBufferMemoryRequirements2", "VK_VERSION_1_1");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkImageMemoryRequirementsInfo2> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkImageMemoryRequirementsInfo2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pInfo[i].image);
+ internal_pInfo[i].image = gfxstream_image->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetImageMemoryRequirements2(vkEnc, gfxstream_device->internal_object,
+ internal_pInfo.data(), pMemoryRequirements);
}
- AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- resources->on_vkGetBufferMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
}
-static void entry_vkGetImageSparseMemoryRequirements2(
+void gfxstream_vk_GetBufferMemoryRequirements2(VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
+ AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBufferMemoryRequirementsInfo2> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkBufferMemoryRequirementsInfo2::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
+ internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetBufferMemoryRequirements2(vkEnc, gfxstream_device->internal_object,
+ internal_pInfo.data(), pMemoryRequirements);
+ }
+}
+void gfxstream_vk_GetImageSparseMemoryRequirements2(
VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements, true /* do lock */);
-}
-static void dynCheck_entry_vkGetImageSparseMemoryRequirements2(
- VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
- uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkGetImageSparseMemoryRequirements2", "VK_VERSION_1_1");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkImageSparseMemoryRequirementsInfo2> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkImageSparseMemoryRequirementsInfo2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pInfo[i].image);
+ internal_pInfo[i].image = gfxstream_image->internal_object;
+ }
+ vkEnc->vkGetImageSparseMemoryRequirements2(
+ gfxstream_device->internal_object, internal_pInfo.data(), pSparseMemoryRequirementCount,
+ pSparseMemoryRequirements, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements, true /* do lock */);
}
-static void entry_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures2* pFeatures) {
+void gfxstream_vk_GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceFeatures2(gfxstream_physicalDevice->internal_object, pFeatures,
+ true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties2* pProperties) {
+void gfxstream_vk_GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceProperties2(physicalDevice, pProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceProperties2(gfxstream_physicalDevice->internal_object,
+ pProperties, true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties2* pFormatProperties) {
+void gfxstream_vk_GetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceFormatProperties2(gfxstream_physicalDevice->internal_object,
+ format, pFormatProperties, true /* do lock */);
+ }
}
-static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2(
+VkResult gfxstream_vk_GetPhysicalDeviceImageFormatProperties2(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
VkImageFormatProperties2* pImageFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkGetPhysicalDeviceImageFormatProperties2_VkResult_return =
- resources->on_vkGetPhysicalDeviceImageFormatProperties2(
- vkEnc, VK_SUCCESS, physicalDevice, pImageFormatInfo, pImageFormatProperties);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkGetPhysicalDeviceImageFormatProperties2_VkResult_return =
+ resources->on_vkGetPhysicalDeviceImageFormatProperties2(
+ vkEnc, VK_SUCCESS, gfxstream_physicalDevice->internal_object, pImageFormatInfo,
+ pImageFormatProperties);
+ }
return vkGetPhysicalDeviceImageFormatProperties2_VkResult_return;
}
-static void entry_vkGetPhysicalDeviceQueueFamilyProperties2(
+void gfxstream_vk_GetPhysicalDeviceQueueFamilyProperties2(
VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties2* pQueueFamilyProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount,
- pQueueFamilyProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2(
+ gfxstream_physicalDevice->internal_object, pQueueFamilyPropertyCount,
+ pQueueFamilyProperties, true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceMemoryProperties2(
+void gfxstream_vk_GetPhysicalDeviceMemoryProperties2(
VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceMemoryProperties2(gfxstream_physicalDevice->internal_object,
+ pMemoryProperties, true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2(
+void gfxstream_vk_GetPhysicalDeviceSparseImageFormatProperties2(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2(
- physicalDevice, pFormatInfo, pPropertyCount, pProperties, true /* do lock */);
-}
-static void entry_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool,
- VkCommandPoolTrimFlags flags) {
- AEMU_SCOPED_TRACE("vkTrimCommandPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkTrimCommandPool(device, commandPool, flags, true /* do lock */);
-}
-static void dynCheck_entry_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool,
- VkCommandPoolTrimFlags flags) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkTrimCommandPool", "VK_VERSION_1_1");
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2(
+ gfxstream_physicalDevice->internal_object, pFormatInfo, pPropertyCount, pProperties,
+ true /* do lock */);
}
+}
+void gfxstream_vk_TrimCommandPool(VkDevice device, VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags) {
AEMU_SCOPED_TRACE("vkTrimCommandPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkTrimCommandPool(device, commandPool, flags, true /* do lock */);
-}
-static void entry_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo,
- VkQueue* pQueue) {
- AEMU_SCOPED_TRACE("vkGetDeviceQueue2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue, true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo,
- VkQueue* pQueue) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceQueue2", "VK_VERSION_1_1");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_command_pool, gfxstream_commandPool, commandPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkTrimCommandPool(gfxstream_device->internal_object,
+ gfxstream_commandPool->internal_object, flags, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceQueue2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue, true /* do lock */);
}
-static VkResult entry_vkCreateSamplerYcbcrConversion(
+VkResult gfxstream_vk_CreateSamplerYcbcrConversion(
VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateSamplerYcbcrConversion_VkResult_return = resources->on_vkCreateSamplerYcbcrConversion(
- vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateSamplerYcbcrConversion_VkResult_return =
+ resources->on_vkCreateSamplerYcbcrConversion(vkEnc, VK_SUCCESS,
+ gfxstream_device->internal_object,
+ pCreateInfo, pAllocator, pYcbcrConversion);
+ }
return vkCreateSamplerYcbcrConversion_VkResult_return;
}
-static VkResult dynCheck_entry_vkCreateSamplerYcbcrConversion(
- VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkCreateSamplerYcbcrConversion", "VK_VERSION_1_1");
- }
- AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
- vkCreateSamplerYcbcrConversion_VkResult_return = resources->on_vkCreateSamplerYcbcrConversion(
- vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion);
- return vkCreateSamplerYcbcrConversion_VkResult_return;
-}
-static void entry_vkDestroySamplerYcbcrConversion(VkDevice device,
- VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroySamplerYcbcrConversion(VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkDestroySamplerYcbcrConversion(vkEnc, device, ycbcrConversion, pAllocator);
-}
-static void dynCheck_entry_vkDestroySamplerYcbcrConversion(
- VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks* pAllocator) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkDestroySamplerYcbcrConversion", "VK_VERSION_1_1");
+ if (VK_NULL_HANDLE == ycbcrConversion) {
+ return;
}
- AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- resources->on_vkDestroySamplerYcbcrConversion(vkEnc, device, ycbcrConversion, pAllocator);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkDestroySamplerYcbcrConversion(vkEnc, gfxstream_device->internal_object,
+ ycbcrConversion, pAllocator);
+ }
}
-static VkResult entry_vkCreateDescriptorUpdateTemplate(
+VkResult gfxstream_vk_CreateDescriptorUpdateTemplate(
VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
- vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(
- device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, true /* do lock */);
- return vkCreateDescriptorUpdateTemplate_VkResult_return;
-}
-static VkResult dynCheck_entry_vkCreateDescriptorUpdateTemplate(
- VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkCreateDescriptorUpdateTemplate", "VK_VERSION_1_1");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_descriptor_update_template* gfxstream_pDescriptorUpdateTemplate =
+ (gfxstream_vk_descriptor_update_template*)vk_object_zalloc(
+ &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_descriptor_update_template),
+ VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE);
+ vkCreateDescriptorUpdateTemplate_VkResult_return =
+ gfxstream_pDescriptorUpdateTemplate ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateDescriptorUpdateTemplate_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkDescriptorUpdateTemplateCreateInfo> internal_pCreateInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCreateInfo[i] = pCreateInfo[i];
+ /* VkDescriptorUpdateTemplateCreateInfo::descriptorSetLayout */
+ if (internal_pCreateInfo[i].descriptorSetLayout) {
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_descriptorSetLayout,
+ internal_pCreateInfo[i].descriptorSetLayout);
+ internal_pCreateInfo[i].descriptorSetLayout =
+ gfxstream_descriptorSetLayout->internal_object;
+ }
+ /* VkDescriptorUpdateTemplateCreateInfo::pipelineLayout */
+ if (internal_pCreateInfo[i].pipelineLayout) {
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_pipelineLayout,
+ internal_pCreateInfo[i].pipelineLayout);
+ internal_pCreateInfo[i].pipelineLayout = gfxstream_pipelineLayout->internal_object;
+ }
+ }
+ vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(
+ gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
+ &gfxstream_pDescriptorUpdateTemplate->internal_object, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
- vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(
- device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, true /* do lock */);
+ *pDescriptorUpdateTemplate =
+ gfxstream_vk_descriptor_update_template_to_handle(gfxstream_pDescriptorUpdateTemplate);
return vkCreateDescriptorUpdateTemplate_VkResult_return;
}
-static void entry_vkDestroyDescriptorUpdateTemplate(
+void gfxstream_vk_DestroyDescriptorUpdateTemplate(
VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator,
- true /* do lock */);
-}
-static void dynCheck_entry_vkDestroyDescriptorUpdateTemplate(
- VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const VkAllocationCallbacks* pAllocator) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkDestroyDescriptorUpdateTemplate", "VK_VERSION_1_1");
+ if (VK_NULL_HANDLE == descriptorUpdateTemplate) {
+ return;
}
- AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
+ descriptorUpdateTemplate);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyDescriptorUpdateTemplate(
+ gfxstream_device->internal_object,
+ gfxstream_descriptorUpdateTemplate ? gfxstream_descriptorUpdateTemplate->internal_object
+ : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_descriptorUpdateTemplate);
}
-static void entry_vkUpdateDescriptorSetWithTemplate(
+void gfxstream_vk_UpdateDescriptorSetWithTemplate(
VkDevice device, VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkUpdateDescriptorSetWithTemplate(vkEnc, device, descriptorSet,
- descriptorUpdateTemplate, pData);
-}
-static void dynCheck_entry_vkUpdateDescriptorSetWithTemplate(
- VkDevice device, VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplate", "VK_VERSION_1_1");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
+ descriptorUpdateTemplate);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkUpdateDescriptorSetWithTemplate(
+ vkEnc, gfxstream_device->internal_object, descriptorSet,
+ gfxstream_descriptorUpdateTemplate->internal_object, pData);
}
- AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- resources->on_vkUpdateDescriptorSetWithTemplate(vkEnc, device, descriptorSet,
- descriptorUpdateTemplate, pData);
}
-static void entry_vkGetPhysicalDeviceExternalBufferProperties(
+void gfxstream_vk_GetPhysicalDeviceExternalBufferProperties(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
VkExternalBufferProperties* pExternalBufferProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetPhysicalDeviceExternalBufferProperties(
- vkEnc, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetPhysicalDeviceExternalBufferProperties(
+ vkEnc, gfxstream_physicalDevice->internal_object, pExternalBufferInfo,
+ pExternalBufferProperties);
+ }
}
-static void entry_vkGetPhysicalDeviceExternalFenceProperties(
+void gfxstream_vk_GetPhysicalDeviceExternalFenceProperties(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
VkExternalFenceProperties* pExternalFenceProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetPhysicalDeviceExternalFenceProperties(
- vkEnc, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetPhysicalDeviceExternalFenceProperties(
+ vkEnc, gfxstream_physicalDevice->internal_object, pExternalFenceInfo,
+ pExternalFenceProperties);
+ }
}
-static void entry_vkGetPhysicalDeviceExternalSemaphoreProperties(
+void gfxstream_vk_GetPhysicalDeviceExternalSemaphoreProperties(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceExternalSemaphoreProperties(
- physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, true /* do lock */);
-}
-static void entry_vkGetDescriptorSetLayoutSupport(
- VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- VkDescriptorSetLayoutSupport* pSupport) {
- AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport, true /* do lock */);
-}
-static void dynCheck_entry_vkGetDescriptorSetLayoutSupport(
- VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- VkDescriptorSetLayoutSupport* pSupport) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
- sOnInvalidDynamicallyCheckedCall("vkGetDescriptorSetLayoutSupport", "VK_VERSION_1_1");
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceExternalSemaphoreProperties(
+ gfxstream_physicalDevice->internal_object, pExternalSemaphoreInfo,
+ pExternalSemaphoreProperties, true /* do lock */);
}
+}
+void gfxstream_vk_GetDescriptorSetLayoutSupport(VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport) {
AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDescriptorSetLayoutSupport(gfxstream_device->internal_object, pCreateInfo,
+ pSupport, true /* do lock */);
+ }
}
#endif
#ifdef VK_VERSION_1_2
-static void entry_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, VkBuffer countBuffer,
- VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
- uint32_t stride) {
+void gfxstream_vk_CmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+ uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndirectCount");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset,
- maxDrawCount, stride, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_countBuffer, countBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDrawIndirectCount(gfxstream_commandBuffer->internal_object,
+ gfxstream_buffer->internal_object, offset,
+ gfxstream_countBuffer->internal_object, countBufferOffset,
+ maxDrawCount, stride, true /* do lock */);
+ }
}
-static void entry_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount, uint32_t stride) {
+void gfxstream_vk_CmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+ uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCount");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer,
- countBufferOffset, maxDrawCount, stride,
- true /* do lock */);
-}
-static VkResult entry_vkCreateRenderPass2(VkDevice device,
- const VkRenderPassCreateInfo2* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass) {
- AEMU_SCOPED_TRACE("vkCreateRenderPass2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateRenderPass2_VkResult_return = (VkResult)0;
- vkCreateRenderPass2_VkResult_return = vkEnc->vkCreateRenderPass2(
- device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
- return vkCreateRenderPass2_VkResult_return;
-}
-static VkResult dynCheck_entry_vkCreateRenderPass2(VkDevice device,
- const VkRenderPassCreateInfo2* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
- sOnInvalidDynamicallyCheckedCall("vkCreateRenderPass2", "VK_VERSION_1_2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_countBuffer, countBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDrawIndexedIndirectCount(
+ gfxstream_commandBuffer->internal_object, gfxstream_buffer->internal_object, offset,
+ gfxstream_countBuffer->internal_object, countBufferOffset, maxDrawCount, stride,
+ true /* do lock */);
}
+}
+VkResult gfxstream_vk_CreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass) {
AEMU_SCOPED_TRACE("vkCreateRenderPass2");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateRenderPass2_VkResult_return = (VkResult)0;
- vkCreateRenderPass2_VkResult_return = vkEnc->vkCreateRenderPass2(
- device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_render_pass* gfxstream_pRenderPass =
+ (gfxstream_vk_render_pass*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+ sizeof(gfxstream_vk_render_pass),
+ VK_OBJECT_TYPE_RENDER_PASS);
+ vkCreateRenderPass2_VkResult_return =
+ gfxstream_pRenderPass ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateRenderPass2_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreateRenderPass2_VkResult_return =
+ vkEnc->vkCreateRenderPass2(gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pRenderPass->internal_object, true /* do lock */);
+ }
+ *pRenderPass = gfxstream_vk_render_pass_to_handle(gfxstream_pRenderPass);
return vkCreateRenderPass2_VkResult_return;
}
-static void entry_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- const VkSubpassBeginInfo* pSubpassBeginInfo) {
+void gfxstream_vk_CmdBeginRenderPass2(VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ const VkSubpassBeginInfo* pSubpassBeginInfo) {
AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkRenderPassBeginInfo> internal_pRenderPassBegin(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pRenderPassBegin[i] = pRenderPassBegin[i];
+ /* VkRenderPassBeginInfo::renderPass */
+ VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass,
+ internal_pRenderPassBegin[i].renderPass);
+ internal_pRenderPassBegin[i].renderPass = gfxstream_renderPass->internal_object;
+ /* VkRenderPassBeginInfo::framebuffer */
+ VK_FROM_HANDLE(gfxstream_vk_framebuffer, gfxstream_framebuffer,
+ internal_pRenderPassBegin[i].framebuffer);
+ internal_pRenderPassBegin[i].framebuffer = gfxstream_framebuffer->internal_object;
+ }
+ vkEnc->vkCmdBeginRenderPass2(gfxstream_commandBuffer->internal_object,
+ internal_pRenderPassBegin.data(), pSubpassBeginInfo,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdNextSubpass2(VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
- const VkSubpassEndInfo* pSubpassEndInfo) {
+void gfxstream_vk_CmdNextSubpass2(VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfo* pSubpassBeginInfo,
+ const VkSubpassEndInfo* pSubpassEndInfo) {
AEMU_SCOPED_TRACE("vkCmdNextSubpass2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdNextSubpass2(gfxstream_commandBuffer->internal_object, pSubpassBeginInfo,
+ pSubpassEndInfo, true /* do lock */);
+ }
}
-static void entry_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer,
- const VkSubpassEndInfo* pSubpassEndInfo) {
+void gfxstream_vk_CmdEndRenderPass2(VkCommandBuffer commandBuffer,
+ const VkSubpassEndInfo* pSubpassEndInfo) {
AEMU_SCOPED_TRACE("vkCmdEndRenderPass2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo, true /* do lock */);
-}
-static void entry_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
- uint32_t queryCount) {
- AEMU_SCOPED_TRACE("vkResetQueryPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkResetQueryPool(device, queryPool, firstQuery, queryCount, true /* do lock */);
-}
-static void dynCheck_entry_vkResetQueryPool(VkDevice device, VkQueryPool queryPool,
- uint32_t firstQuery, uint32_t queryCount) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
- sOnInvalidDynamicallyCheckedCall("vkResetQueryPool", "VK_VERSION_1_2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdEndRenderPass2(gfxstream_commandBuffer->internal_object, pSubpassEndInfo,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkResetQueryPool");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkResetQueryPool(device, queryPool, firstQuery, queryCount, true /* do lock */);
}
-static VkResult entry_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
- uint64_t* pValue) {
+void gfxstream_vk_ResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
+ uint32_t queryCount) {
+ AEMU_SCOPED_TRACE("vkResetQueryPool");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkResetQueryPool(gfxstream_device->internal_object,
+ gfxstream_queryPool->internal_object, firstQuery, queryCount,
+ true /* do lock */);
+ }
+}
+VkResult gfxstream_vk_GetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
+ uint64_t* pValue) {
AEMU_SCOPED_TRACE("vkGetSemaphoreCounterValue");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSemaphoreCounterValue_VkResult_return = (VkResult)0;
- vkGetSemaphoreCounterValue_VkResult_return =
- vkEnc->vkGetSemaphoreCounterValue(device, semaphore, pValue, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore, semaphore);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetSemaphoreCounterValue_VkResult_return = vkEnc->vkGetSemaphoreCounterValue(
+ gfxstream_device->internal_object, gfxstream_semaphore->internal_object, pValue,
+ true /* do lock */);
+ }
return vkGetSemaphoreCounterValue_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
- uint64_t* pValue) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
- sOnInvalidDynamicallyCheckedCall("vkGetSemaphoreCounterValue", "VK_VERSION_1_2");
- }
- AEMU_SCOPED_TRACE("vkGetSemaphoreCounterValue");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetSemaphoreCounterValue_VkResult_return = (VkResult)0;
- vkGetSemaphoreCounterValue_VkResult_return =
- vkEnc->vkGetSemaphoreCounterValue(device, semaphore, pValue, true /* do lock */);
- return vkGetSemaphoreCounterValue_VkResult_return;
-}
-static VkResult entry_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo,
- uint64_t timeout) {
+VkResult gfxstream_vk_WaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo,
+ uint64_t timeout) {
AEMU_SCOPED_TRACE("vkWaitSemaphores");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkWaitSemaphores_VkResult_return = (VkResult)0;
- vkWaitSemaphores_VkResult_return =
- vkEnc->vkWaitSemaphores(device, pWaitInfo, timeout, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkSemaphoreWaitInfo> internal_pWaitInfo(1);
+ std::vector<std::vector<VkSemaphore>> internal_VkSemaphoreWaitInfo_pSemaphores;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pWaitInfo[i] = pWaitInfo[i];
+ /* VkSemaphoreWaitInfo::pSemaphores */
+ internal_VkSemaphoreWaitInfo_pSemaphores.push_back(std::vector<VkSemaphore>());
+ internal_VkSemaphoreWaitInfo_pSemaphores[i] = transformVkSemaphoreList(
+ internal_pWaitInfo[i].pSemaphores, internal_pWaitInfo[i].semaphoreCount);
+ internal_pWaitInfo[i].pSemaphores = internal_VkSemaphoreWaitInfo_pSemaphores[i].data();
+ internal_pWaitInfo[i].semaphoreCount =
+ internal_VkSemaphoreWaitInfo_pSemaphores[i].size();
+ }
+ vkWaitSemaphores_VkResult_return =
+ vkEnc->vkWaitSemaphores(gfxstream_device->internal_object, internal_pWaitInfo.data(),
+ timeout, true /* do lock */);
+ }
return vkWaitSemaphores_VkResult_return;
}
-static VkResult dynCheck_entry_vkWaitSemaphores(VkDevice device,
- const VkSemaphoreWaitInfo* pWaitInfo,
- uint64_t timeout) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
- sOnInvalidDynamicallyCheckedCall("vkWaitSemaphores", "VK_VERSION_1_2");
- }
- AEMU_SCOPED_TRACE("vkWaitSemaphores");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkWaitSemaphores_VkResult_return = (VkResult)0;
- vkWaitSemaphores_VkResult_return =
- vkEnc->vkWaitSemaphores(device, pWaitInfo, timeout, true /* do lock */);
- return vkWaitSemaphores_VkResult_return;
-}
-static VkResult entry_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) {
+VkResult gfxstream_vk_SignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) {
AEMU_SCOPED_TRACE("vkSignalSemaphore");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSignalSemaphore_VkResult_return = (VkResult)0;
- vkSignalSemaphore_VkResult_return =
- vkEnc->vkSignalSemaphore(device, pSignalInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkSemaphoreSignalInfo> internal_pSignalInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pSignalInfo[i] = pSignalInfo[i];
+ /* VkSemaphoreSignalInfo::semaphore */
+ VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore,
+ internal_pSignalInfo[i].semaphore);
+ internal_pSignalInfo[i].semaphore = gfxstream_semaphore->internal_object;
+ }
+ vkSignalSemaphore_VkResult_return = vkEnc->vkSignalSemaphore(
+ gfxstream_device->internal_object, internal_pSignalInfo.data(), true /* do lock */);
+ }
return vkSignalSemaphore_VkResult_return;
}
-static VkResult dynCheck_entry_vkSignalSemaphore(VkDevice device,
- const VkSemaphoreSignalInfo* pSignalInfo) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
- sOnInvalidDynamicallyCheckedCall("vkSignalSemaphore", "VK_VERSION_1_2");
- }
- AEMU_SCOPED_TRACE("vkSignalSemaphore");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkSignalSemaphore_VkResult_return = (VkResult)0;
- vkSignalSemaphore_VkResult_return =
- vkEnc->vkSignalSemaphore(device, pSignalInfo, true /* do lock */);
- return vkSignalSemaphore_VkResult_return;
-}
-static VkDeviceAddress entry_vkGetBufferDeviceAddress(VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo) {
+VkDeviceAddress gfxstream_vk_GetBufferDeviceAddress(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetBufferDeviceAddress");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkDeviceAddress vkGetBufferDeviceAddress_VkDeviceAddress_return = (VkDeviceAddress)0;
- vkGetBufferDeviceAddress_VkDeviceAddress_return =
- vkEnc->vkGetBufferDeviceAddress(device, pInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBufferDeviceAddressInfo> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkBufferDeviceAddressInfo::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
+ internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
+ }
+ vkGetBufferDeviceAddress_VkDeviceAddress_return = vkEnc->vkGetBufferDeviceAddress(
+ gfxstream_device->internal_object, internal_pInfo.data(), true /* do lock */);
+ }
return vkGetBufferDeviceAddress_VkDeviceAddress_return;
}
-static VkDeviceAddress dynCheck_entry_vkGetBufferDeviceAddress(
- VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
- sOnInvalidDynamicallyCheckedCall("vkGetBufferDeviceAddress", "VK_VERSION_1_2");
- }
- AEMU_SCOPED_TRACE("vkGetBufferDeviceAddress");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkDeviceAddress vkGetBufferDeviceAddress_VkDeviceAddress_return = (VkDeviceAddress)0;
- vkGetBufferDeviceAddress_VkDeviceAddress_return =
- vkEnc->vkGetBufferDeviceAddress(device, pInfo, true /* do lock */);
- return vkGetBufferDeviceAddress_VkDeviceAddress_return;
-}
-static uint64_t entry_vkGetBufferOpaqueCaptureAddress(VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo) {
+uint64_t gfxstream_vk_GetBufferOpaqueCaptureAddress(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddress");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetBufferOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
- vkGetBufferOpaqueCaptureAddress_uint64_t_return =
- vkEnc->vkGetBufferOpaqueCaptureAddress(device, pInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBufferDeviceAddressInfo> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkBufferDeviceAddressInfo::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
+ internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
+ }
+ vkGetBufferOpaqueCaptureAddress_uint64_t_return = vkEnc->vkGetBufferOpaqueCaptureAddress(
+ gfxstream_device->internal_object, internal_pInfo.data(), true /* do lock */);
+ }
return vkGetBufferOpaqueCaptureAddress_uint64_t_return;
}
-static uint64_t dynCheck_entry_vkGetBufferOpaqueCaptureAddress(
- VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
- sOnInvalidDynamicallyCheckedCall("vkGetBufferOpaqueCaptureAddress", "VK_VERSION_1_2");
- }
- AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddress");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- uint64_t vkGetBufferOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
- vkGetBufferOpaqueCaptureAddress_uint64_t_return =
- vkEnc->vkGetBufferOpaqueCaptureAddress(device, pInfo, true /* do lock */);
- return vkGetBufferOpaqueCaptureAddress_uint64_t_return;
-}
-static uint64_t entry_vkGetDeviceMemoryOpaqueCaptureAddress(
+uint64_t gfxstream_vk_GetDeviceMemoryOpaqueCaptureAddress(
VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddress");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
- vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return =
- vkEnc->vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo, true /* do lock */);
- return vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return;
-}
-static uint64_t dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddress(
- VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceMemoryOpaqueCaptureAddress", "VK_VERSION_1_2");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkDeviceMemoryOpaqueCaptureAddressInfo> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkDeviceMemoryOpaqueCaptureAddressInfo::memory */
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, internal_pInfo[i].memory);
+ internal_pInfo[i].memory = gfxstream_memory->internal_object;
+ }
+ vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return =
+ vkEnc->vkGetDeviceMemoryOpaqueCaptureAddress(gfxstream_device->internal_object,
+ internal_pInfo.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddress");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- uint64_t vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
- vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return =
- vkEnc->vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo, true /* do lock */);
return vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return;
}
#endif
#ifdef VK_VERSION_1_3
-static VkResult entry_vkGetPhysicalDeviceToolProperties(
+VkResult gfxstream_vk_GetPhysicalDeviceToolProperties(
VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
VkPhysicalDeviceToolProperties* pToolProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceToolProperties");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceToolProperties_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceToolProperties_VkResult_return = vkEnc->vkGetPhysicalDeviceToolProperties(
- physicalDevice, pToolCount, pToolProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetPhysicalDeviceToolProperties_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceToolProperties(gfxstream_physicalDevice->internal_object,
+ pToolCount, pToolProperties,
+ true /* do lock */);
+ }
return vkGetPhysicalDeviceToolProperties_VkResult_return;
}
-static VkResult entry_vkCreatePrivateDataSlot(VkDevice device,
- const VkPrivateDataSlotCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPrivateDataSlot* pPrivateDataSlot) {
+VkResult gfxstream_vk_CreatePrivateDataSlot(VkDevice device,
+ const VkPrivateDataSlotCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPrivateDataSlot* pPrivateDataSlot) {
AEMU_SCOPED_TRACE("vkCreatePrivateDataSlot");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreatePrivateDataSlot_VkResult_return = (VkResult)0;
- vkCreatePrivateDataSlot_VkResult_return = vkEnc->vkCreatePrivateDataSlot(
- device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreatePrivateDataSlot_VkResult_return =
+ vkEnc->vkCreatePrivateDataSlot(gfxstream_device->internal_object, pCreateInfo,
+ pAllocator, pPrivateDataSlot, true /* do lock */);
+ }
return vkCreatePrivateDataSlot_VkResult_return;
}
-static VkResult dynCheck_entry_vkCreatePrivateDataSlot(
- VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
- sOnInvalidDynamicallyCheckedCall("vkCreatePrivateDataSlot", "VK_VERSION_1_3");
- }
- AEMU_SCOPED_TRACE("vkCreatePrivateDataSlot");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreatePrivateDataSlot_VkResult_return = (VkResult)0;
- vkCreatePrivateDataSlot_VkResult_return = vkEnc->vkCreatePrivateDataSlot(
- device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
- return vkCreatePrivateDataSlot_VkResult_return;
-}
-static void entry_vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlot");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPrivateDataSlot(device, privateDataSlot, pAllocator, true /* do lock */);
-}
-static void dynCheck_entry_vkDestroyPrivateDataSlot(VkDevice device,
- VkPrivateDataSlot privateDataSlot,
- const VkAllocationCallbacks* pAllocator) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
- sOnInvalidDynamicallyCheckedCall("vkDestroyPrivateDataSlot", "VK_VERSION_1_3");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyPrivateDataSlot(gfxstream_device->internal_object, privateDataSlot,
+ pAllocator, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlot");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPrivateDataSlot(device, privateDataSlot, pAllocator, true /* do lock */);
}
-static VkResult entry_vkSetPrivateData(VkDevice device, VkObjectType objectType,
- uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
- uint64_t data) {
+VkResult gfxstream_vk_SetPrivateData(VkDevice device, VkObjectType objectType,
+ uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
+ uint64_t data) {
AEMU_SCOPED_TRACE("vkSetPrivateData");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetPrivateData_VkResult_return = (VkResult)0;
- vkSetPrivateData_VkResult_return = vkEnc->vkSetPrivateData(
- device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkSetPrivateData_VkResult_return =
+ vkEnc->vkSetPrivateData(gfxstream_device->internal_object, objectType, objectHandle,
+ privateDataSlot, data, true /* do lock */);
+ }
return vkSetPrivateData_VkResult_return;
}
-static VkResult dynCheck_entry_vkSetPrivateData(VkDevice device, VkObjectType objectType,
- uint64_t objectHandle,
- VkPrivateDataSlot privateDataSlot, uint64_t data) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
- sOnInvalidDynamicallyCheckedCall("vkSetPrivateData", "VK_VERSION_1_3");
- }
- AEMU_SCOPED_TRACE("vkSetPrivateData");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkSetPrivateData_VkResult_return = (VkResult)0;
- vkSetPrivateData_VkResult_return = vkEnc->vkSetPrivateData(
- device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
- return vkSetPrivateData_VkResult_return;
-}
-static void entry_vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
- VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
+void gfxstream_vk_GetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
+ VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
AEMU_SCOPED_TRACE("vkGetPrivateData");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPrivateData(device, objectType, objectHandle, privateDataSlot, pData,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetPrivateData(VkDevice device, VkObjectType objectType,
- uint64_t objectHandle,
- VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
- sOnInvalidDynamicallyCheckedCall("vkGetPrivateData", "VK_VERSION_1_3");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPrivateData(gfxstream_device->internal_object, objectType, objectHandle,
+ privateDataSlot, pData, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetPrivateData");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPrivateData(device, objectType, objectHandle, privateDataSlot, pData,
- true /* do lock */);
}
-static void entry_vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
- const VkDependencyInfo* pDependencyInfo) {
+void gfxstream_vk_CmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
+ const VkDependencyInfo* pDependencyInfo) {
AEMU_SCOPED_TRACE("vkCmdSetEvent2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetEvent2(commandBuffer, event, pDependencyInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkDependencyInfo> internal_pDependencyInfo(1);
+ std::vector<std::vector<VkBufferMemoryBarrier2>>
+ internal_VkDependencyInfo_pBufferMemoryBarriers;
+ std::vector<std::vector<VkImageMemoryBarrier2>>
+ internal_VkDependencyInfo_pImageMemoryBarriers;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pDependencyInfo[i] = pDependencyInfo[i];
+ /* VkDependencyInfo::pBufferMemoryBarriers */
+ internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
+ std::vector<VkBufferMemoryBarrier2>());
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
+ internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
+ sizeof(VkBufferMemoryBarrier2) *
+ internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfo[i].bufferMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
+ internal_pDependencyInfo[i].pBufferMemoryBarriers[j];
+ /* VkBufferMemoryBarrier2::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ }
+ internal_pDependencyInfo[i].pBufferMemoryBarriers =
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
+ /* VkDependencyInfo::pImageMemoryBarriers */
+ internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
+ std::vector<VkImageMemoryBarrier2>());
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
+ internal_pDependencyInfo[i].imageMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
+ sizeof(VkImageMemoryBarrier2) *
+ internal_pDependencyInfo[i].imageMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfo[i].imageMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
+ internal_pDependencyInfo[i].pImageMemoryBarriers[j];
+ /* VkImageMemoryBarrier2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
+ gfxstream_image->internal_object;
+ }
+ internal_pDependencyInfo[i].pImageMemoryBarriers =
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
+ }
+ vkEnc->vkCmdSetEvent2(gfxstream_commandBuffer->internal_object,
+ gfxstream_event->internal_object, internal_pDependencyInfo.data(),
+ true /* do lock */);
+ }
}
-static void entry_vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
- VkPipelineStageFlags2 stageMask) {
+void gfxstream_vk_CmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
+ VkPipelineStageFlags2 stageMask) {
AEMU_SCOPED_TRACE("vkCmdResetEvent2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResetEvent2(commandBuffer, event, stageMask, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdResetEvent2(gfxstream_commandBuffer->internal_object,
+ gfxstream_event->internal_object, stageMask, true /* do lock */);
+ }
}
-static void entry_vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount,
- const VkEvent* pEvents,
- const VkDependencyInfo* pDependencyInfos) {
+void gfxstream_vk_CmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount,
+ const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) {
AEMU_SCOPED_TRACE("vkCmdWaitEvents2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkEvent> internal_pEvents(eventCount);
+ for (uint32_t i = 0; i < eventCount; ++i) {
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_pEvents, pEvents[i]);
+ internal_pEvents[i] = gfxstream_pEvents->internal_object;
+ }
+ std::vector<VkDependencyInfo> internal_pDependencyInfos(eventCount);
+ std::vector<std::vector<VkBufferMemoryBarrier2>>
+ internal_VkDependencyInfo_pBufferMemoryBarriers;
+ std::vector<std::vector<VkImageMemoryBarrier2>>
+ internal_VkDependencyInfo_pImageMemoryBarriers;
+ for (uint32_t i = 0; i < eventCount; ++i) {
+ internal_pDependencyInfos[i] = pDependencyInfos[i];
+ /* VkDependencyInfo::pBufferMemoryBarriers */
+ internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
+ std::vector<VkBufferMemoryBarrier2>());
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
+ internal_pDependencyInfos[i].bufferMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
+ sizeof(VkBufferMemoryBarrier2) *
+ internal_pDependencyInfos[i].bufferMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfos[i].bufferMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
+ internal_pDependencyInfos[i].pBufferMemoryBarriers[j];
+ /* VkBufferMemoryBarrier2::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ }
+ internal_pDependencyInfos[i].pBufferMemoryBarriers =
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
+ /* VkDependencyInfo::pImageMemoryBarriers */
+ internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
+ std::vector<VkImageMemoryBarrier2>());
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
+ internal_pDependencyInfos[i].imageMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
+ sizeof(VkImageMemoryBarrier2) *
+ internal_pDependencyInfos[i].imageMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfos[i].imageMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
+ internal_pDependencyInfos[i].pImageMemoryBarriers[j];
+ /* VkImageMemoryBarrier2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
+ gfxstream_image->internal_object;
+ }
+ internal_pDependencyInfos[i].pImageMemoryBarriers =
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
+ }
+ vkEnc->vkCmdWaitEvents2(gfxstream_commandBuffer->internal_object, eventCount,
+ internal_pEvents.data(), internal_pDependencyInfos.data(),
+ true /* do lock */);
+ }
}
-static void entry_vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer,
- const VkDependencyInfo* pDependencyInfo) {
+void gfxstream_vk_CmdPipelineBarrier2(VkCommandBuffer commandBuffer,
+ const VkDependencyInfo* pDependencyInfo) {
AEMU_SCOPED_TRACE("vkCmdPipelineBarrier2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdPipelineBarrier2(commandBuffer, pDependencyInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkDependencyInfo> internal_pDependencyInfo(1);
+ std::vector<std::vector<VkBufferMemoryBarrier2>>
+ internal_VkDependencyInfo_pBufferMemoryBarriers;
+ std::vector<std::vector<VkImageMemoryBarrier2>>
+ internal_VkDependencyInfo_pImageMemoryBarriers;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pDependencyInfo[i] = pDependencyInfo[i];
+ /* VkDependencyInfo::pBufferMemoryBarriers */
+ internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
+ std::vector<VkBufferMemoryBarrier2>());
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
+ internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
+ sizeof(VkBufferMemoryBarrier2) *
+ internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfo[i].bufferMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
+ internal_pDependencyInfo[i].pBufferMemoryBarriers[j];
+ /* VkBufferMemoryBarrier2::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ }
+ internal_pDependencyInfo[i].pBufferMemoryBarriers =
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
+ /* VkDependencyInfo::pImageMemoryBarriers */
+ internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
+ std::vector<VkImageMemoryBarrier2>());
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
+ internal_pDependencyInfo[i].imageMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
+ sizeof(VkImageMemoryBarrier2) *
+ internal_pDependencyInfo[i].imageMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfo[i].imageMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
+ internal_pDependencyInfo[i].pImageMemoryBarriers[j];
+ /* VkImageMemoryBarrier2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
+ gfxstream_image->internal_object;
+ }
+ internal_pDependencyInfo[i].pImageMemoryBarriers =
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
+ }
+ vkEnc->vkCmdPipelineBarrier2(gfxstream_commandBuffer->internal_object,
+ internal_pDependencyInfo.data(), true /* do lock */);
+ }
}
-static void entry_vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
- VkQueryPool queryPool, uint32_t query) {
+void gfxstream_vk_CmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
+ VkQueryPool queryPool, uint32_t query) {
AEMU_SCOPED_TRACE("vkCmdWriteTimestamp2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteTimestamp2(commandBuffer, stage, queryPool, query, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdWriteTimestamp2(gfxstream_commandBuffer->internal_object, stage,
+ gfxstream_queryPool->internal_object, query,
+ true /* do lock */);
+ }
}
-static VkResult entry_vkQueueSubmit2(VkQueue queue, uint32_t submitCount,
- const VkSubmitInfo2* pSubmits, VkFence fence) {
+VkResult gfxstream_vk_QueueSubmit2(VkQueue queue, uint32_t submitCount,
+ const VkSubmitInfo2* pSubmits, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueSubmit2");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueSubmit2_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkQueueSubmit2_VkResult_return =
- resources->on_vkQueueSubmit2(vkEnc, VK_SUCCESS, queue, submitCount, pSubmits, fence);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkSubmitInfo2> internal_pSubmits(submitCount);
+ std::vector<std::vector<VkSemaphoreSubmitInfo>> internal_VkSubmitInfo2_pWaitSemaphoreInfos;
+ std::vector<std::vector<VkCommandBufferSubmitInfo>>
+ internal_VkSubmitInfo2_pCommandBufferInfos;
+ std::vector<std::vector<VkSemaphoreSubmitInfo>>
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos;
+ for (uint32_t i = 0; i < submitCount; ++i) {
+ internal_pSubmits[i] = pSubmits[i];
+ /* VkSubmitInfo2::pWaitSemaphoreInfos */
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos.push_back(
+ std::vector<VkSemaphoreSubmitInfo>());
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos[i] =
+ transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pWaitSemaphoreInfos,
+ internal_pSubmits[i].waitSemaphoreInfoCount);
+ internal_pSubmits[i].pWaitSemaphoreInfos =
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].data();
+ internal_pSubmits[i].waitSemaphoreInfoCount =
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].size();
+ /* VkSubmitInfo2::pCommandBufferInfos */
+ internal_VkSubmitInfo2_pCommandBufferInfos.push_back(
+ std::vector<VkCommandBufferSubmitInfo>());
+ internal_VkSubmitInfo2_pCommandBufferInfos[i].reserve(
+ internal_pSubmits[i].commandBufferInfoCount);
+ memset(&internal_VkSubmitInfo2_pCommandBufferInfos[i][0], 0,
+ sizeof(VkCommandBufferSubmitInfo) * internal_pSubmits[i].commandBufferInfoCount);
+ for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferInfoCount; ++j) {
+ internal_VkSubmitInfo2_pCommandBufferInfos[i][j] =
+ internal_pSubmits[i].pCommandBufferInfos[j];
+ /* VkCommandBufferSubmitInfo::commandBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer,
+ internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer);
+ internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer =
+ gfxstream_commandBuffer->internal_object;
+ }
+ internal_pSubmits[i].pCommandBufferInfos =
+ internal_VkSubmitInfo2_pCommandBufferInfos[i].data();
+ /* VkSubmitInfo2::pSignalSemaphoreInfos */
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos.push_back(
+ std::vector<VkSemaphoreSubmitInfo>());
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos[i] =
+ transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pSignalSemaphoreInfos,
+ internal_pSubmits[i].signalSemaphoreInfoCount);
+ internal_pSubmits[i].pSignalSemaphoreInfos =
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].data();
+ internal_pSubmits[i].signalSemaphoreInfoCount =
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].size();
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkQueueSubmit2_VkResult_return = resources->on_vkQueueSubmit2(
+ vkEnc, VK_SUCCESS, gfxstream_queue->internal_object, submitCount,
+ internal_pSubmits.data(),
+ gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE);
+ }
return vkQueueSubmit2_VkResult_return;
}
-static void entry_vkCmdCopyBuffer2(VkCommandBuffer commandBuffer,
- const VkCopyBufferInfo2* pCopyBufferInfo) {
+void gfxstream_vk_CmdCopyBuffer2(VkCommandBuffer commandBuffer,
+ const VkCopyBufferInfo2* pCopyBufferInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyBuffer2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyBuffer2(commandBuffer, pCopyBufferInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCopyBufferInfo2> internal_pCopyBufferInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyBufferInfo[i] = pCopyBufferInfo[i];
+ /* VkCopyBufferInfo2::srcBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer,
+ internal_pCopyBufferInfo[i].srcBuffer);
+ internal_pCopyBufferInfo[i].srcBuffer = gfxstream_srcBuffer->internal_object;
+ /* VkCopyBufferInfo2::dstBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer,
+ internal_pCopyBufferInfo[i].dstBuffer);
+ internal_pCopyBufferInfo[i].dstBuffer = gfxstream_dstBuffer->internal_object;
+ }
+ vkEnc->vkCmdCopyBuffer2(gfxstream_commandBuffer->internal_object,
+ internal_pCopyBufferInfo.data(), true /* do lock */);
+ }
}
-static void entry_vkCmdCopyImage2(VkCommandBuffer commandBuffer,
- const VkCopyImageInfo2* pCopyImageInfo) {
+void gfxstream_vk_CmdCopyImage2(VkCommandBuffer commandBuffer,
+ const VkCopyImageInfo2* pCopyImageInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyImage2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyImage2(commandBuffer, pCopyImageInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCopyImageInfo2> internal_pCopyImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyImageInfo[i] = pCopyImageInfo[i];
+ /* VkCopyImageInfo2::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pCopyImageInfo[i].srcImage);
+ internal_pCopyImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ /* VkCopyImageInfo2::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pCopyImageInfo[i].dstImage);
+ internal_pCopyImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkEnc->vkCmdCopyImage2(gfxstream_commandBuffer->internal_object,
+ internal_pCopyImageInfo.data(), true /* do lock */);
+ }
}
-static void entry_vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer,
- const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
+void gfxstream_vk_CmdCopyBufferToImage2(VkCommandBuffer commandBuffer,
+ const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCopyBufferToImageInfo2> internal_pCopyBufferToImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyBufferToImageInfo[i] = pCopyBufferToImageInfo[i];
+ /* VkCopyBufferToImageInfo2::srcBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer,
+ internal_pCopyBufferToImageInfo[i].srcBuffer);
+ internal_pCopyBufferToImageInfo[i].srcBuffer = gfxstream_srcBuffer->internal_object;
+ /* VkCopyBufferToImageInfo2::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pCopyBufferToImageInfo[i].dstImage);
+ internal_pCopyBufferToImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkEnc->vkCmdCopyBufferToImage2(gfxstream_commandBuffer->internal_object,
+ internal_pCopyBufferToImageInfo.data(), true /* do lock */);
+ }
}
-static void entry_vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer,
- const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
+void gfxstream_vk_CmdCopyImageToBuffer2(VkCommandBuffer commandBuffer,
+ const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCopyImageToBufferInfo2> internal_pCopyImageToBufferInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyImageToBufferInfo[i] = pCopyImageToBufferInfo[i];
+ /* VkCopyImageToBufferInfo2::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pCopyImageToBufferInfo[i].srcImage);
+ internal_pCopyImageToBufferInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ /* VkCopyImageToBufferInfo2::dstBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer,
+ internal_pCopyImageToBufferInfo[i].dstBuffer);
+ internal_pCopyImageToBufferInfo[i].dstBuffer = gfxstream_dstBuffer->internal_object;
+ }
+ vkEnc->vkCmdCopyImageToBuffer2(gfxstream_commandBuffer->internal_object,
+ internal_pCopyImageToBufferInfo.data(), true /* do lock */);
+ }
}
-static void entry_vkCmdBlitImage2(VkCommandBuffer commandBuffer,
- const VkBlitImageInfo2* pBlitImageInfo) {
+void gfxstream_vk_CmdBlitImage2(VkCommandBuffer commandBuffer,
+ const VkBlitImageInfo2* pBlitImageInfo) {
AEMU_SCOPED_TRACE("vkCmdBlitImage2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBlitImage2(commandBuffer, pBlitImageInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkBlitImageInfo2> internal_pBlitImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pBlitImageInfo[i] = pBlitImageInfo[i];
+ /* VkBlitImageInfo2::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pBlitImageInfo[i].srcImage);
+ internal_pBlitImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ /* VkBlitImageInfo2::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pBlitImageInfo[i].dstImage);
+ internal_pBlitImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkEnc->vkCmdBlitImage2(gfxstream_commandBuffer->internal_object,
+ internal_pBlitImageInfo.data(), true /* do lock */);
+ }
}
-static void entry_vkCmdResolveImage2(VkCommandBuffer commandBuffer,
- const VkResolveImageInfo2* pResolveImageInfo) {
+void gfxstream_vk_CmdResolveImage2(VkCommandBuffer commandBuffer,
+ const VkResolveImageInfo2* pResolveImageInfo) {
AEMU_SCOPED_TRACE("vkCmdResolveImage2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResolveImage2(commandBuffer, pResolveImageInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkResolveImageInfo2> internal_pResolveImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pResolveImageInfo[i] = pResolveImageInfo[i];
+ /* VkResolveImageInfo2::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pResolveImageInfo[i].srcImage);
+ internal_pResolveImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ /* VkResolveImageInfo2::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pResolveImageInfo[i].dstImage);
+ internal_pResolveImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkEnc->vkCmdResolveImage2(gfxstream_commandBuffer->internal_object,
+ internal_pResolveImageInfo.data(), true /* do lock */);
+ }
}
-static void entry_vkCmdBeginRendering(VkCommandBuffer commandBuffer,
- const VkRenderingInfo* pRenderingInfo) {
+void gfxstream_vk_CmdBeginRendering(VkCommandBuffer commandBuffer,
+ const VkRenderingInfo* pRenderingInfo) {
AEMU_SCOPED_TRACE("vkCmdBeginRendering");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginRendering(commandBuffer, pRenderingInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkRenderingInfo> internal_pRenderingInfo(1);
+ std::vector<std::vector<VkRenderingAttachmentInfo>>
+ internal_VkRenderingInfo_pColorAttachments;
+ std::vector<VkRenderingAttachmentInfo> internal_VkRenderingInfo_pDepthAttachment;
+ std::vector<VkRenderingAttachmentInfo> internal_VkRenderingInfo_pStencilAttachment;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pRenderingInfo[i] = pRenderingInfo[i];
+ /* VkRenderingInfo::pColorAttachments */
+ internal_VkRenderingInfo_pColorAttachments.push_back(
+ std::vector<VkRenderingAttachmentInfo>());
+ internal_VkRenderingInfo_pColorAttachments[i].reserve(
+ internal_pRenderingInfo[i].colorAttachmentCount);
+ memset(&internal_VkRenderingInfo_pColorAttachments[i][0], 0,
+ sizeof(VkRenderingAttachmentInfo) *
+ internal_pRenderingInfo[i].colorAttachmentCount);
+ for (uint32_t j = 0; j < internal_pRenderingInfo[i].colorAttachmentCount; ++j) {
+ internal_VkRenderingInfo_pColorAttachments[i][j] =
+ internal_pRenderingInfo[i].pColorAttachments[j];
+ /* VkRenderingAttachmentInfo::imageView */
+ if (internal_VkRenderingInfo_pColorAttachments[i][j].imageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+ internal_VkRenderingInfo_pColorAttachments[i][j].imageView);
+ internal_VkRenderingInfo_pColorAttachments[i][j].imageView =
+ gfxstream_imageView->internal_object;
+ }
+ /* VkRenderingAttachmentInfo::resolveImageView */
+ if (internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView) {
+ VK_FROM_HANDLE(
+ gfxstream_vk_image_view, gfxstream_resolveImageView,
+ internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView);
+ internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView =
+ gfxstream_resolveImageView->internal_object;
+ }
+ }
+ internal_pRenderingInfo[i].pColorAttachments =
+ internal_VkRenderingInfo_pColorAttachments[i].data();
+ /* VkRenderingInfo::pDepthAttachment */
+ if (internal_pRenderingInfo[i].pDepthAttachment) {
+ internal_VkRenderingInfo_pDepthAttachment[i] =
+ internal_pRenderingInfo[i].pDepthAttachment[0];
+ /* VkRenderingAttachmentInfo::imageView */
+ if (internal_VkRenderingInfo_pDepthAttachment[i].imageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+ internal_VkRenderingInfo_pDepthAttachment[i].imageView);
+ internal_VkRenderingInfo_pDepthAttachment[i].imageView =
+ gfxstream_imageView->internal_object;
+ }
+ /* VkRenderingAttachmentInfo::resolveImageView */
+ if (internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_resolveImageView,
+ internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView);
+ internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView =
+ gfxstream_resolveImageView->internal_object;
+ }
+ internal_pRenderingInfo[i].pDepthAttachment =
+ &internal_VkRenderingInfo_pDepthAttachment[i];
+ }
+ /* VkRenderingInfo::pStencilAttachment */
+ if (internal_pRenderingInfo[i].pStencilAttachment) {
+ internal_VkRenderingInfo_pStencilAttachment[i] =
+ internal_pRenderingInfo[i].pStencilAttachment[0];
+ /* VkRenderingAttachmentInfo::imageView */
+ if (internal_VkRenderingInfo_pStencilAttachment[i].imageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+ internal_VkRenderingInfo_pStencilAttachment[i].imageView);
+ internal_VkRenderingInfo_pStencilAttachment[i].imageView =
+ gfxstream_imageView->internal_object;
+ }
+ /* VkRenderingAttachmentInfo::resolveImageView */
+ if (internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_resolveImageView,
+ internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView);
+ internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView =
+ gfxstream_resolveImageView->internal_object;
+ }
+ internal_pRenderingInfo[i].pStencilAttachment =
+ &internal_VkRenderingInfo_pStencilAttachment[i];
+ }
+ }
+ vkEnc->vkCmdBeginRendering(gfxstream_commandBuffer->internal_object,
+ internal_pRenderingInfo.data(), true /* do lock */);
+ }
}
-static void entry_vkCmdEndRendering(VkCommandBuffer commandBuffer) {
+void gfxstream_vk_CmdEndRendering(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkCmdEndRendering");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndRendering(commandBuffer, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdEndRendering(gfxstream_commandBuffer->internal_object, true /* do lock */);
+ }
}
-static void entry_vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
+void gfxstream_vk_CmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
AEMU_SCOPED_TRACE("vkCmdSetCullMode");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetCullMode(commandBuffer, cullMode, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetCullMode(gfxstream_commandBuffer->internal_object, cullMode,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
+void gfxstream_vk_CmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
AEMU_SCOPED_TRACE("vkCmdSetFrontFace");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetFrontFace(commandBuffer, frontFace, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetFrontFace(gfxstream_commandBuffer->internal_object, frontFace,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer,
- VkPrimitiveTopology primitiveTopology) {
+void gfxstream_vk_CmdSetPrimitiveTopology(VkCommandBuffer commandBuffer,
+ VkPrimitiveTopology primitiveTopology) {
AEMU_SCOPED_TRACE("vkCmdSetPrimitiveTopology");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetPrimitiveTopology(commandBuffer, primitiveTopology, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetPrimitiveTopology(gfxstream_commandBuffer->internal_object,
+ primitiveTopology, true /* do lock */);
+ }
}
-static void entry_vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount,
- const VkViewport* pViewports) {
+void gfxstream_vk_CmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount,
+ const VkViewport* pViewports) {
AEMU_SCOPED_TRACE("vkCmdSetViewportWithCount");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetViewportWithCount(commandBuffer, viewportCount, pViewports, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetViewportWithCount(gfxstream_commandBuffer->internal_object, viewportCount,
+ pViewports, true /* do lock */);
+ }
}
-static void entry_vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount,
- const VkRect2D* pScissors) {
+void gfxstream_vk_CmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount,
+ const VkRect2D* pScissors) {
AEMU_SCOPED_TRACE("vkCmdSetScissorWithCount");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetScissorWithCount(commandBuffer, scissorCount, pScissors, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetScissorWithCount(gfxstream_commandBuffer->internal_object, scissorCount,
+ pScissors, true /* do lock */);
+ }
}
-static void entry_vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding,
- uint32_t bindingCount, const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
- const VkDeviceSize* pStrides) {
+void gfxstream_vk_CmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+ uint32_t bindingCount, const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
+ const VkDeviceSize* pStrides) {
AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
- pSizes, pStrides, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkBuffer> internal_pBuffers(bindingCount);
+ for (uint32_t i = 0; i < bindingCount; ++i) {
+ if (pBuffers) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pBuffers, pBuffers[i]);
+ internal_pBuffers[i] = gfxstream_pBuffers->internal_object;
+ }
+ }
+ vkEnc->vkCmdBindVertexBuffers2(gfxstream_commandBuffer->internal_object, firstBinding,
+ bindingCount, internal_pBuffers.data(), pOffsets, pSizes,
+ pStrides, true /* do lock */);
+ }
}
-static void entry_vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {
+void gfxstream_vk_CmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthTestEnable");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthTestEnable(commandBuffer, depthTestEnable, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthTestEnable(gfxstream_commandBuffer->internal_object, depthTestEnable,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer,
- VkBool32 depthWriteEnable) {
+void gfxstream_vk_CmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthWriteEnable");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthWriteEnable(commandBuffer, depthWriteEnable, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthWriteEnable(gfxstream_commandBuffer->internal_object, depthWriteEnable,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer,
- VkCompareOp depthCompareOp) {
+void gfxstream_vk_CmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) {
AEMU_SCOPED_TRACE("vkCmdSetDepthCompareOp");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthCompareOp(commandBuffer, depthCompareOp, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthCompareOp(gfxstream_commandBuffer->internal_object, depthCompareOp,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer,
- VkBool32 depthBoundsTestEnable) {
+void gfxstream_vk_CmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer,
+ VkBool32 depthBoundsTestEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthBoundsTestEnable");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthBoundsTestEnable(gfxstream_commandBuffer->internal_object,
+ depthBoundsTestEnable, true /* do lock */);
+ }
}
-static void entry_vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer,
- VkBool32 stencilTestEnable) {
+void gfxstream_vk_CmdSetStencilTestEnable(VkCommandBuffer commandBuffer,
+ VkBool32 stencilTestEnable) {
AEMU_SCOPED_TRACE("vkCmdSetStencilTestEnable");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilTestEnable(commandBuffer, stencilTestEnable, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetStencilTestEnable(gfxstream_commandBuffer->internal_object,
+ stencilTestEnable, true /* do lock */);
+ }
}
-static void entry_vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
- VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp,
- VkCompareOp compareOp) {
+void gfxstream_vk_CmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+ VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp,
+ VkCompareOp compareOp) {
AEMU_SCOPED_TRACE("vkCmdSetStencilOp");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetStencilOp(gfxstream_commandBuffer->internal_object, faceMask, failOp, passOp,
+ depthFailOp, compareOp, true /* do lock */);
+ }
}
-static void entry_vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer,
- VkBool32 rasterizerDiscardEnable) {
+void gfxstream_vk_CmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer,
+ VkBool32 rasterizerDiscardEnable) {
AEMU_SCOPED_TRACE("vkCmdSetRasterizerDiscardEnable");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetRasterizerDiscardEnable(gfxstream_commandBuffer->internal_object,
+ rasterizerDiscardEnable, true /* do lock */);
+ }
}
-static void entry_vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {
+void gfxstream_vk_CmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthBiasEnable");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBiasEnable(commandBuffer, depthBiasEnable, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthBiasEnable(gfxstream_commandBuffer->internal_object, depthBiasEnable,
+ true /* do lock */);
+ }
}
-static void entry_vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer,
- VkBool32 primitiveRestartEnable) {
+void gfxstream_vk_CmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer,
+ VkBool32 primitiveRestartEnable) {
AEMU_SCOPED_TRACE("vkCmdSetPrimitiveRestartEnable");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable,
- true /* do lock */);
-}
-static void entry_vkGetDeviceBufferMemoryRequirements(VkDevice device,
- const VkDeviceBufferMemoryRequirements* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirements");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceBufferMemoryRequirements(
- VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceBufferMemoryRequirements", "VK_VERSION_1_3");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetPrimitiveRestartEnable(gfxstream_commandBuffer->internal_object,
+ primitiveRestartEnable, true /* do lock */);
}
+}
+void gfxstream_vk_GetDeviceBufferMemoryRequirements(VkDevice device,
+ const VkDeviceBufferMemoryRequirements* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirements");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements,
- true /* do lock */);
-}
-static void entry_vkGetDeviceImageMemoryRequirements(VkDevice device,
- const VkDeviceImageMemoryRequirements* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirements");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceImageMemoryRequirements(
- VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageMemoryRequirements", "VK_VERSION_1_3");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceBufferMemoryRequirements(gfxstream_device->internal_object, pInfo,
+ pMemoryRequirements, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirements");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements,
- true /* do lock */);
}
-static void entry_vkGetDeviceImageSparseMemoryRequirements(
+void gfxstream_vk_GetDeviceImageMemoryRequirements(VkDevice device,
+ const VkDeviceImageMemoryRequirements* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
+ AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirements");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceImageMemoryRequirements(gfxstream_device->internal_object, pInfo,
+ pMemoryRequirements, true /* do lock */);
+ }
+}
+void gfxstream_vk_GetDeviceImageSparseMemoryRequirements(
VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirements");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements, true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceImageSparseMemoryRequirements(
- VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
- uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageSparseMemoryRequirements",
- "VK_VERSION_1_3");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceImageSparseMemoryRequirements(
+ gfxstream_device->internal_object, pInfo, pSparseMemoryRequirementCount,
+ pSparseMemoryRequirements, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirements");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements, true /* do lock */);
}
#endif
#ifdef VK_KHR_surface
@@ -2171,140 +3639,236 @@
#ifdef VK_KHR_xcb_surface
#endif
#ifdef VK_KHR_android_surface
-static VkResult entry_vkCreateAndroidSurfaceKHR(VkInstance instance,
- const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface) {
+VkResult gfxstream_vk_CreateAndroidSurfaceKHR(VkInstance instance,
+ const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateAndroidSurfaceKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
- vkCreateAndroidSurfaceKHR_VkResult_return = vkEnc->vkCreateAndroidSurfaceKHR(
- instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_instance, gfxstream_instance, instance);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreateAndroidSurfaceKHR_VkResult_return =
+ vkEnc->vkCreateAndroidSurfaceKHR(gfxstream_instance->internal_object, pCreateInfo,
+ pAllocator, pSurface, true /* do lock */);
+ }
return vkCreateAndroidSurfaceKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_win32_surface
#endif
#ifdef VK_KHR_dynamic_rendering
-static void entry_vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
- const VkRenderingInfo* pRenderingInfo) {
+void gfxstream_vk_CmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
+ const VkRenderingInfo* pRenderingInfo) {
AEMU_SCOPED_TRACE("vkCmdBeginRenderingKHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginRenderingKHR(commandBuffer, pRenderingInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
- const VkRenderingInfo* pRenderingInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdBeginRenderingKHR", "VK_KHR_dynamic_rendering");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkRenderingInfo> internal_pRenderingInfo(1);
+ std::vector<std::vector<VkRenderingAttachmentInfo>>
+ internal_VkRenderingInfo_pColorAttachments;
+ std::vector<VkRenderingAttachmentInfo> internal_VkRenderingInfo_pDepthAttachment;
+ std::vector<VkRenderingAttachmentInfo> internal_VkRenderingInfo_pStencilAttachment;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pRenderingInfo[i] = pRenderingInfo[i];
+ /* VkRenderingInfo::pColorAttachments */
+ internal_VkRenderingInfo_pColorAttachments.push_back(
+ std::vector<VkRenderingAttachmentInfo>());
+ internal_VkRenderingInfo_pColorAttachments[i].reserve(
+ internal_pRenderingInfo[i].colorAttachmentCount);
+ memset(&internal_VkRenderingInfo_pColorAttachments[i][0], 0,
+ sizeof(VkRenderingAttachmentInfo) *
+ internal_pRenderingInfo[i].colorAttachmentCount);
+ for (uint32_t j = 0; j < internal_pRenderingInfo[i].colorAttachmentCount; ++j) {
+ internal_VkRenderingInfo_pColorAttachments[i][j] =
+ internal_pRenderingInfo[i].pColorAttachments[j];
+ /* VkRenderingAttachmentInfo::imageView */
+ if (internal_VkRenderingInfo_pColorAttachments[i][j].imageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+ internal_VkRenderingInfo_pColorAttachments[i][j].imageView);
+ internal_VkRenderingInfo_pColorAttachments[i][j].imageView =
+ gfxstream_imageView->internal_object;
+ }
+ /* VkRenderingAttachmentInfo::resolveImageView */
+ if (internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView) {
+ VK_FROM_HANDLE(
+ gfxstream_vk_image_view, gfxstream_resolveImageView,
+ internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView);
+ internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView =
+ gfxstream_resolveImageView->internal_object;
+ }
+ }
+ internal_pRenderingInfo[i].pColorAttachments =
+ internal_VkRenderingInfo_pColorAttachments[i].data();
+ /* VkRenderingInfo::pDepthAttachment */
+ if (internal_pRenderingInfo[i].pDepthAttachment) {
+ internal_VkRenderingInfo_pDepthAttachment[i] =
+ internal_pRenderingInfo[i].pDepthAttachment[0];
+ /* VkRenderingAttachmentInfo::imageView */
+ if (internal_VkRenderingInfo_pDepthAttachment[i].imageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+ internal_VkRenderingInfo_pDepthAttachment[i].imageView);
+ internal_VkRenderingInfo_pDepthAttachment[i].imageView =
+ gfxstream_imageView->internal_object;
+ }
+ /* VkRenderingAttachmentInfo::resolveImageView */
+ if (internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_resolveImageView,
+ internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView);
+ internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView =
+ gfxstream_resolveImageView->internal_object;
+ }
+ internal_pRenderingInfo[i].pDepthAttachment =
+ &internal_VkRenderingInfo_pDepthAttachment[i];
+ }
+ /* VkRenderingInfo::pStencilAttachment */
+ if (internal_pRenderingInfo[i].pStencilAttachment) {
+ internal_VkRenderingInfo_pStencilAttachment[i] =
+ internal_pRenderingInfo[i].pStencilAttachment[0];
+ /* VkRenderingAttachmentInfo::imageView */
+ if (internal_VkRenderingInfo_pStencilAttachment[i].imageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+ internal_VkRenderingInfo_pStencilAttachment[i].imageView);
+ internal_VkRenderingInfo_pStencilAttachment[i].imageView =
+ gfxstream_imageView->internal_object;
+ }
+ /* VkRenderingAttachmentInfo::resolveImageView */
+ if (internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_resolveImageView,
+ internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView);
+ internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView =
+ gfxstream_resolveImageView->internal_object;
+ }
+ internal_pRenderingInfo[i].pStencilAttachment =
+ &internal_VkRenderingInfo_pStencilAttachment[i];
+ }
+ }
+ vkEnc->vkCmdBeginRenderingKHR(gfxstream_commandBuffer->internal_object,
+ internal_pRenderingInfo.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdBeginRenderingKHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginRenderingKHR(commandBuffer, pRenderingInfo, true /* do lock */);
}
-static void entry_vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) {
+void gfxstream_vk_CmdEndRenderingKHR(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkCmdEndRenderingKHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndRenderingKHR(commandBuffer, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdEndRenderingKHR", "VK_KHR_dynamic_rendering");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdEndRenderingKHR(gfxstream_commandBuffer->internal_object, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdEndRenderingKHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndRenderingKHR(commandBuffer, true /* do lock */);
}
#endif
#ifdef VK_KHR_get_physical_device_properties2
-static void entry_vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures2* pFeatures) {
+void gfxstream_vk_GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceFeatures2KHR(gfxstream_physicalDevice->internal_object, pFeatures,
+ true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties2* pProperties) {
+void gfxstream_vk_GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceProperties2KHR(gfxstream_physicalDevice->internal_object,
+ pProperties, true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties2* pFormatProperties) {
+void gfxstream_vk_GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceFormatProperties2KHR(gfxstream_physicalDevice->internal_object,
+ format, pFormatProperties,
+ true /* do lock */);
+ }
}
-static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2KHR(
+VkResult gfxstream_vk_GetPhysicalDeviceImageFormatProperties2KHR(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
VkImageFormatProperties2* pImageFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return =
- resources->on_vkGetPhysicalDeviceImageFormatProperties2KHR(
- vkEnc, VK_SUCCESS, physicalDevice, pImageFormatInfo, pImageFormatProperties);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return =
+ resources->on_vkGetPhysicalDeviceImageFormatProperties2KHR(
+ vkEnc, VK_SUCCESS, gfxstream_physicalDevice->internal_object, pImageFormatInfo,
+ pImageFormatProperties);
+ }
return vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return;
}
-static void entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+void gfxstream_vk_GetPhysicalDeviceQueueFamilyProperties2KHR(
VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties2* pQueueFamilyProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount,
- pQueueFamilyProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+ gfxstream_physicalDevice->internal_object, pQueueFamilyPropertyCount,
+ pQueueFamilyProperties, true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceMemoryProperties2KHR(
+void gfxstream_vk_GetPhysicalDeviceMemoryProperties2KHR(
VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceMemoryProperties2KHR(gfxstream_physicalDevice->internal_object,
+ pMemoryProperties, true /* do lock */);
+ }
}
-static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+void gfxstream_vk_GetPhysicalDeviceSparseImageFormatProperties2KHR(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
- physicalDevice, pFormatInfo, pPropertyCount, pProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+ gfxstream_physicalDevice->internal_object, pFormatInfo, pPropertyCount, pProperties,
+ true /* do lock */);
+ }
}
#endif
#ifdef VK_KHR_maintenance1
-static void entry_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
- VkCommandPoolTrimFlags flags) {
+void gfxstream_vk_TrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags) {
AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkTrimCommandPoolKHR(device, commandPool, flags, true /* do lock */);
-}
-static void dynCheck_entry_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
- VkCommandPoolTrimFlags flags) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance1")) {
- sOnInvalidDynamicallyCheckedCall("vkTrimCommandPoolKHR", "VK_KHR_maintenance1");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_command_pool, gfxstream_commandPool, commandPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkTrimCommandPoolKHR(gfxstream_device->internal_object,
+ gfxstream_commandPool->internal_object, flags,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkTrimCommandPoolKHR(device, commandPool, flags, true /* do lock */);
}
#endif
#ifdef VK_KHR_external_memory_capabilities
-static void entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+void gfxstream_vk_GetPhysicalDeviceExternalBufferPropertiesKHR(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
VkExternalBufferProperties* pExternalBufferProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferPropertiesKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
- vkEnc, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+ vkEnc, gfxstream_physicalDevice->internal_object, pExternalBufferInfo,
+ pExternalBufferProperties);
+ }
}
#endif
#ifdef VK_KHR_external_memory
@@ -2314,14 +3878,18 @@
#ifdef VK_KHR_external_memory_fd
#endif
#ifdef VK_KHR_external_semaphore_capabilities
-static void entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+void gfxstream_vk_GetPhysicalDeviceExternalSemaphorePropertiesKHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
- physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+ gfxstream_physicalDevice->internal_object, pExternalSemaphoreInfo,
+ pExternalSemaphoreProperties, true /* do lock */);
+ }
}
#endif
#ifdef VK_KHR_external_semaphore
@@ -2329,51 +3897,47 @@
#ifdef VK_KHR_external_semaphore_win32
#endif
#ifdef VK_KHR_external_semaphore_fd
-static VkResult entry_vkImportSemaphoreFdKHR(
+VkResult gfxstream_vk_ImportSemaphoreFdKHR(
VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkImportSemaphoreFdKHR_VkResult_return =
- resources->on_vkImportSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pImportSemaphoreFdInfo);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkImportSemaphoreFdInfoKHR> internal_pImportSemaphoreFdInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pImportSemaphoreFdInfo[i] = pImportSemaphoreFdInfo[i];
+ /* VkImportSemaphoreFdInfoKHR::semaphore */
+ VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore,
+ internal_pImportSemaphoreFdInfo[i].semaphore);
+ internal_pImportSemaphoreFdInfo[i].semaphore = gfxstream_semaphore->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkImportSemaphoreFdKHR_VkResult_return = resources->on_vkImportSemaphoreFdKHR(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ internal_pImportSemaphoreFdInfo.data());
+ }
return vkImportSemaphoreFdKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkImportSemaphoreFdKHR(
- VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd")) {
- sOnInvalidDynamicallyCheckedCall("vkImportSemaphoreFdKHR", "VK_KHR_external_semaphore_fd");
- }
- AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
- vkImportSemaphoreFdKHR_VkResult_return =
- resources->on_vkImportSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pImportSemaphoreFdInfo);
- return vkImportSemaphoreFdKHR_VkResult_return;
-}
-static VkResult entry_vkGetSemaphoreFdKHR(VkDevice device,
- const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) {
+VkResult gfxstream_vk_GetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+ int* pFd) {
AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkGetSemaphoreFdKHR_VkResult_return =
- resources->on_vkGetSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
- return vkGetSemaphoreFdKHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetSemaphoreFdKHR(VkDevice device,
- const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
- int* pFd) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd")) {
- sOnInvalidDynamicallyCheckedCall("vkGetSemaphoreFdKHR", "VK_KHR_external_semaphore_fd");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkSemaphoreGetFdInfoKHR> internal_pGetFdInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pGetFdInfo[i] = pGetFdInfo[i];
+ /* VkSemaphoreGetFdInfoKHR::semaphore */
+ VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore,
+ internal_pGetFdInfo[i].semaphore);
+ internal_pGetFdInfo[i].semaphore = gfxstream_semaphore->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkGetSemaphoreFdKHR_VkResult_return = resources->on_vkGetSemaphoreFdKHR(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, internal_pGetFdInfo.data(), pFd);
}
- AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
- vkGetSemaphoreFdKHR_VkResult_return =
- resources->on_vkGetSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
return vkGetSemaphoreFdKHR_VkResult_return;
}
#endif
@@ -2382,228 +3946,190 @@
#ifdef VK_KHR_incremental_present
#endif
#ifdef VK_KHR_descriptor_update_template
-static VkResult entry_vkCreateDescriptorUpdateTemplateKHR(
+VkResult gfxstream_vk_CreateDescriptorUpdateTemplateKHR(
VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_descriptor_update_template* gfxstream_pDescriptorUpdateTemplate =
+ (gfxstream_vk_descriptor_update_template*)vk_object_zalloc(
+ &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_descriptor_update_template),
+ VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE);
vkCreateDescriptorUpdateTemplateKHR_VkResult_return =
- vkEnc->vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator,
- pDescriptorUpdateTemplate, true /* do lock */);
- return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkCreateDescriptorUpdateTemplateKHR(
- VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template")) {
- sOnInvalidDynamicallyCheckedCall("vkCreateDescriptorUpdateTemplateKHR",
- "VK_KHR_descriptor_update_template");
+ gfxstream_pDescriptorUpdateTemplate ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateDescriptorUpdateTemplateKHR_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkDescriptorUpdateTemplateCreateInfo> internal_pCreateInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCreateInfo[i] = pCreateInfo[i];
+ /* VkDescriptorUpdateTemplateCreateInfo::descriptorSetLayout */
+ if (internal_pCreateInfo[i].descriptorSetLayout) {
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_descriptorSetLayout,
+ internal_pCreateInfo[i].descriptorSetLayout);
+ internal_pCreateInfo[i].descriptorSetLayout =
+ gfxstream_descriptorSetLayout->internal_object;
+ }
+ /* VkDescriptorUpdateTemplateCreateInfo::pipelineLayout */
+ if (internal_pCreateInfo[i].pipelineLayout) {
+ VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_pipelineLayout,
+ internal_pCreateInfo[i].pipelineLayout);
+ internal_pCreateInfo[i].pipelineLayout = gfxstream_pipelineLayout->internal_object;
+ }
+ }
+ vkCreateDescriptorUpdateTemplateKHR_VkResult_return =
+ vkEnc->vkCreateDescriptorUpdateTemplateKHR(
+ gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
+ &gfxstream_pDescriptorUpdateTemplate->internal_object, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
- vkCreateDescriptorUpdateTemplateKHR_VkResult_return =
- vkEnc->vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator,
- pDescriptorUpdateTemplate, true /* do lock */);
+ *pDescriptorUpdateTemplate =
+ gfxstream_vk_descriptor_update_template_to_handle(gfxstream_pDescriptorUpdateTemplate);
return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
}
-static void entry_vkDestroyDescriptorUpdateTemplateKHR(
+void gfxstream_vk_DestroyDescriptorUpdateTemplateKHR(
VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator,
- true /* do lock */);
-}
-static void dynCheck_entry_vkDestroyDescriptorUpdateTemplateKHR(
- VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const VkAllocationCallbacks* pAllocator) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template")) {
- sOnInvalidDynamicallyCheckedCall("vkDestroyDescriptorUpdateTemplateKHR",
- "VK_KHR_descriptor_update_template");
+ if (VK_NULL_HANDLE == descriptorUpdateTemplate) {
+ return;
}
- AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
+ descriptorUpdateTemplate);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyDescriptorUpdateTemplateKHR(
+ gfxstream_device->internal_object,
+ gfxstream_descriptorUpdateTemplate ? gfxstream_descriptorUpdateTemplate->internal_object
+ : VK_NULL_HANDLE,
+ pAllocator, true /* do lock */);
+ }
+ vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_descriptorUpdateTemplate);
}
-static void entry_vkUpdateDescriptorSetWithTemplateKHR(
+void gfxstream_vk_UpdateDescriptorSetWithTemplateKHR(
VkDevice device, VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate,
- pData, true /* do lock */);
-}
-static void dynCheck_entry_vkUpdateDescriptorSetWithTemplateKHR(
- VkDevice device, VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template")) {
- sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplateKHR",
- "VK_KHR_descriptor_update_template");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
+ descriptorUpdateTemplate);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkUpdateDescriptorSetWithTemplateKHR(
+ vkEnc, gfxstream_device->internal_object, descriptorSet,
+ gfxstream_descriptorUpdateTemplate->internal_object, pData);
}
- AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate,
- pData, true /* do lock */);
}
#endif
#ifdef VK_KHR_imageless_framebuffer
#endif
#ifdef VK_KHR_create_renderpass2
-static VkResult entry_vkCreateRenderPass2KHR(VkDevice device,
- const VkRenderPassCreateInfo2* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass) {
+VkResult gfxstream_vk_CreateRenderPass2KHR(VkDevice device,
+ const VkRenderPassCreateInfo2* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass) {
AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
- vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(
- device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_render_pass* gfxstream_pRenderPass =
+ (gfxstream_vk_render_pass*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+ sizeof(gfxstream_vk_render_pass),
+ VK_OBJECT_TYPE_RENDER_PASS);
+ vkCreateRenderPass2KHR_VkResult_return =
+ gfxstream_pRenderPass ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateRenderPass2KHR_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(
+ gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pRenderPass->internal_object, true /* do lock */);
+ }
+ *pRenderPass = gfxstream_vk_render_pass_to_handle(gfxstream_pRenderPass);
return vkCreateRenderPass2KHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkCreateRenderPass2KHR(VkDevice device,
- const VkRenderPassCreateInfo2* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
- sOnInvalidDynamicallyCheckedCall("vkCreateRenderPass2KHR", "VK_KHR_create_renderpass2");
+void gfxstream_vk_CmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfo* pSubpassBeginInfo,
+ const VkSubpassEndInfo* pSubpassEndInfo) {
+ AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdNextSubpass2KHR(gfxstream_commandBuffer->internal_object, pSubpassBeginInfo,
+ pSubpassEndInfo, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
- vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(
- device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
- return vkCreateRenderPass2KHR_VkResult_return;
}
-static void entry_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- const VkSubpassBeginInfo* pSubpassBeginInfo) {
- AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- const VkSubpassBeginInfo* pSubpassBeginInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdBeginRenderPass2KHR", "VK_KHR_create_renderpass2");
- }
- AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo,
- true /* do lock */);
-}
-static void entry_vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
+void gfxstream_vk_CmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
const VkSubpassEndInfo* pSubpassEndInfo) {
- AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
- const VkSubpassEndInfo* pSubpassEndInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdNextSubpass2KHR", "VK_KHR_create_renderpass2");
- }
- AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo,
- true /* do lock */);
-}
-static void entry_vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
- const VkSubpassEndInfo* pSubpassEndInfo) {
AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
- const VkSubpassEndInfo* pSubpassEndInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdEndRenderPass2KHR", "VK_KHR_create_renderpass2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdEndRenderPass2KHR(gfxstream_commandBuffer->internal_object, pSubpassEndInfo,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo, true /* do lock */);
}
#endif
#ifdef VK_KHR_external_fence_capabilities
-static void entry_vkGetPhysicalDeviceExternalFencePropertiesKHR(
+void gfxstream_vk_GetPhysicalDeviceExternalFencePropertiesKHR(
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
VkExternalFenceProperties* pExternalFenceProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFencePropertiesKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetPhysicalDeviceExternalFencePropertiesKHR(
- vkEnc, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetPhysicalDeviceExternalFencePropertiesKHR(
+ vkEnc, gfxstream_physicalDevice->internal_object, pExternalFenceInfo,
+ pExternalFenceProperties);
+ }
}
#endif
#ifdef VK_KHR_external_fence
#endif
#ifdef VK_KHR_external_fence_fd
-static VkResult entry_vkImportFenceFdKHR(VkDevice device,
- const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
+VkResult gfxstream_vk_ImportFenceFdKHR(VkDevice device,
+ const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
AEMU_SCOPED_TRACE("vkImportFenceFdKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkImportFenceFdKHR_VkResult_return =
- resources->on_vkImportFenceFdKHR(vkEnc, VK_SUCCESS, device, pImportFenceFdInfo);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkImportFenceFdInfoKHR> internal_pImportFenceFdInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pImportFenceFdInfo[i] = pImportFenceFdInfo[i];
+ /* VkImportFenceFdInfoKHR::fence */
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence,
+ internal_pImportFenceFdInfo[i].fence);
+ internal_pImportFenceFdInfo[i].fence = gfxstream_fence->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkImportFenceFdKHR_VkResult_return =
+ resources->on_vkImportFenceFdKHR(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+ internal_pImportFenceFdInfo.data());
+ }
return vkImportFenceFdKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkImportFenceFdKHR(
- VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd")) {
- sOnInvalidDynamicallyCheckedCall("vkImportFenceFdKHR", "VK_KHR_external_fence_fd");
- }
- AEMU_SCOPED_TRACE("vkImportFenceFdKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
- vkImportFenceFdKHR_VkResult_return =
- resources->on_vkImportFenceFdKHR(vkEnc, VK_SUCCESS, device, pImportFenceFdInfo);
- return vkImportFenceFdKHR_VkResult_return;
-}
-static VkResult entry_vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo,
- int* pFd) {
+VkResult gfxstream_vk_GetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo,
+ int* pFd) {
AEMU_SCOPED_TRACE("vkGetFenceFdKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkGetFenceFdKHR_VkResult_return =
- resources->on_vkGetFenceFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
- return vkGetFenceFdKHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetFenceFdKHR(VkDevice device,
- const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd")) {
- sOnInvalidDynamicallyCheckedCall("vkGetFenceFdKHR", "VK_KHR_external_fence_fd");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkFenceGetFdInfoKHR> internal_pGetFdInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pGetFdInfo[i] = pGetFdInfo[i];
+ /* VkFenceGetFdInfoKHR::fence */
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, internal_pGetFdInfo[i].fence);
+ internal_pGetFdInfo[i].fence = gfxstream_fence->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkGetFenceFdKHR_VkResult_return = resources->on_vkGetFenceFdKHR(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, internal_pGetFdInfo.data(), pFd);
}
- AEMU_SCOPED_TRACE("vkGetFenceFdKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
- vkGetFenceFdKHR_VkResult_return =
- resources->on_vkGetFenceFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
return vkGetFenceFdKHR_VkResult_return;
}
#endif
@@ -2614,189 +4140,165 @@
#ifdef VK_KHR_storage_buffer_storage_class
#endif
#ifdef VK_KHR_get_memory_requirements2
-static void entry_vkGetImageMemoryRequirements2KHR(VkDevice device,
- const VkImageMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
+void gfxstream_vk_GetImageMemoryRequirements2KHR(VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetImageMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
-}
-static void dynCheck_entry_vkGetImageMemoryRequirements2KHR(
- VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2")) {
- sOnInvalidDynamicallyCheckedCall("vkGetImageMemoryRequirements2KHR",
- "VK_KHR_get_memory_requirements2");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkImageMemoryRequirementsInfo2> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkImageMemoryRequirementsInfo2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pInfo[i].image);
+ internal_pInfo[i].image = gfxstream_image->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetImageMemoryRequirements2KHR(vkEnc, gfxstream_device->internal_object,
+ internal_pInfo.data(), pMemoryRequirements);
}
- AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- resources->on_vkGetImageMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
}
-static void entry_vkGetBufferMemoryRequirements2KHR(VkDevice device,
- const VkBufferMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
+void gfxstream_vk_GetBufferMemoryRequirements2KHR(VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkGetBufferMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
-}
-static void dynCheck_entry_vkGetBufferMemoryRequirements2KHR(
- VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2")) {
- sOnInvalidDynamicallyCheckedCall("vkGetBufferMemoryRequirements2KHR",
- "VK_KHR_get_memory_requirements2");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBufferMemoryRequirementsInfo2> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkBufferMemoryRequirementsInfo2::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
+ internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkGetBufferMemoryRequirements2KHR(vkEnc, gfxstream_device->internal_object,
+ internal_pInfo.data(), pMemoryRequirements);
}
- AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- resources->on_vkGetBufferMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
}
-static void entry_vkGetImageSparseMemoryRequirements2KHR(
+void gfxstream_vk_GetImageSparseMemoryRequirements2KHR(
VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements, true /* do lock */);
-}
-static void dynCheck_entry_vkGetImageSparseMemoryRequirements2KHR(
- VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
- uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2")) {
- sOnInvalidDynamicallyCheckedCall("vkGetImageSparseMemoryRequirements2KHR",
- "VK_KHR_get_memory_requirements2");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkImageSparseMemoryRequirementsInfo2> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkImageSparseMemoryRequirementsInfo2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pInfo[i].image);
+ internal_pInfo[i].image = gfxstream_image->internal_object;
+ }
+ vkEnc->vkGetImageSparseMemoryRequirements2KHR(
+ gfxstream_device->internal_object, internal_pInfo.data(), pSparseMemoryRequirementCount,
+ pSparseMemoryRequirements, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements, true /* do lock */);
}
#endif
#ifdef VK_KHR_image_format_list
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
-static VkResult entry_vkCreateSamplerYcbcrConversionKHR(
+VkResult gfxstream_vk_CreateSamplerYcbcrConversionKHR(
VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkCreateSamplerYcbcrConversionKHR_VkResult_return =
- resources->on_vkCreateSamplerYcbcrConversionKHR(vkEnc, VK_SUCCESS, device, pCreateInfo,
- pAllocator, pYcbcrConversion);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkCreateSamplerYcbcrConversionKHR_VkResult_return =
+ resources->on_vkCreateSamplerYcbcrConversionKHR(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ pYcbcrConversion);
+ }
return vkCreateSamplerYcbcrConversionKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkCreateSamplerYcbcrConversionKHR(
- VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion")) {
- sOnInvalidDynamicallyCheckedCall("vkCreateSamplerYcbcrConversionKHR",
- "VK_KHR_sampler_ycbcr_conversion");
- }
- AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
- vkCreateSamplerYcbcrConversionKHR_VkResult_return =
- resources->on_vkCreateSamplerYcbcrConversionKHR(vkEnc, VK_SUCCESS, device, pCreateInfo,
- pAllocator, pYcbcrConversion);
- return vkCreateSamplerYcbcrConversionKHR_VkResult_return;
-}
-static void entry_vkDestroySamplerYcbcrConversionKHR(VkDevice device,
- VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroySamplerYcbcrConversionKHR(VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- auto resources = ResourceTracker::get();
- resources->on_vkDestroySamplerYcbcrConversionKHR(vkEnc, device, ycbcrConversion, pAllocator);
-}
-static void dynCheck_entry_vkDestroySamplerYcbcrConversionKHR(
- VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks* pAllocator) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion")) {
- sOnInvalidDynamicallyCheckedCall("vkDestroySamplerYcbcrConversionKHR",
- "VK_KHR_sampler_ycbcr_conversion");
+ if (VK_NULL_HANDLE == ycbcrConversion) {
+ return;
}
- AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- resources->on_vkDestroySamplerYcbcrConversionKHR(vkEnc, device, ycbcrConversion, pAllocator);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ resources->on_vkDestroySamplerYcbcrConversionKHR(vkEnc, gfxstream_device->internal_object,
+ ycbcrConversion, pAllocator);
+ }
}
#endif
#ifdef VK_KHR_bind_memory2
-static VkResult entry_vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
- const VkBindBufferMemoryInfo* pBindInfos) {
+VkResult gfxstream_vk_BindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos) {
AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkBindBufferMemory2KHR_VkResult_return =
- resources->on_vkBindBufferMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBindBufferMemoryInfo> internal_pBindInfos(bindInfoCount);
+ for (uint32_t i = 0; i < bindInfoCount; ++i) {
+ internal_pBindInfos[i] = pBindInfos[i];
+ /* VkBindBufferMemoryInfo::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pBindInfos[i].buffer);
+ internal_pBindInfos[i].buffer = gfxstream_buffer->internal_object;
+ /* VkBindBufferMemoryInfo::memory */
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_pBindInfos[i].memory);
+ internal_pBindInfos[i].memory = gfxstream_memory->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkBindBufferMemory2KHR_VkResult_return = resources->on_vkBindBufferMemory2KHR(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, bindInfoCount,
+ internal_pBindInfos.data());
+ }
return vkBindBufferMemory2KHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
- const VkBindBufferMemoryInfo* pBindInfos) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_bind_memory2")) {
- sOnInvalidDynamicallyCheckedCall("vkBindBufferMemory2KHR", "VK_KHR_bind_memory2");
- }
- AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
- vkBindBufferMemory2KHR_VkResult_return =
- resources->on_vkBindBufferMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
- return vkBindBufferMemory2KHR_VkResult_return;
-}
-static VkResult entry_vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
- const VkBindImageMemoryInfo* pBindInfos) {
+VkResult gfxstream_vk_BindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos) {
AEMU_SCOPED_TRACE("vkBindImageMemory2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkBindImageMemory2KHR_VkResult_return =
- resources->on_vkBindImageMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
- return vkBindImageMemory2KHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
- const VkBindImageMemoryInfo* pBindInfos) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_bind_memory2")) {
- sOnInvalidDynamicallyCheckedCall("vkBindImageMemory2KHR", "VK_KHR_bind_memory2");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBindImageMemoryInfo> internal_pBindInfos(bindInfoCount);
+ for (uint32_t i = 0; i < bindInfoCount; ++i) {
+ internal_pBindInfos[i] = pBindInfos[i];
+ /* VkBindImageMemoryInfo::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pBindInfos[i].image);
+ internal_pBindInfos[i].image = gfxstream_image->internal_object;
+ /* VkBindImageMemoryInfo::memory */
+ if (internal_pBindInfos[i].memory) {
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_pBindInfos[i].memory);
+ internal_pBindInfos[i].memory = gfxstream_memory->internal_object;
+ }
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkBindImageMemory2KHR_VkResult_return = resources->on_vkBindImageMemory2KHR(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, bindInfoCount,
+ internal_pBindInfos.data());
}
- AEMU_SCOPED_TRACE("vkBindImageMemory2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
- vkBindImageMemory2KHR_VkResult_return =
- resources->on_vkBindImageMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
return vkBindImageMemory2KHR_VkResult_return;
}
#endif
#ifdef VK_KHR_maintenance3
-static void entry_vkGetDescriptorSetLayoutSupportKHR(
+void gfxstream_vk_GetDescriptorSetLayoutSupportKHR(
VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayoutSupport* pSupport) {
AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport, true /* do lock */);
-}
-static void dynCheck_entry_vkGetDescriptorSetLayoutSupportKHR(
- VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- VkDescriptorSetLayoutSupport* pSupport) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance3")) {
- sOnInvalidDynamicallyCheckedCall("vkGetDescriptorSetLayoutSupportKHR",
- "VK_KHR_maintenance3");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDescriptorSetLayoutSupportKHR(gfxstream_device->internal_object, pCreateInfo,
+ pSupport, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport, true /* do lock */);
}
#endif
#ifdef VK_KHR_shader_subgroup_extended_types
@@ -2806,160 +4308,135 @@
#ifdef VK_KHR_shader_terminate_invocation
#endif
#ifdef VK_KHR_buffer_device_address
-static VkDeviceAddress entry_vkGetBufferDeviceAddressKHR(VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo) {
+VkDeviceAddress gfxstream_vk_GetBufferDeviceAddressKHR(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetBufferDeviceAddressKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkDeviceAddress vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = (VkDeviceAddress)0;
- vkGetBufferDeviceAddressKHR_VkDeviceAddress_return =
- vkEnc->vkGetBufferDeviceAddressKHR(device, pInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBufferDeviceAddressInfo> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkBufferDeviceAddressInfo::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
+ internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
+ }
+ vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = vkEnc->vkGetBufferDeviceAddressKHR(
+ gfxstream_device->internal_object, internal_pInfo.data(), true /* do lock */);
+ }
return vkGetBufferDeviceAddressKHR_VkDeviceAddress_return;
}
-static VkDeviceAddress dynCheck_entry_vkGetBufferDeviceAddressKHR(
- VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address")) {
- sOnInvalidDynamicallyCheckedCall("vkGetBufferDeviceAddressKHR",
- "VK_KHR_buffer_device_address");
- }
- AEMU_SCOPED_TRACE("vkGetBufferDeviceAddressKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkDeviceAddress vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = (VkDeviceAddress)0;
- vkGetBufferDeviceAddressKHR_VkDeviceAddress_return =
- vkEnc->vkGetBufferDeviceAddressKHR(device, pInfo, true /* do lock */);
- return vkGetBufferDeviceAddressKHR_VkDeviceAddress_return;
-}
-static uint64_t entry_vkGetBufferOpaqueCaptureAddressKHR(VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo) {
+uint64_t gfxstream_vk_GetBufferOpaqueCaptureAddressKHR(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddressKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
- vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return =
- vkEnc->vkGetBufferOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkBufferDeviceAddressInfo> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkBufferDeviceAddressInfo::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
+ internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
+ }
+ vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return =
+ vkEnc->vkGetBufferOpaqueCaptureAddressKHR(gfxstream_device->internal_object,
+ internal_pInfo.data(), true /* do lock */);
+ }
return vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return;
}
-static uint64_t dynCheck_entry_vkGetBufferOpaqueCaptureAddressKHR(
- VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address")) {
- sOnInvalidDynamicallyCheckedCall("vkGetBufferOpaqueCaptureAddressKHR",
- "VK_KHR_buffer_device_address");
- }
- AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddressKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- uint64_t vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
- vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return =
- vkEnc->vkGetBufferOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
- return vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return;
-}
-static uint64_t entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR(
+uint64_t gfxstream_vk_GetDeviceMemoryOpaqueCaptureAddressKHR(
VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddressKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
- vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return =
- vkEnc->vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
- return vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return;
-}
-static uint64_t dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR(
- VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address")) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceMemoryOpaqueCaptureAddressKHR",
- "VK_KHR_buffer_device_address");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkDeviceMemoryOpaqueCaptureAddressInfo> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkDeviceMemoryOpaqueCaptureAddressInfo::memory */
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, internal_pInfo[i].memory);
+ internal_pInfo[i].memory = gfxstream_memory->internal_object;
+ }
+ vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return =
+ vkEnc->vkGetDeviceMemoryOpaqueCaptureAddressKHR(
+ gfxstream_device->internal_object, internal_pInfo.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddressKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
- vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return =
- vkEnc->vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
return vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
-static VkResult entry_vkGetPipelineExecutablePropertiesKHR(
+VkResult gfxstream_vk_GetPipelineExecutablePropertiesKHR(
VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount,
VkPipelineExecutablePropertiesKHR* pProperties) {
AEMU_SCOPED_TRACE("vkGetPipelineExecutablePropertiesKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPipelineExecutablePropertiesKHR_VkResult_return = (VkResult)0;
- vkGetPipelineExecutablePropertiesKHR_VkResult_return =
- vkEnc->vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount,
- pProperties, true /* do lock */);
- return vkGetPipelineExecutablePropertiesKHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetPipelineExecutablePropertiesKHR(
- VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount,
- VkPipelineExecutablePropertiesKHR* pProperties) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties")) {
- sOnInvalidDynamicallyCheckedCall("vkGetPipelineExecutablePropertiesKHR",
- "VK_KHR_pipeline_executable_properties");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkPipelineInfoKHR> internal_pPipelineInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pPipelineInfo[i] = pPipelineInfo[i];
+ /* VkPipelineInfoKHR::pipeline */
+ VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline,
+ internal_pPipelineInfo[i].pipeline);
+ internal_pPipelineInfo[i].pipeline = gfxstream_pipeline->internal_object;
+ }
+ vkGetPipelineExecutablePropertiesKHR_VkResult_return =
+ vkEnc->vkGetPipelineExecutablePropertiesKHR(
+ gfxstream_device->internal_object, internal_pPipelineInfo.data(), pExecutableCount,
+ pProperties, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetPipelineExecutablePropertiesKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetPipelineExecutablePropertiesKHR_VkResult_return = (VkResult)0;
- vkGetPipelineExecutablePropertiesKHR_VkResult_return =
- vkEnc->vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount,
- pProperties, true /* do lock */);
return vkGetPipelineExecutablePropertiesKHR_VkResult_return;
}
-static VkResult entry_vkGetPipelineExecutableStatisticsKHR(
+VkResult gfxstream_vk_GetPipelineExecutableStatisticsKHR(
VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount,
VkPipelineExecutableStatisticKHR* pStatistics) {
AEMU_SCOPED_TRACE("vkGetPipelineExecutableStatisticsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPipelineExecutableStatisticsKHR_VkResult_return = (VkResult)0;
- vkGetPipelineExecutableStatisticsKHR_VkResult_return =
- vkEnc->vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount,
- pStatistics, true /* do lock */);
- return vkGetPipelineExecutableStatisticsKHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetPipelineExecutableStatisticsKHR(
- VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount,
- VkPipelineExecutableStatisticKHR* pStatistics) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties")) {
- sOnInvalidDynamicallyCheckedCall("vkGetPipelineExecutableStatisticsKHR",
- "VK_KHR_pipeline_executable_properties");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkPipelineExecutableInfoKHR> internal_pExecutableInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pExecutableInfo[i] = pExecutableInfo[i];
+ /* VkPipelineExecutableInfoKHR::pipeline */
+ VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline,
+ internal_pExecutableInfo[i].pipeline);
+ internal_pExecutableInfo[i].pipeline = gfxstream_pipeline->internal_object;
+ }
+ vkGetPipelineExecutableStatisticsKHR_VkResult_return =
+ vkEnc->vkGetPipelineExecutableStatisticsKHR(
+ gfxstream_device->internal_object, internal_pExecutableInfo.data(), pStatisticCount,
+ pStatistics, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetPipelineExecutableStatisticsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetPipelineExecutableStatisticsKHR_VkResult_return = (VkResult)0;
- vkGetPipelineExecutableStatisticsKHR_VkResult_return =
- vkEnc->vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount,
- pStatistics, true /* do lock */);
return vkGetPipelineExecutableStatisticsKHR_VkResult_return;
}
-static VkResult entry_vkGetPipelineExecutableInternalRepresentationsKHR(
+VkResult gfxstream_vk_GetPipelineExecutableInternalRepresentationsKHR(
VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo,
uint32_t* pInternalRepresentationCount,
VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
AEMU_SCOPED_TRACE("vkGetPipelineExecutableInternalRepresentationsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return = (VkResult)0;
- vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return =
- vkEnc->vkGetPipelineExecutableInternalRepresentationsKHR(
- device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations,
- true /* do lock */);
- return vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetPipelineExecutableInternalRepresentationsKHR(
- VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo,
- uint32_t* pInternalRepresentationCount,
- VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties")) {
- sOnInvalidDynamicallyCheckedCall("vkGetPipelineExecutableInternalRepresentationsKHR",
- "VK_KHR_pipeline_executable_properties");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkPipelineExecutableInfoKHR> internal_pExecutableInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pExecutableInfo[i] = pExecutableInfo[i];
+ /* VkPipelineExecutableInfoKHR::pipeline */
+ VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline,
+ internal_pExecutableInfo[i].pipeline);
+ internal_pExecutableInfo[i].pipeline = gfxstream_pipeline->internal_object;
+ }
+ vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return =
+ vkEnc->vkGetPipelineExecutableInternalRepresentationsKHR(
+ gfxstream_device->internal_object, internal_pExecutableInfo.data(),
+ pInternalRepresentationCount, pInternalRepresentations, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetPipelineExecutableInternalRepresentationsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return = (VkResult)0;
- vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return =
- vkEnc->vkGetPipelineExecutableInternalRepresentationsKHR(
- device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations,
- true /* do lock */);
return vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return;
}
#endif
@@ -2968,646 +4445,718 @@
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_synchronization2
-static void entry_vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
- const VkDependencyInfo* pDependencyInfo) {
+void gfxstream_vk_CmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
+ const VkDependencyInfo* pDependencyInfo) {
AEMU_SCOPED_TRACE("vkCmdSetEvent2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
- const VkDependencyInfo* pDependencyInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetEvent2KHR", "VK_KHR_synchronization2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkDependencyInfo> internal_pDependencyInfo(1);
+ std::vector<std::vector<VkBufferMemoryBarrier2>>
+ internal_VkDependencyInfo_pBufferMemoryBarriers;
+ std::vector<std::vector<VkImageMemoryBarrier2>>
+ internal_VkDependencyInfo_pImageMemoryBarriers;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pDependencyInfo[i] = pDependencyInfo[i];
+ /* VkDependencyInfo::pBufferMemoryBarriers */
+ internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
+ std::vector<VkBufferMemoryBarrier2>());
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
+ internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
+ sizeof(VkBufferMemoryBarrier2) *
+ internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfo[i].bufferMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
+ internal_pDependencyInfo[i].pBufferMemoryBarriers[j];
+ /* VkBufferMemoryBarrier2::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ }
+ internal_pDependencyInfo[i].pBufferMemoryBarriers =
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
+ /* VkDependencyInfo::pImageMemoryBarriers */
+ internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
+ std::vector<VkImageMemoryBarrier2>());
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
+ internal_pDependencyInfo[i].imageMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
+ sizeof(VkImageMemoryBarrier2) *
+ internal_pDependencyInfo[i].imageMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfo[i].imageMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
+ internal_pDependencyInfo[i].pImageMemoryBarriers[j];
+ /* VkImageMemoryBarrier2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
+ gfxstream_image->internal_object;
+ }
+ internal_pDependencyInfo[i].pImageMemoryBarriers =
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
+ }
+ vkEnc->vkCmdSetEvent2KHR(gfxstream_commandBuffer->internal_object,
+ gfxstream_event->internal_object, internal_pDependencyInfo.data(),
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetEvent2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo, true /* do lock */);
}
-static void entry_vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
- VkPipelineStageFlags2 stageMask) {
+void gfxstream_vk_CmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
+ VkPipelineStageFlags2 stageMask) {
AEMU_SCOPED_TRACE("vkCmdResetEvent2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResetEvent2KHR(commandBuffer, event, stageMask, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
- VkPipelineStageFlags2 stageMask) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdResetEvent2KHR", "VK_KHR_synchronization2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdResetEvent2KHR(gfxstream_commandBuffer->internal_object,
+ gfxstream_event->internal_object, stageMask, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdResetEvent2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResetEvent2KHR(commandBuffer, event, stageMask, true /* do lock */);
}
-static void entry_vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
- const VkEvent* pEvents,
- const VkDependencyInfo* pDependencyInfos) {
+void gfxstream_vk_CmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
+ const VkEvent* pEvents,
+ const VkDependencyInfo* pDependencyInfos) {
AEMU_SCOPED_TRACE("vkCmdWaitEvents2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
- const VkEvent* pEvents,
- const VkDependencyInfo* pDependencyInfos) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdWaitEvents2KHR", "VK_KHR_synchronization2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkEvent> internal_pEvents(eventCount);
+ for (uint32_t i = 0; i < eventCount; ++i) {
+ VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_pEvents, pEvents[i]);
+ internal_pEvents[i] = gfxstream_pEvents->internal_object;
+ }
+ std::vector<VkDependencyInfo> internal_pDependencyInfos(eventCount);
+ std::vector<std::vector<VkBufferMemoryBarrier2>>
+ internal_VkDependencyInfo_pBufferMemoryBarriers;
+ std::vector<std::vector<VkImageMemoryBarrier2>>
+ internal_VkDependencyInfo_pImageMemoryBarriers;
+ for (uint32_t i = 0; i < eventCount; ++i) {
+ internal_pDependencyInfos[i] = pDependencyInfos[i];
+ /* VkDependencyInfo::pBufferMemoryBarriers */
+ internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
+ std::vector<VkBufferMemoryBarrier2>());
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
+ internal_pDependencyInfos[i].bufferMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
+ sizeof(VkBufferMemoryBarrier2) *
+ internal_pDependencyInfos[i].bufferMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfos[i].bufferMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
+ internal_pDependencyInfos[i].pBufferMemoryBarriers[j];
+ /* VkBufferMemoryBarrier2::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ }
+ internal_pDependencyInfos[i].pBufferMemoryBarriers =
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
+ /* VkDependencyInfo::pImageMemoryBarriers */
+ internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
+ std::vector<VkImageMemoryBarrier2>());
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
+ internal_pDependencyInfos[i].imageMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
+ sizeof(VkImageMemoryBarrier2) *
+ internal_pDependencyInfos[i].imageMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfos[i].imageMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
+ internal_pDependencyInfos[i].pImageMemoryBarriers[j];
+ /* VkImageMemoryBarrier2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
+ gfxstream_image->internal_object;
+ }
+ internal_pDependencyInfos[i].pImageMemoryBarriers =
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
+ }
+ vkEnc->vkCmdWaitEvents2KHR(gfxstream_commandBuffer->internal_object, eventCount,
+ internal_pEvents.data(), internal_pDependencyInfos.data(),
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdWaitEvents2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos,
- true /* do lock */);
}
-static void entry_vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
- const VkDependencyInfo* pDependencyInfo) {
+void gfxstream_vk_CmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
+ const VkDependencyInfo* pDependencyInfo) {
AEMU_SCOPED_TRACE("vkCmdPipelineBarrier2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
- const VkDependencyInfo* pDependencyInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdPipelineBarrier2KHR", "VK_KHR_synchronization2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkDependencyInfo> internal_pDependencyInfo(1);
+ std::vector<std::vector<VkBufferMemoryBarrier2>>
+ internal_VkDependencyInfo_pBufferMemoryBarriers;
+ std::vector<std::vector<VkImageMemoryBarrier2>>
+ internal_VkDependencyInfo_pImageMemoryBarriers;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pDependencyInfo[i] = pDependencyInfo[i];
+ /* VkDependencyInfo::pBufferMemoryBarriers */
+ internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
+ std::vector<VkBufferMemoryBarrier2>());
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
+ internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
+ sizeof(VkBufferMemoryBarrier2) *
+ internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfo[i].bufferMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
+ internal_pDependencyInfo[i].pBufferMemoryBarriers[j];
+ /* VkBufferMemoryBarrier2::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ }
+ internal_pDependencyInfo[i].pBufferMemoryBarriers =
+ internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
+ /* VkDependencyInfo::pImageMemoryBarriers */
+ internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
+ std::vector<VkImageMemoryBarrier2>());
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
+ internal_pDependencyInfo[i].imageMemoryBarrierCount);
+ memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
+ sizeof(VkImageMemoryBarrier2) *
+ internal_pDependencyInfo[i].imageMemoryBarrierCount);
+ for (uint32_t j = 0; j < internal_pDependencyInfo[i].imageMemoryBarrierCount; ++j) {
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
+ internal_pDependencyInfo[i].pImageMemoryBarriers[j];
+ /* VkImageMemoryBarrier2::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
+ internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
+ gfxstream_image->internal_object;
+ }
+ internal_pDependencyInfo[i].pImageMemoryBarriers =
+ internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
+ }
+ vkEnc->vkCmdPipelineBarrier2KHR(gfxstream_commandBuffer->internal_object,
+ internal_pDependencyInfo.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdPipelineBarrier2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo, true /* do lock */);
}
-static void entry_vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2 stage, VkQueryPool queryPool,
- uint32_t query) {
+void gfxstream_vk_CmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
+ VkQueryPool queryPool, uint32_t query) {
AEMU_SCOPED_TRACE("vkCmdWriteTimestamp2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2 stage,
- VkQueryPool queryPool, uint32_t query) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdWriteTimestamp2KHR", "VK_KHR_synchronization2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdWriteTimestamp2KHR(gfxstream_commandBuffer->internal_object, stage,
+ gfxstream_queryPool->internal_object, query,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdWriteTimestamp2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query, true /* do lock */);
}
-static VkResult entry_vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount,
- const VkSubmitInfo2* pSubmits, VkFence fence) {
+VkResult gfxstream_vk_QueueSubmit2KHR(VkQueue queue, uint32_t submitCount,
+ const VkSubmitInfo2* pSubmits, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueSubmit2KHR");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueSubmit2KHR_VkResult_return = (VkResult)0;
- vkQueueSubmit2KHR_VkResult_return =
- vkEnc->vkQueueSubmit2KHR(queue, submitCount, pSubmits, fence, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkSubmitInfo2> internal_pSubmits(submitCount);
+ std::vector<std::vector<VkSemaphoreSubmitInfo>> internal_VkSubmitInfo2_pWaitSemaphoreInfos;
+ std::vector<std::vector<VkCommandBufferSubmitInfo>>
+ internal_VkSubmitInfo2_pCommandBufferInfos;
+ std::vector<std::vector<VkSemaphoreSubmitInfo>>
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos;
+ for (uint32_t i = 0; i < submitCount; ++i) {
+ internal_pSubmits[i] = pSubmits[i];
+ /* VkSubmitInfo2::pWaitSemaphoreInfos */
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos.push_back(
+ std::vector<VkSemaphoreSubmitInfo>());
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos[i] =
+ transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pWaitSemaphoreInfos,
+ internal_pSubmits[i].waitSemaphoreInfoCount);
+ internal_pSubmits[i].pWaitSemaphoreInfos =
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].data();
+ internal_pSubmits[i].waitSemaphoreInfoCount =
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].size();
+ /* VkSubmitInfo2::pCommandBufferInfos */
+ internal_VkSubmitInfo2_pCommandBufferInfos.push_back(
+ std::vector<VkCommandBufferSubmitInfo>());
+ internal_VkSubmitInfo2_pCommandBufferInfos[i].reserve(
+ internal_pSubmits[i].commandBufferInfoCount);
+ memset(&internal_VkSubmitInfo2_pCommandBufferInfos[i][0], 0,
+ sizeof(VkCommandBufferSubmitInfo) * internal_pSubmits[i].commandBufferInfoCount);
+ for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferInfoCount; ++j) {
+ internal_VkSubmitInfo2_pCommandBufferInfos[i][j] =
+ internal_pSubmits[i].pCommandBufferInfos[j];
+ /* VkCommandBufferSubmitInfo::commandBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer,
+ internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer);
+ internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer =
+ gfxstream_commandBuffer->internal_object;
+ }
+ internal_pSubmits[i].pCommandBufferInfos =
+ internal_VkSubmitInfo2_pCommandBufferInfos[i].data();
+ /* VkSubmitInfo2::pSignalSemaphoreInfos */
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos.push_back(
+ std::vector<VkSemaphoreSubmitInfo>());
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos[i] =
+ transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pSignalSemaphoreInfos,
+ internal_pSubmits[i].signalSemaphoreInfoCount);
+ internal_pSubmits[i].pSignalSemaphoreInfos =
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].data();
+ internal_pSubmits[i].signalSemaphoreInfoCount =
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].size();
+ }
+ vkQueueSubmit2KHR_VkResult_return = vkEnc->vkQueueSubmit2KHR(
+ gfxstream_queue->internal_object, submitCount, internal_pSubmits.data(),
+ gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+ true /* do lock */);
+ }
return vkQueueSubmit2KHR_VkResult_return;
}
-static void entry_vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2 stage, VkBuffer dstBuffer,
- VkDeviceSize dstOffset, uint32_t marker) {
+void gfxstream_vk_CmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags2 stage, VkBuffer dstBuffer,
+ VkDeviceSize dstOffset, uint32_t marker) {
AEMU_SCOPED_TRACE("vkCmdWriteBufferMarker2AMD");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2 stage,
- VkBuffer dstBuffer, VkDeviceSize dstOffset,
- uint32_t marker) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdWriteBufferMarker2AMD", "VK_KHR_synchronization2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdWriteBufferMarker2AMD(gfxstream_commandBuffer->internal_object, stage,
+ gfxstream_dstBuffer->internal_object, dstOffset, marker,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdWriteBufferMarker2AMD");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker,
- true /* do lock */);
}
-static void entry_vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount,
- VkCheckpointData2NV* pCheckpointData) {
+void gfxstream_vk_GetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount,
+ VkCheckpointData2NV* pCheckpointData) {
AEMU_SCOPED_TRACE("vkGetQueueCheckpointData2NV");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkGetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ vkEnc->vkGetQueueCheckpointData2NV(gfxstream_queue->internal_object, pCheckpointDataCount,
+ pCheckpointData, true /* do lock */);
+ }
}
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
#endif
#ifdef VK_KHR_copy_commands2
-static void entry_vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
- const VkCopyBufferInfo2* pCopyBufferInfo) {
+void gfxstream_vk_CmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
+ const VkCopyBufferInfo2* pCopyBufferInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyBuffer2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
- const VkCopyBufferInfo2* pCopyBufferInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdCopyBuffer2KHR", "VK_KHR_copy_commands2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCopyBufferInfo2> internal_pCopyBufferInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyBufferInfo[i] = pCopyBufferInfo[i];
+ /* VkCopyBufferInfo2::srcBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer,
+ internal_pCopyBufferInfo[i].srcBuffer);
+ internal_pCopyBufferInfo[i].srcBuffer = gfxstream_srcBuffer->internal_object;
+ /* VkCopyBufferInfo2::dstBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer,
+ internal_pCopyBufferInfo[i].dstBuffer);
+ internal_pCopyBufferInfo[i].dstBuffer = gfxstream_dstBuffer->internal_object;
+ }
+ vkEnc->vkCmdCopyBuffer2KHR(gfxstream_commandBuffer->internal_object,
+ internal_pCopyBufferInfo.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdCopyBuffer2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo, true /* do lock */);
}
-static void entry_vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer,
- const VkCopyImageInfo2* pCopyImageInfo) {
+void gfxstream_vk_CmdCopyImage2KHR(VkCommandBuffer commandBuffer,
+ const VkCopyImageInfo2* pCopyImageInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyImage2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer,
- const VkCopyImageInfo2* pCopyImageInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdCopyImage2KHR", "VK_KHR_copy_commands2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCopyImageInfo2> internal_pCopyImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyImageInfo[i] = pCopyImageInfo[i];
+ /* VkCopyImageInfo2::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pCopyImageInfo[i].srcImage);
+ internal_pCopyImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ /* VkCopyImageInfo2::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pCopyImageInfo[i].dstImage);
+ internal_pCopyImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkEnc->vkCmdCopyImage2KHR(gfxstream_commandBuffer->internal_object,
+ internal_pCopyImageInfo.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdCopyImage2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo, true /* do lock */);
}
-static void entry_vkCmdCopyBufferToImage2KHR(
- VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
+void gfxstream_vk_CmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,
+ const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdCopyBufferToImage2KHR(
- VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdCopyBufferToImage2KHR", "VK_KHR_copy_commands2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCopyBufferToImageInfo2> internal_pCopyBufferToImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyBufferToImageInfo[i] = pCopyBufferToImageInfo[i];
+ /* VkCopyBufferToImageInfo2::srcBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer,
+ internal_pCopyBufferToImageInfo[i].srcBuffer);
+ internal_pCopyBufferToImageInfo[i].srcBuffer = gfxstream_srcBuffer->internal_object;
+ /* VkCopyBufferToImageInfo2::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pCopyBufferToImageInfo[i].dstImage);
+ internal_pCopyBufferToImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkEnc->vkCmdCopyBufferToImage2KHR(gfxstream_commandBuffer->internal_object,
+ internal_pCopyBufferToImageInfo.data(),
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo, true /* do lock */);
}
-static void entry_vkCmdCopyImageToBuffer2KHR(
- VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
+void gfxstream_vk_CmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,
+ const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdCopyImageToBuffer2KHR(
- VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdCopyImageToBuffer2KHR", "VK_KHR_copy_commands2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCopyImageToBufferInfo2> internal_pCopyImageToBufferInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyImageToBufferInfo[i] = pCopyImageToBufferInfo[i];
+ /* VkCopyImageToBufferInfo2::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pCopyImageToBufferInfo[i].srcImage);
+ internal_pCopyImageToBufferInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ /* VkCopyImageToBufferInfo2::dstBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer,
+ internal_pCopyImageToBufferInfo[i].dstBuffer);
+ internal_pCopyImageToBufferInfo[i].dstBuffer = gfxstream_dstBuffer->internal_object;
+ }
+ vkEnc->vkCmdCopyImageToBuffer2KHR(gfxstream_commandBuffer->internal_object,
+ internal_pCopyImageToBufferInfo.data(),
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo, true /* do lock */);
}
-static void entry_vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer,
- const VkBlitImageInfo2* pBlitImageInfo) {
+void gfxstream_vk_CmdBlitImage2KHR(VkCommandBuffer commandBuffer,
+ const VkBlitImageInfo2* pBlitImageInfo) {
AEMU_SCOPED_TRACE("vkCmdBlitImage2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer,
- const VkBlitImageInfo2* pBlitImageInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdBlitImage2KHR", "VK_KHR_copy_commands2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkBlitImageInfo2> internal_pBlitImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pBlitImageInfo[i] = pBlitImageInfo[i];
+ /* VkBlitImageInfo2::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pBlitImageInfo[i].srcImage);
+ internal_pBlitImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ /* VkBlitImageInfo2::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pBlitImageInfo[i].dstImage);
+ internal_pBlitImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkEnc->vkCmdBlitImage2KHR(gfxstream_commandBuffer->internal_object,
+ internal_pBlitImageInfo.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdBlitImage2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo, true /* do lock */);
}
-static void entry_vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer,
- const VkResolveImageInfo2* pResolveImageInfo) {
+void gfxstream_vk_CmdResolveImage2KHR(VkCommandBuffer commandBuffer,
+ const VkResolveImageInfo2* pResolveImageInfo) {
AEMU_SCOPED_TRACE("vkCmdResolveImage2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer,
- const VkResolveImageInfo2* pResolveImageInfo) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdResolveImage2KHR", "VK_KHR_copy_commands2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkResolveImageInfo2> internal_pResolveImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pResolveImageInfo[i] = pResolveImageInfo[i];
+ /* VkResolveImageInfo2::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pResolveImageInfo[i].srcImage);
+ internal_pResolveImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ /* VkResolveImageInfo2::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pResolveImageInfo[i].dstImage);
+ internal_pResolveImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkEnc->vkCmdResolveImage2KHR(gfxstream_commandBuffer->internal_object,
+ internal_pResolveImageInfo.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdResolveImage2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo, true /* do lock */);
}
#endif
#ifdef VK_KHR_format_feature_flags2
#endif
#ifdef VK_KHR_maintenance4
-static void entry_vkGetDeviceBufferMemoryRequirementsKHR(
+void gfxstream_vk_GetDeviceBufferMemoryRequirementsKHR(
VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo,
VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirementsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceBufferMemoryRequirementsKHR(
- VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance4")) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceBufferMemoryRequirementsKHR",
- "VK_KHR_maintenance4");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceBufferMemoryRequirementsKHR(gfxstream_device->internal_object, pInfo,
+ pMemoryRequirements, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirementsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
- true /* do lock */);
}
-static void entry_vkGetDeviceImageMemoryRequirementsKHR(
- VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
+void gfxstream_vk_GetDeviceImageMemoryRequirementsKHR(VkDevice device,
+ const VkDeviceImageMemoryRequirements* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirementsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceImageMemoryRequirementsKHR(
- VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance4")) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageMemoryRequirementsKHR",
- "VK_KHR_maintenance4");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceImageMemoryRequirementsKHR(gfxstream_device->internal_object, pInfo,
+ pMemoryRequirements, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirementsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
- true /* do lock */);
}
-static void entry_vkGetDeviceImageSparseMemoryRequirementsKHR(
+void gfxstream_vk_GetDeviceImageSparseMemoryRequirementsKHR(
VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirementsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceImageSparseMemoryRequirementsKHR(
- VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
- uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance4")) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageSparseMemoryRequirementsKHR",
- "VK_KHR_maintenance4");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceImageSparseMemoryRequirementsKHR(
+ gfxstream_device->internal_object, pInfo, pSparseMemoryRequirementCount,
+ pSparseMemoryRequirements, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirementsKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements,
- true /* do lock */);
}
#endif
#ifdef VK_KHR_maintenance5
-static void entry_vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, VkDeviceSize size,
- VkIndexType indexType) {
+void gfxstream_vk_CmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkDeviceSize size,
+ VkIndexType indexType) {
AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, VkDeviceSize size,
- VkIndexType indexType) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance5")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdBindIndexBuffer2KHR", "VK_KHR_maintenance5");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdBindIndexBuffer2KHR(gfxstream_commandBuffer->internal_object,
+ gfxstream_buffer->internal_object, offset, size, indexType,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer2KHR");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType,
- true /* do lock */);
}
-static void entry_vkGetRenderingAreaGranularityKHR(VkDevice device,
- const VkRenderingAreaInfoKHR* pRenderingAreaInfo,
- VkExtent2D* pGranularity) {
+void gfxstream_vk_GetRenderingAreaGranularityKHR(VkDevice device,
+ const VkRenderingAreaInfoKHR* pRenderingAreaInfo,
+ VkExtent2D* pGranularity) {
AEMU_SCOPED_TRACE("vkGetRenderingAreaGranularityKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, pGranularity,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetRenderingAreaGranularityKHR(
- VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance5")) {
- sOnInvalidDynamicallyCheckedCall("vkGetRenderingAreaGranularityKHR", "VK_KHR_maintenance5");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetRenderingAreaGranularityKHR(gfxstream_device->internal_object,
+ pRenderingAreaInfo, pGranularity,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetRenderingAreaGranularityKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, pGranularity,
- true /* do lock */);
}
-static void entry_vkGetDeviceImageSubresourceLayoutKHR(VkDevice device,
- const VkDeviceImageSubresourceInfoKHR* pInfo,
- VkSubresourceLayout2KHR* pLayout) {
+void gfxstream_vk_GetDeviceImageSubresourceLayoutKHR(VkDevice device,
+ const VkDeviceImageSubresourceInfoKHR* pInfo,
+ VkSubresourceLayout2KHR* pLayout) {
AEMU_SCOPED_TRACE("vkGetDeviceImageSubresourceLayoutKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageSubresourceLayoutKHR(device, pInfo, pLayout, true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceImageSubresourceLayoutKHR(
- VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo,
- VkSubresourceLayout2KHR* pLayout) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance5")) {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageSubresourceLayoutKHR",
- "VK_KHR_maintenance5");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetDeviceImageSubresourceLayoutKHR(gfxstream_device->internal_object, pInfo,
+ pLayout, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetDeviceImageSubresourceLayoutKHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageSubresourceLayoutKHR(device, pInfo, pLayout, true /* do lock */);
}
-static void entry_vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
- const VkImageSubresource2KHR* pSubresource,
- VkSubresourceLayout2KHR* pLayout) {
+void gfxstream_vk_GetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
+ const VkImageSubresource2KHR* pSubresource,
+ VkSubresourceLayout2KHR* pLayout) {
AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetImageSubresourceLayout2KHR(
- VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource,
- VkSubresourceLayout2KHR* pLayout) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance5")) {
- sOnInvalidDynamicallyCheckedCall("vkGetImageSubresourceLayout2KHR", "VK_KHR_maintenance5");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetImageSubresourceLayout2KHR(gfxstream_device->internal_object,
+ gfxstream_image->internal_object, pSubresource,
+ pLayout, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout2KHR");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout,
- true /* do lock */);
}
#endif
#ifdef VK_ANDROID_native_buffer
-static VkResult entry_vkGetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
- VkImageUsageFlags imageUsage,
- int* grallocUsage) {
+VkResult gfxstream_vk_GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
+ VkImageUsageFlags imageUsage,
+ int* grallocUsage) {
AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
- vkGetSwapchainGrallocUsageANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsageANDROID(
- device, format, imageUsage, grallocUsage, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetSwapchainGrallocUsageANDROID_VkResult_return =
+ vkEnc->vkGetSwapchainGrallocUsageANDROID(gfxstream_device->internal_object, format,
+ imageUsage, grallocUsage, true /* do lock */);
+ }
return vkGetSwapchainGrallocUsageANDROID_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
- VkImageUsageFlags imageUsage,
- int* grallocUsage) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer")) {
- sOnInvalidDynamicallyCheckedCall("vkGetSwapchainGrallocUsageANDROID",
- "VK_ANDROID_native_buffer");
- }
- AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
- vkGetSwapchainGrallocUsageANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsageANDROID(
- device, format, imageUsage, grallocUsage, true /* do lock */);
- return vkGetSwapchainGrallocUsageANDROID_VkResult_return;
-}
-static VkResult entry_vkAcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd,
- VkSemaphore semaphore, VkFence fence) {
+VkResult gfxstream_vk_AcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd,
+ VkSemaphore semaphore, VkFence fence) {
AEMU_SCOPED_TRACE("vkAcquireImageANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
- vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(
- device, image, nativeFenceFd, semaphore, fence, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore, semaphore);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(
+ gfxstream_device->internal_object, gfxstream_image->internal_object, nativeFenceFd,
+ gfxstream_semaphore ? gfxstream_semaphore->internal_object : VK_NULL_HANDLE,
+ gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+ true /* do lock */);
+ }
return vkAcquireImageANDROID_VkResult_return;
}
-static VkResult dynCheck_entry_vkAcquireImageANDROID(VkDevice device, VkImage image,
- int nativeFenceFd, VkSemaphore semaphore,
- VkFence fence) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer")) {
- sOnInvalidDynamicallyCheckedCall("vkAcquireImageANDROID", "VK_ANDROID_native_buffer");
- }
- AEMU_SCOPED_TRACE("vkAcquireImageANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
- vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(
- device, image, nativeFenceFd, semaphore, fence, true /* do lock */);
- return vkAcquireImageANDROID_VkResult_return;
-}
-static VkResult entry_vkQueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount,
- const VkSemaphore* pWaitSemaphores,
- VkImage image, int* pNativeFenceFd) {
+VkResult gfxstream_vk_QueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount,
+ const VkSemaphore* pWaitSemaphores,
+ VkImage image, int* pNativeFenceFd) {
AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROID");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkQueueSignalReleaseImageANDROID_VkResult_return =
- resources->on_vkQueueSignalReleaseImageANDROID(vkEnc, VK_SUCCESS, queue, waitSemaphoreCount,
- pWaitSemaphores, image, pNativeFenceFd);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkSemaphore> internal_pWaitSemaphores(waitSemaphoreCount);
+ for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+ if (pWaitSemaphores) {
+ VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_pWaitSemaphores,
+ pWaitSemaphores[i]);
+ internal_pWaitSemaphores[i] = gfxstream_pWaitSemaphores->internal_object;
+ }
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkQueueSignalReleaseImageANDROID_VkResult_return =
+ resources->on_vkQueueSignalReleaseImageANDROID(
+ vkEnc, VK_SUCCESS, gfxstream_queue->internal_object, waitSemaphoreCount,
+ internal_pWaitSemaphores.data(), gfxstream_image->internal_object, pNativeFenceFd);
+ }
return vkQueueSignalReleaseImageANDROID_VkResult_return;
}
-static VkResult entry_vkGetSwapchainGrallocUsage2ANDROID(
+VkResult gfxstream_vk_GetSwapchainGrallocUsage2ANDROID(
VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage,
uint64_t* grallocProducerUsage) {
AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsage2ANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = (VkResult)0;
- vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsage2ANDROID(
- device, format, imageUsage, swapchainImageUsage, grallocConsumerUsage, grallocProducerUsage,
- true /* do lock */);
- return vkGetSwapchainGrallocUsage2ANDROID_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetSwapchainGrallocUsage2ANDROID(
- VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
- VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage,
- uint64_t* grallocProducerUsage) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer")) {
- sOnInvalidDynamicallyCheckedCall("vkGetSwapchainGrallocUsage2ANDROID",
- "VK_ANDROID_native_buffer");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetSwapchainGrallocUsage2ANDROID_VkResult_return =
+ vkEnc->vkGetSwapchainGrallocUsage2ANDROID(
+ gfxstream_device->internal_object, format, imageUsage, swapchainImageUsage,
+ grallocConsumerUsage, grallocProducerUsage, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsage2ANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = (VkResult)0;
- vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsage2ANDROID(
- device, format, imageUsage, swapchainImageUsage, grallocConsumerUsage, grallocProducerUsage,
- true /* do lock */);
return vkGetSwapchainGrallocUsage2ANDROID_VkResult_return;
}
#endif
#ifdef VK_EXT_transform_feedback
-static void entry_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer,
- uint32_t firstBinding, uint32_t bindingCount,
- const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets,
- const VkDeviceSize* pSizes) {
+void gfxstream_vk_CmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer,
+ uint32_t firstBinding, uint32_t bindingCount,
+ const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets,
+ const VkDeviceSize* pSizes) {
AEMU_SCOPED_TRACE("vkCmdBindTransformFeedbackBuffersEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers,
- pOffsets, pSizes, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBindTransformFeedbackBuffersEXT(
- VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
- const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdBindTransformFeedbackBuffersEXT",
- "VK_EXT_transform_feedback");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkBuffer> internal_pBuffers(bindingCount);
+ for (uint32_t i = 0; i < bindingCount; ++i) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pBuffers, pBuffers[i]);
+ internal_pBuffers[i] = gfxstream_pBuffers->internal_object;
+ }
+ vkEnc->vkCmdBindTransformFeedbackBuffersEXT(
+ gfxstream_commandBuffer->internal_object, firstBinding, bindingCount,
+ internal_pBuffers.data(), pOffsets, pSizes, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdBindTransformFeedbackBuffersEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers,
- pOffsets, pSizes, true /* do lock */);
}
-static void entry_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer,
- uint32_t firstCounterBuffer,
- uint32_t counterBufferCount,
- const VkBuffer* pCounterBuffers,
- const VkDeviceSize* pCounterBufferOffsets) {
- AEMU_SCOPED_TRACE("vkCmdBeginTransformFeedbackEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
- pCounterBuffers, pCounterBufferOffsets,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBeginTransformFeedbackEXT(
- VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount,
- const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdBeginTransformFeedbackEXT",
- "VK_EXT_transform_feedback");
- }
- AEMU_SCOPED_TRACE("vkCmdBeginTransformFeedbackEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
- pCounterBuffers, pCounterBufferOffsets,
- true /* do lock */);
-}
-static void entry_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
+void gfxstream_vk_CmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer,
uint32_t firstCounterBuffer,
uint32_t counterBufferCount,
const VkBuffer* pCounterBuffers,
const VkDeviceSize* pCounterBufferOffsets) {
+ AEMU_SCOPED_TRACE("vkCmdBeginTransformFeedbackEXT");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkBuffer> internal_pCounterBuffers(counterBufferCount);
+ for (uint32_t i = 0; i < counterBufferCount; ++i) {
+ if (pCounterBuffers) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pCounterBuffers, pCounterBuffers[i]);
+ internal_pCounterBuffers[i] = gfxstream_pCounterBuffers->internal_object;
+ }
+ }
+ vkEnc->vkCmdBeginTransformFeedbackEXT(
+ gfxstream_commandBuffer->internal_object, firstCounterBuffer, counterBufferCount,
+ internal_pCounterBuffers.data(), pCounterBufferOffsets, true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
+ uint32_t firstCounterBuffer,
+ uint32_t counterBufferCount,
+ const VkBuffer* pCounterBuffers,
+ const VkDeviceSize* pCounterBufferOffsets) {
AEMU_SCOPED_TRACE("vkCmdEndTransformFeedbackEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
- pCounterBuffers, pCounterBufferOffsets, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
- uint32_t firstCounterBuffer,
- uint32_t counterBufferCount,
- const VkBuffer* pCounterBuffers,
- const VkDeviceSize* pCounterBufferOffsets) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdEndTransformFeedbackEXT",
- "VK_EXT_transform_feedback");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkBuffer> internal_pCounterBuffers(counterBufferCount);
+ for (uint32_t i = 0; i < counterBufferCount; ++i) {
+ if (pCounterBuffers) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pCounterBuffers, pCounterBuffers[i]);
+ internal_pCounterBuffers[i] = gfxstream_pCounterBuffers->internal_object;
+ }
+ }
+ vkEnc->vkCmdEndTransformFeedbackEXT(
+ gfxstream_commandBuffer->internal_object, firstCounterBuffer, counterBufferCount,
+ internal_pCounterBuffers.data(), pCounterBufferOffsets, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdEndTransformFeedbackEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
- pCounterBuffers, pCounterBufferOffsets, true /* do lock */);
}
-static void entry_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
- uint32_t query, VkQueryControlFlags flags,
- uint32_t index) {
+void gfxstream_vk_CmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t query, VkQueryControlFlags flags,
+ uint32_t index) {
AEMU_SCOPED_TRACE("vkCmdBeginQueryIndexedEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer,
- VkQueryPool queryPool, uint32_t query,
- VkQueryControlFlags flags, uint32_t index) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdBeginQueryIndexedEXT", "VK_EXT_transform_feedback");
- }
- AEMU_SCOPED_TRACE("vkCmdBeginQueryIndexedEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index,
- true /* do lock */);
-}
-static void entry_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
- uint32_t query, uint32_t index) {
- AEMU_SCOPED_TRACE("vkCmdEndQueryIndexedEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer,
- VkQueryPool queryPool, uint32_t query,
- uint32_t index) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdEndQueryIndexedEXT", "VK_EXT_transform_feedback");
- }
- AEMU_SCOPED_TRACE("vkCmdEndQueryIndexedEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index, true /* do lock */);
-}
-static void entry_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer,
- uint32_t instanceCount, uint32_t firstInstance,
- VkBuffer counterBuffer,
- VkDeviceSize counterBufferOffset,
- uint32_t counterOffset, uint32_t vertexStride) {
- AEMU_SCOPED_TRACE("vkCmdDrawIndirectByteCountEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer,
- counterBufferOffset, counterOffset, vertexStride,
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdBeginQueryIndexedEXT(gfxstream_commandBuffer->internal_object,
+ gfxstream_queryPool->internal_object, query, flags, index,
true /* do lock */);
-}
-static void dynCheck_entry_vkCmdDrawIndirectByteCountEXT(
- VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance,
- VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset,
- uint32_t vertexStride) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdDrawIndirectByteCountEXT",
- "VK_EXT_transform_feedback");
}
+}
+void gfxstream_vk_CmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t query, uint32_t index) {
+ AEMU_SCOPED_TRACE("vkCmdEndQueryIndexedEXT");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdEndQueryIndexedEXT(gfxstream_commandBuffer->internal_object,
+ gfxstream_queryPool->internal_object, query, index,
+ true /* do lock */);
+ }
+}
+void gfxstream_vk_CmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount,
+ uint32_t firstInstance, VkBuffer counterBuffer,
+ VkDeviceSize counterBufferOffset,
+ uint32_t counterOffset, uint32_t vertexStride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndirectByteCountEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer,
- counterBufferOffset, counterOffset, vertexStride,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_counterBuffer, counterBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdDrawIndirectByteCountEXT(
+ gfxstream_commandBuffer->internal_object, instanceCount, firstInstance,
+ gfxstream_counterBuffer->internal_object, counterBufferOffset, counterOffset,
+ vertexStride, true /* do lock */);
+ }
}
#endif
#ifdef VK_AMD_gpu_shader_half_float
@@ -3623,62 +5172,42 @@
#ifdef VK_EXT_debug_utils
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
-static VkResult entry_vkGetAndroidHardwareBufferPropertiesANDROID(
+VkResult gfxstream_vk_GetAndroidHardwareBufferPropertiesANDROID(
VkDevice device, const AHardwareBuffer* buffer,
VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return =
- resources->on_vkGetAndroidHardwareBufferPropertiesANDROID(vkEnc, VK_SUCCESS, device, buffer,
- pProperties);
- return vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetAndroidHardwareBufferPropertiesANDROID(
- VkDevice device, const AHardwareBuffer* buffer,
- VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device,
- "VK_ANDROID_external_memory_android_hardware_buffer")) {
- sOnInvalidDynamicallyCheckedCall("vkGetAndroidHardwareBufferPropertiesANDROID",
- "VK_ANDROID_external_memory_android_hardware_buffer");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return =
+ resources->on_vkGetAndroidHardwareBufferPropertiesANDROID(
+ vkEnc, VK_SUCCESS, gfxstream_device->internal_object, buffer, pProperties);
}
- AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
- vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return =
- resources->on_vkGetAndroidHardwareBufferPropertiesANDROID(vkEnc, VK_SUCCESS, device, buffer,
- pProperties);
return vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
}
-static VkResult entry_vkGetMemoryAndroidHardwareBufferANDROID(
+VkResult gfxstream_vk_GetMemoryAndroidHardwareBufferANDROID(
VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
AHardwareBuffer** pBuffer) {
AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
- auto resources = ResourceTracker::get();
- vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return =
- resources->on_vkGetMemoryAndroidHardwareBufferANDROID(vkEnc, VK_SUCCESS, device, pInfo,
- pBuffer);
- return vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetMemoryAndroidHardwareBufferANDROID(
- VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
- AHardwareBuffer** pBuffer) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device,
- "VK_ANDROID_external_memory_android_hardware_buffer")) {
- sOnInvalidDynamicallyCheckedCall("vkGetMemoryAndroidHardwareBufferANDROID",
- "VK_ANDROID_external_memory_android_hardware_buffer");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkMemoryGetAndroidHardwareBufferInfoANDROID> internal_pInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pInfo[i] = pInfo[i];
+ /* VkMemoryGetAndroidHardwareBufferInfoANDROID::memory */
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, internal_pInfo[i].memory);
+ internal_pInfo[i].memory = gfxstream_memory->internal_object;
+ }
+ auto resources = gfxstream::vk::ResourceTracker::get();
+ vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return =
+ resources->on_vkGetMemoryAndroidHardwareBufferANDROID(vkEnc, VK_SUCCESS,
+ gfxstream_device->internal_object,
+ internal_pInfo.data(), pBuffer);
}
- AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
- vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return =
- resources->on_vkGetMemoryAndroidHardwareBufferANDROID(vkEnc, VK_SUCCESS, device, pInfo,
- pBuffer);
return vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
}
#endif
@@ -3701,15 +5230,19 @@
#ifdef VK_EXT_subgroup_size_control
#endif
#ifdef VK_EXT_tooling_info
-static VkResult entry_vkGetPhysicalDeviceToolPropertiesEXT(
+VkResult gfxstream_vk_GetPhysicalDeviceToolPropertiesEXT(
VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
VkPhysicalDeviceToolProperties* pToolProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceToolPropertiesEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return =
- vkEnc->vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount, pToolProperties,
- true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceToolPropertiesEXT(gfxstream_physicalDevice->internal_object,
+ pToolCount, pToolProperties,
+ true /* do lock */);
+ }
return vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return;
}
#endif
@@ -3718,387 +5251,264 @@
#ifdef VK_EXT_provoking_vertex
#endif
#ifdef VK_EXT_line_rasterization
-static void entry_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
- uint16_t lineStipplePattern) {
+void gfxstream_vk_CmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+ uint16_t lineStipplePattern) {
AEMU_SCOPED_TRACE("vkCmdSetLineStippleEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer,
- uint32_t lineStippleFactor,
- uint16_t lineStipplePattern) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_line_rasterization")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetLineStippleEXT", "VK_EXT_line_rasterization");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetLineStippleEXT(gfxstream_commandBuffer->internal_object, lineStippleFactor,
+ lineStipplePattern, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetLineStippleEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern,
- true /* do lock */);
}
#endif
#ifdef VK_EXT_index_type_uint8
#endif
#ifdef VK_EXT_extended_dynamic_state
-static void entry_vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
+void gfxstream_vk_CmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
AEMU_SCOPED_TRACE("vkCmdSetCullModeEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetCullModeEXT(commandBuffer, cullMode, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer,
- VkCullModeFlags cullMode) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetCullModeEXT", "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetCullModeEXT(gfxstream_commandBuffer->internal_object, cullMode,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetCullModeEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetCullModeEXT(commandBuffer, cullMode, true /* do lock */);
}
-static void entry_vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
+void gfxstream_vk_CmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
AEMU_SCOPED_TRACE("vkCmdSetFrontFaceEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetFrontFaceEXT(commandBuffer, frontFace, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer,
- VkFrontFace frontFace) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetFrontFaceEXT", "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetFrontFaceEXT(gfxstream_commandBuffer->internal_object, frontFace,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetFrontFaceEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetFrontFaceEXT(commandBuffer, frontFace, true /* do lock */);
}
-static void entry_vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
- VkPrimitiveTopology primitiveTopology) {
+void gfxstream_vk_CmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
+ VkPrimitiveTopology primitiveTopology) {
AEMU_SCOPED_TRACE("vkCmdSetPrimitiveTopologyEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
- VkPrimitiveTopology primitiveTopology) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetPrimitiveTopologyEXT",
- "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetPrimitiveTopologyEXT(gfxstream_commandBuffer->internal_object,
+ primitiveTopology, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetPrimitiveTopologyEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology, true /* do lock */);
}
-static void entry_vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer,
- uint32_t viewportCount,
- const VkViewport* pViewports) {
+void gfxstream_vk_CmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount,
+ const VkViewport* pViewports) {
AEMU_SCOPED_TRACE("vkCmdSetViewportWithCountEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer,
- uint32_t viewportCount,
- const VkViewport* pViewports) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetViewportWithCountEXT",
- "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetViewportWithCountEXT(gfxstream_commandBuffer->internal_object, viewportCount,
+ pViewports, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetViewportWithCountEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports,
- true /* do lock */);
}
-static void entry_vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount,
- const VkRect2D* pScissors) {
+void gfxstream_vk_CmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount,
+ const VkRect2D* pScissors) {
AEMU_SCOPED_TRACE("vkCmdSetScissorWithCountEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer,
- uint32_t scissorCount,
- const VkRect2D* pScissors) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetScissorWithCountEXT",
- "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetScissorWithCountEXT(gfxstream_commandBuffer->internal_object, scissorCount,
+ pScissors, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetScissorWithCountEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors, true /* do lock */);
}
-static void entry_vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
- uint32_t bindingCount, const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets,
- const VkDeviceSize* pSizes,
- const VkDeviceSize* pStrides) {
+void gfxstream_vk_CmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+ uint32_t bindingCount, const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
+ const VkDeviceSize* pStrides) {
AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers2EXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
- pSizes, pStrides, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer,
- uint32_t firstBinding, uint32_t bindingCount,
- const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets,
- const VkDeviceSize* pSizes,
- const VkDeviceSize* pStrides) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdBindVertexBuffers2EXT",
- "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkBuffer> internal_pBuffers(bindingCount);
+ for (uint32_t i = 0; i < bindingCount; ++i) {
+ if (pBuffers) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pBuffers, pBuffers[i]);
+ internal_pBuffers[i] = gfxstream_pBuffers->internal_object;
+ }
+ }
+ vkEnc->vkCmdBindVertexBuffers2EXT(gfxstream_commandBuffer->internal_object, firstBinding,
+ bindingCount, internal_pBuffers.data(), pOffsets, pSizes,
+ pStrides, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers2EXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
- pSizes, pStrides, true /* do lock */);
}
-static void entry_vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthTestEnable) {
+void gfxstream_vk_CmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthTestEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthTestEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthTestEnable) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthTestEnableEXT",
- "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthTestEnableEXT(gfxstream_commandBuffer->internal_object, depthTestEnable,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetDepthTestEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable, true /* do lock */);
}
-static void entry_vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthWriteEnable) {
+void gfxstream_vk_CmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthWriteEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthWriteEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthWriteEnable) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthWriteEnableEXT",
- "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthWriteEnableEXT(gfxstream_commandBuffer->internal_object,
+ depthWriteEnable, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetDepthWriteEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable, true /* do lock */);
}
-static void entry_vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,
- VkCompareOp depthCompareOp) {
+void gfxstream_vk_CmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,
+ VkCompareOp depthCompareOp) {
AEMU_SCOPED_TRACE("vkCmdSetDepthCompareOpEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,
- VkCompareOp depthCompareOp) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthCompareOpEXT",
- "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthCompareOpEXT(gfxstream_commandBuffer->internal_object, depthCompareOp,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetDepthCompareOpEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp, true /* do lock */);
}
-static void entry_vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthBoundsTestEnable) {
+void gfxstream_vk_CmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthBoundsTestEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthBoundsTestEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthBoundsTestEnable) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthBoundsTestEnableEXT",
- "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthBoundsTestEnableEXT(gfxstream_commandBuffer->internal_object,
+ depthBoundsTestEnable, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetDepthBoundsTestEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable,
- true /* do lock */);
}
-static void entry_vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 stencilTestEnable) {
+void gfxstream_vk_CmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 stencilTestEnable) {
AEMU_SCOPED_TRACE("vkCmdSetStencilTestEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 stencilTestEnable) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetStencilTestEnableEXT",
- "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetStencilTestEnableEXT(gfxstream_commandBuffer->internal_object,
+ stencilTestEnable, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetStencilTestEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable, true /* do lock */);
}
-static void entry_vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
- VkStencilOp failOp, VkStencilOp passOp,
- VkStencilOp depthFailOp, VkCompareOp compareOp) {
+void gfxstream_vk_CmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+ VkStencilOp failOp, VkStencilOp passOp,
+ VkStencilOp depthFailOp, VkCompareOp compareOp) {
AEMU_SCOPED_TRACE("vkCmdSetStencilOpEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask, VkStencilOp failOp,
- VkStencilOp passOp, VkStencilOp depthFailOp,
- VkCompareOp compareOp) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetStencilOpEXT", "VK_EXT_extended_dynamic_state");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetStencilOpEXT(gfxstream_commandBuffer->internal_object, faceMask, failOp,
+ passOp, depthFailOp, compareOp, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetStencilOpEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp,
- true /* do lock */);
}
#endif
#ifdef VK_EXT_host_image_copy
-static VkResult entry_vkCopyMemoryToImageEXT(
+VkResult gfxstream_vk_CopyMemoryToImageEXT(
VkDevice device, const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo) {
AEMU_SCOPED_TRACE("vkCopyMemoryToImageEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCopyMemoryToImageEXT_VkResult_return = (VkResult)0;
- vkCopyMemoryToImageEXT_VkResult_return =
- vkEnc->vkCopyMemoryToImageEXT(device, pCopyMemoryToImageInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkCopyMemoryToImageInfoEXT> internal_pCopyMemoryToImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyMemoryToImageInfo[i] = pCopyMemoryToImageInfo[i];
+ /* VkCopyMemoryToImageInfoEXT::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pCopyMemoryToImageInfo[i].dstImage);
+ internal_pCopyMemoryToImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkCopyMemoryToImageEXT_VkResult_return = vkEnc->vkCopyMemoryToImageEXT(
+ gfxstream_device->internal_object, internal_pCopyMemoryToImageInfo.data(),
+ true /* do lock */);
+ }
return vkCopyMemoryToImageEXT_VkResult_return;
}
-static VkResult dynCheck_entry_vkCopyMemoryToImageEXT(
- VkDevice device, const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
- sOnInvalidDynamicallyCheckedCall("vkCopyMemoryToImageEXT", "VK_EXT_host_image_copy");
- }
- AEMU_SCOPED_TRACE("vkCopyMemoryToImageEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCopyMemoryToImageEXT_VkResult_return = (VkResult)0;
- vkCopyMemoryToImageEXT_VkResult_return =
- vkEnc->vkCopyMemoryToImageEXT(device, pCopyMemoryToImageInfo, true /* do lock */);
- return vkCopyMemoryToImageEXT_VkResult_return;
-}
-static VkResult entry_vkCopyImageToMemoryEXT(
+VkResult gfxstream_vk_CopyImageToMemoryEXT(
VkDevice device, const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo) {
AEMU_SCOPED_TRACE("vkCopyImageToMemoryEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCopyImageToMemoryEXT_VkResult_return = (VkResult)0;
- vkCopyImageToMemoryEXT_VkResult_return =
- vkEnc->vkCopyImageToMemoryEXT(device, pCopyImageToMemoryInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkCopyImageToMemoryInfoEXT> internal_pCopyImageToMemoryInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyImageToMemoryInfo[i] = pCopyImageToMemoryInfo[i];
+ /* VkCopyImageToMemoryInfoEXT::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pCopyImageToMemoryInfo[i].srcImage);
+ internal_pCopyImageToMemoryInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ }
+ vkCopyImageToMemoryEXT_VkResult_return = vkEnc->vkCopyImageToMemoryEXT(
+ gfxstream_device->internal_object, internal_pCopyImageToMemoryInfo.data(),
+ true /* do lock */);
+ }
return vkCopyImageToMemoryEXT_VkResult_return;
}
-static VkResult dynCheck_entry_vkCopyImageToMemoryEXT(
- VkDevice device, const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
- sOnInvalidDynamicallyCheckedCall("vkCopyImageToMemoryEXT", "VK_EXT_host_image_copy");
- }
- AEMU_SCOPED_TRACE("vkCopyImageToMemoryEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCopyImageToMemoryEXT_VkResult_return = (VkResult)0;
- vkCopyImageToMemoryEXT_VkResult_return =
- vkEnc->vkCopyImageToMemoryEXT(device, pCopyImageToMemoryInfo, true /* do lock */);
- return vkCopyImageToMemoryEXT_VkResult_return;
-}
-static VkResult entry_vkCopyImageToImageEXT(
- VkDevice device, const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) {
+VkResult gfxstream_vk_CopyImageToImageEXT(VkDevice device,
+ const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) {
AEMU_SCOPED_TRACE("vkCopyImageToImageEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCopyImageToImageEXT_VkResult_return = (VkResult)0;
- vkCopyImageToImageEXT_VkResult_return =
- vkEnc->vkCopyImageToImageEXT(device, pCopyImageToImageInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkCopyImageToImageInfoEXT> internal_pCopyImageToImageInfo(1);
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pCopyImageToImageInfo[i] = pCopyImageToImageInfo[i];
+ /* VkCopyImageToImageInfoEXT::srcImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+ internal_pCopyImageToImageInfo[i].srcImage);
+ internal_pCopyImageToImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+ /* VkCopyImageToImageInfoEXT::dstImage */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+ internal_pCopyImageToImageInfo[i].dstImage);
+ internal_pCopyImageToImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+ }
+ vkCopyImageToImageEXT_VkResult_return =
+ vkEnc->vkCopyImageToImageEXT(gfxstream_device->internal_object,
+ internal_pCopyImageToImageInfo.data(), true /* do lock */);
+ }
return vkCopyImageToImageEXT_VkResult_return;
}
-static VkResult dynCheck_entry_vkCopyImageToImageEXT(
- VkDevice device, const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
- sOnInvalidDynamicallyCheckedCall("vkCopyImageToImageEXT", "VK_EXT_host_image_copy");
- }
- AEMU_SCOPED_TRACE("vkCopyImageToImageEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCopyImageToImageEXT_VkResult_return = (VkResult)0;
- vkCopyImageToImageEXT_VkResult_return =
- vkEnc->vkCopyImageToImageEXT(device, pCopyImageToImageInfo, true /* do lock */);
- return vkCopyImageToImageEXT_VkResult_return;
-}
-static VkResult entry_vkTransitionImageLayoutEXT(
+VkResult gfxstream_vk_TransitionImageLayoutEXT(
VkDevice device, uint32_t transitionCount,
const VkHostImageLayoutTransitionInfoEXT* pTransitions) {
AEMU_SCOPED_TRACE("vkTransitionImageLayoutEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkTransitionImageLayoutEXT_VkResult_return = (VkResult)0;
- vkTransitionImageLayoutEXT_VkResult_return = vkEnc->vkTransitionImageLayoutEXT(
- device, transitionCount, pTransitions, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkHostImageLayoutTransitionInfoEXT> internal_pTransitions(transitionCount);
+ for (uint32_t i = 0; i < transitionCount; ++i) {
+ internal_pTransitions[i] = pTransitions[i];
+ /* VkHostImageLayoutTransitionInfoEXT::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pTransitions[i].image);
+ internal_pTransitions[i].image = gfxstream_image->internal_object;
+ }
+ vkTransitionImageLayoutEXT_VkResult_return =
+ vkEnc->vkTransitionImageLayoutEXT(gfxstream_device->internal_object, transitionCount,
+ internal_pTransitions.data(), true /* do lock */);
+ }
return vkTransitionImageLayoutEXT_VkResult_return;
}
-static VkResult dynCheck_entry_vkTransitionImageLayoutEXT(
- VkDevice device, uint32_t transitionCount,
- const VkHostImageLayoutTransitionInfoEXT* pTransitions) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
- sOnInvalidDynamicallyCheckedCall("vkTransitionImageLayoutEXT", "VK_EXT_host_image_copy");
- }
- AEMU_SCOPED_TRACE("vkTransitionImageLayoutEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkTransitionImageLayoutEXT_VkResult_return = (VkResult)0;
- vkTransitionImageLayoutEXT_VkResult_return = vkEnc->vkTransitionImageLayoutEXT(
- device, transitionCount, pTransitions, true /* do lock */);
- return vkTransitionImageLayoutEXT_VkResult_return;
-}
-static void entry_vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image,
- const VkImageSubresource2KHR* pSubresource,
- VkSubresourceLayout2KHR* pLayout) {
+void gfxstream_vk_GetImageSubresourceLayout2EXT(VkDevice device, VkImage image,
+ const VkImageSubresource2KHR* pSubresource,
+ VkSubresourceLayout2KHR* pLayout) {
AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout2EXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetImageSubresourceLayout2EXT(
- VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource,
- VkSubresourceLayout2KHR* pLayout) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
- sOnInvalidDynamicallyCheckedCall("vkGetImageSubresourceLayout2EXT",
- "VK_EXT_host_image_copy");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetImageSubresourceLayout2EXT(gfxstream_device->internal_object,
+ gfxstream_image->internal_object, pSubresource,
+ pLayout, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout2EXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout,
- true /* do lock */);
}
#endif
#ifdef VK_EXT_swapchain_maintenance1
@@ -4114,92 +5524,54 @@
#ifdef VK_EXT_custom_border_color
#endif
#ifdef VK_EXT_private_data
-static VkResult entry_vkCreatePrivateDataSlotEXT(VkDevice device,
- const VkPrivateDataSlotCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPrivateDataSlot* pPrivateDataSlot) {
+VkResult gfxstream_vk_CreatePrivateDataSlotEXT(VkDevice device,
+ const VkPrivateDataSlotCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPrivateDataSlot* pPrivateDataSlot) {
AEMU_SCOPED_TRACE("vkCreatePrivateDataSlotEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreatePrivateDataSlotEXT_VkResult_return = (VkResult)0;
- vkCreatePrivateDataSlotEXT_VkResult_return = vkEnc->vkCreatePrivateDataSlotEXT(
- device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreatePrivateDataSlotEXT_VkResult_return =
+ vkEnc->vkCreatePrivateDataSlotEXT(gfxstream_device->internal_object, pCreateInfo,
+ pAllocator, pPrivateDataSlot, true /* do lock */);
+ }
return vkCreatePrivateDataSlotEXT_VkResult_return;
}
-static VkResult dynCheck_entry_vkCreatePrivateDataSlotEXT(
- VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
- sOnInvalidDynamicallyCheckedCall("vkCreatePrivateDataSlotEXT", "VK_EXT_private_data");
- }
- AEMU_SCOPED_TRACE("vkCreatePrivateDataSlotEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreatePrivateDataSlotEXT_VkResult_return = (VkResult)0;
- vkCreatePrivateDataSlotEXT_VkResult_return = vkEnc->vkCreatePrivateDataSlotEXT(
- device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
- return vkCreatePrivateDataSlotEXT_VkResult_return;
-}
-static void entry_vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot,
- const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlotEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator, true /* do lock */);
-}
-static void dynCheck_entry_vkDestroyPrivateDataSlotEXT(VkDevice device,
- VkPrivateDataSlot privateDataSlot,
- const VkAllocationCallbacks* pAllocator) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
- sOnInvalidDynamicallyCheckedCall("vkDestroyPrivateDataSlotEXT", "VK_EXT_private_data");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkDestroyPrivateDataSlotEXT(gfxstream_device->internal_object, privateDataSlot,
+ pAllocator, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlotEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator, true /* do lock */);
}
-static VkResult entry_vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType,
- uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
- uint64_t data) {
+VkResult gfxstream_vk_SetPrivateDataEXT(VkDevice device, VkObjectType objectType,
+ uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
+ uint64_t data) {
AEMU_SCOPED_TRACE("vkSetPrivateDataEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetPrivateDataEXT_VkResult_return = (VkResult)0;
- vkSetPrivateDataEXT_VkResult_return = vkEnc->vkSetPrivateDataEXT(
- device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkSetPrivateDataEXT_VkResult_return =
+ vkEnc->vkSetPrivateDataEXT(gfxstream_device->internal_object, objectType, objectHandle,
+ privateDataSlot, data, true /* do lock */);
+ }
return vkSetPrivateDataEXT_VkResult_return;
}
-static VkResult dynCheck_entry_vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType,
- uint64_t objectHandle,
- VkPrivateDataSlot privateDataSlot,
- uint64_t data) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
- sOnInvalidDynamicallyCheckedCall("vkSetPrivateDataEXT", "VK_EXT_private_data");
- }
- AEMU_SCOPED_TRACE("vkSetPrivateDataEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkSetPrivateDataEXT_VkResult_return = (VkResult)0;
- vkSetPrivateDataEXT_VkResult_return = vkEnc->vkSetPrivateDataEXT(
- device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
- return vkSetPrivateDataEXT_VkResult_return;
-}
-static void entry_vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType,
- uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
- uint64_t* pData) {
+void gfxstream_vk_GetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
+ VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
AEMU_SCOPED_TRACE("vkGetPrivateDataEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType,
- uint64_t objectHandle,
- VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
- sOnInvalidDynamicallyCheckedCall("vkGetPrivateDataEXT", "VK_EXT_private_data");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetPrivateDataEXT(gfxstream_device->internal_object, objectType, objectHandle,
+ privateDataSlot, pData, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetPrivateDataEXT");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData,
- true /* do lock */);
}
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
@@ -4217,129 +5589,78 @@
#ifdef VK_EXT_primitive_topology_list_restart
#endif
#ifdef VK_EXT_extended_dynamic_state2
-static void entry_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer,
- uint32_t patchControlPoints) {
+void gfxstream_vk_CmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer,
+ uint32_t patchControlPoints) {
AEMU_SCOPED_TRACE("vkCmdSetPatchControlPointsEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer,
- uint32_t patchControlPoints) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetPatchControlPointsEXT",
- "VK_EXT_extended_dynamic_state2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetPatchControlPointsEXT(gfxstream_commandBuffer->internal_object,
+ patchControlPoints, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetPatchControlPointsEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints, true /* do lock */);
}
-static void entry_vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 rasterizerDiscardEnable) {
+void gfxstream_vk_CmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 rasterizerDiscardEnable) {
AEMU_SCOPED_TRACE("vkCmdSetRasterizerDiscardEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 rasterizerDiscardEnable) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetRasterizerDiscardEnableEXT",
- "VK_EXT_extended_dynamic_state2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetRasterizerDiscardEnableEXT(gfxstream_commandBuffer->internal_object,
+ rasterizerDiscardEnable, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetRasterizerDiscardEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable,
- true /* do lock */);
}
-static void entry_vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthBiasEnable) {
+void gfxstream_vk_CmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthBiasEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthBiasEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthBiasEnable) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthBiasEnableEXT",
- "VK_EXT_extended_dynamic_state2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetDepthBiasEnableEXT(gfxstream_commandBuffer->internal_object, depthBiasEnable,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetDepthBiasEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable, true /* do lock */);
}
-static void entry_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
+void gfxstream_vk_CmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
AEMU_SCOPED_TRACE("vkCmdSetLogicOpEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetLogicOpEXT(commandBuffer, logicOp, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetLogicOpEXT", "VK_EXT_extended_dynamic_state2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetLogicOpEXT(gfxstream_commandBuffer->internal_object, logicOp,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetLogicOpEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetLogicOpEXT(commandBuffer, logicOp, true /* do lock */);
}
-static void entry_vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 primitiveRestartEnable) {
+void gfxstream_vk_CmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 primitiveRestartEnable) {
AEMU_SCOPED_TRACE("vkCmdSetPrimitiveRestartEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 primitiveRestartEnable) {
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- ;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetPrimitiveRestartEnableEXT",
- "VK_EXT_extended_dynamic_state2");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCmdSetPrimitiveRestartEnableEXT(gfxstream_commandBuffer->internal_object,
+ primitiveRestartEnable, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCmdSetPrimitiveRestartEnableEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable,
- true /* do lock */);
}
#endif
#ifdef VK_GOOGLE_gfxstream
-static VkResult entry_vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device, VkDeviceMemory memory,
- uint64_t* pAddress) {
+VkResult gfxstream_vk_MapMemoryIntoAddressSpaceGOOGLE(VkDevice device, VkDeviceMemory memory,
+ uint64_t* pAddress) {
AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = (VkResult)0;
- vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return =
- vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(device, memory, pAddress, true /* do lock */);
- return vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return;
-}
-static VkResult dynCheck_entry_vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device,
- VkDeviceMemory memory,
- uint64_t* pAddress) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkMapMemoryIntoAddressSpaceGOOGLE",
- "VK_GOOGLE_gfxstream");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return =
+ vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(gfxstream_device->internal_object,
+ gfxstream_memory->internal_object, pAddress,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = (VkResult)0;
- vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return =
- vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(device, memory, pAddress, true /* do lock */);
return vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return;
}
-static void entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
+void gfxstream_vk_UpdateDescriptorSetWithTemplateSizedGOOGLE(
VkDevice device, VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
uint32_t bufferInfoCount, uint32_t bufferViewCount, const uint32_t* pImageInfoEntryIndices,
@@ -4347,300 +5668,533 @@
const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos,
const VkBufferView* pBufferViews) {
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
- device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
- bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices,
- pImageInfos, pBufferInfos, pBufferViews, true /* do lock */);
-}
-static void dynCheck_entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
- VkDevice device, VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
- uint32_t bufferInfoCount, uint32_t bufferViewCount, const uint32_t* pImageInfoEntryIndices,
- const uint32_t* pBufferInfoEntryIndices, const uint32_t* pBufferViewEntryIndices,
- const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos,
- const VkBufferView* pBufferViews) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplateSizedGOOGLE",
- "VK_GOOGLE_gfxstream");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
+ descriptorUpdateTemplate);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkDescriptorImageInfo> internal_pImageInfos(imageInfoCount);
+ for (uint32_t i = 0; i < imageInfoCount; ++i) {
+ if (pImageInfos) {
+ internal_pImageInfos[i] = pImageInfos[i];
+ /* VkDescriptorImageInfo::imageView */
+ if (internal_pImageInfos[i].imageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+ internal_pImageInfos[i].imageView);
+ internal_pImageInfos[i].imageView = gfxstream_imageView->internal_object;
+ }
+ }
+ }
+ std::vector<VkDescriptorBufferInfo> internal_pBufferInfos(bufferInfoCount);
+ for (uint32_t i = 0; i < bufferInfoCount; ++i) {
+ if (pBufferInfos) {
+ internal_pBufferInfos[i] = pBufferInfos[i];
+ /* VkDescriptorBufferInfo::buffer */
+ if (internal_pBufferInfos[i].buffer) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_pBufferInfos[i].buffer);
+ internal_pBufferInfos[i].buffer = gfxstream_buffer->internal_object;
+ }
+ }
+ }
+ std::vector<VkBufferView> internal_pBufferViews(bufferViewCount);
+ for (uint32_t i = 0; i < bufferViewCount; ++i) {
+ if (pBufferViews) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_pBufferViews, pBufferViews[i]);
+ internal_pBufferViews[i] = gfxstream_pBufferViews->internal_object;
+ }
+ }
+ vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
+ gfxstream_device->internal_object, descriptorSet,
+ gfxstream_descriptorUpdateTemplate->internal_object, imageInfoCount, bufferInfoCount,
+ bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices,
+ pBufferViewEntryIndices, internal_pImageInfos.data(), internal_pBufferInfos.data(),
+ internal_pBufferViews.data(), true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
- device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
- bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices,
- pImageInfos, pBufferInfos, pBufferViews, true /* do lock */);
}
-static void entry_vkBeginCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
- const VkCommandBufferBeginInfo* pBeginInfo) {
+void gfxstream_vk_BeginCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo) {
AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkBeginCommandBufferAsyncGOOGLE(commandBuffer, pBeginInfo, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ std::vector<VkCommandBufferBeginInfo> internal_pBeginInfo(1);
+ std::vector<VkCommandBufferInheritanceInfo>
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo;
+ for (uint32_t i = 0; i < 1; ++i) {
+ internal_pBeginInfo[i] = pBeginInfo[i];
+ /* VkCommandBufferBeginInfo::pInheritanceInfo */
+ if (internal_pBeginInfo[i].pInheritanceInfo) {
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i] =
+ internal_pBeginInfo[i].pInheritanceInfo[0];
+ /* VkCommandBufferInheritanceInfo::renderPass */
+ if (internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass) {
+ VK_FROM_HANDLE(
+ gfxstream_vk_render_pass, gfxstream_renderPass,
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass);
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass =
+ gfxstream_renderPass->internal_object;
+ }
+ /* VkCommandBufferInheritanceInfo::framebuffer */
+ if (internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer) {
+ VK_FROM_HANDLE(
+ gfxstream_vk_framebuffer, gfxstream_framebuffer,
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer);
+ internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer =
+ gfxstream_framebuffer->internal_object;
+ }
+ internal_pBeginInfo[i].pInheritanceInfo =
+ &internal_VkCommandBufferBeginInfo_pInheritanceInfo[i];
+ }
+ }
+ vkEnc->vkBeginCommandBufferAsyncGOOGLE(gfxstream_commandBuffer->internal_object,
+ internal_pBeginInfo.data(), true /* do lock */);
+ }
}
-static void entry_vkEndCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer) {
+void gfxstream_vk_EndCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkEndCommandBufferAsyncGOOGLE(commandBuffer, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkEndCommandBufferAsyncGOOGLE(gfxstream_commandBuffer->internal_object,
+ true /* do lock */);
+ }
}
-static void entry_vkResetCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
- VkCommandBufferResetFlags flags) {
+void gfxstream_vk_ResetCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags) {
AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkResetCommandBufferAsyncGOOGLE(commandBuffer, flags, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkResetCommandBufferAsyncGOOGLE(gfxstream_commandBuffer->internal_object, flags,
+ true /* do lock */);
+ }
}
-static void entry_vkCommandBufferHostSyncGOOGLE(VkCommandBuffer commandBuffer,
- uint32_t needHostSync, uint32_t sequenceNumber) {
+void gfxstream_vk_CommandBufferHostSyncGOOGLE(VkCommandBuffer commandBuffer, uint32_t needHostSync,
+ uint32_t sequenceNumber) {
AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCommandBufferHostSyncGOOGLE(commandBuffer, needHostSync, sequenceNumber,
- true /* do lock */);
-}
-static VkResult entry_vkCreateImageWithRequirementsGOOGLE(
- VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
- VkImage* pImage, VkMemoryRequirements* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
- vkCreateImageWithRequirementsGOOGLE_VkResult_return =
- vkEnc->vkCreateImageWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pImage,
- pMemoryRequirements, true /* do lock */);
- return vkCreateImageWithRequirementsGOOGLE_VkResult_return;
-}
-static VkResult dynCheck_entry_vkCreateImageWithRequirementsGOOGLE(
- VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
- VkImage* pImage, VkMemoryRequirements* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkCreateImageWithRequirementsGOOGLE",
- "VK_GOOGLE_gfxstream");
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+ gfxstream_commandBuffer->internal_object);
+ vkEnc->vkCommandBufferHostSyncGOOGLE(gfxstream_commandBuffer->internal_object, needHostSync,
+ sequenceNumber, true /* do lock */);
}
+}
+VkResult gfxstream_vk_CreateImageWithRequirementsGOOGLE(VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage,
+ VkMemoryRequirements* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_image* gfxstream_pImage = (struct gfxstream_vk_image*)vk_image_create(
+ (vk_device*)gfxstream_device, pCreateInfo, pAllocator, sizeof(struct gfxstream_vk_image));
vkCreateImageWithRequirementsGOOGLE_VkResult_return =
- vkEnc->vkCreateImageWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pImage,
- pMemoryRequirements, true /* do lock */);
+ gfxstream_pImage ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateImageWithRequirementsGOOGLE_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreateImageWithRequirementsGOOGLE_VkResult_return =
+ vkEnc->vkCreateImageWithRequirementsGOOGLE(
+ gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pImage->internal_object, pMemoryRequirements, true /* do lock */);
+ }
+ *pImage = gfxstream_vk_image_to_handle(gfxstream_pImage);
return vkCreateImageWithRequirementsGOOGLE_VkResult_return;
}
-static VkResult entry_vkCreateBufferWithRequirementsGOOGLE(
+VkResult gfxstream_vk_CreateBufferWithRequirementsGOOGLE(
VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
VkBuffer* pBuffer, VkMemoryRequirements* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ struct gfxstream_vk_buffer* gfxstream_pBuffer = (struct gfxstream_vk_buffer*)vk_buffer_create(
+ (vk_device*)gfxstream_device, pCreateInfo, pAllocator, sizeof(struct gfxstream_vk_buffer));
vkCreateBufferWithRequirementsGOOGLE_VkResult_return =
- vkEnc->vkCreateBufferWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pBuffer,
- pMemoryRequirements, true /* do lock */);
+ gfxstream_pBuffer ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (VK_SUCCESS == vkCreateBufferWithRequirementsGOOGLE_VkResult_return) {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkCreateBufferWithRequirementsGOOGLE_VkResult_return =
+ vkEnc->vkCreateBufferWithRequirementsGOOGLE(
+ gfxstream_device->internal_object, pCreateInfo, pAllocator,
+ &gfxstream_pBuffer->internal_object, pMemoryRequirements, true /* do lock */);
+ }
+ *pBuffer = gfxstream_vk_buffer_to_handle(gfxstream_pBuffer);
return vkCreateBufferWithRequirementsGOOGLE_VkResult_return;
}
-static VkResult dynCheck_entry_vkCreateBufferWithRequirementsGOOGLE(
- VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
- VkBuffer* pBuffer, VkMemoryRequirements* pMemoryRequirements) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkCreateBufferWithRequirementsGOOGLE",
- "VK_GOOGLE_gfxstream");
- }
- AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
- vkCreateBufferWithRequirementsGOOGLE_VkResult_return =
- vkEnc->vkCreateBufferWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pBuffer,
- pMemoryRequirements, true /* do lock */);
- return vkCreateBufferWithRequirementsGOOGLE_VkResult_return;
-}
-static VkResult entry_vkGetMemoryHostAddressInfoGOOGLE(VkDevice device, VkDeviceMemory memory,
- uint64_t* pAddress, uint64_t* pSize,
- uint64_t* pHostmemId) {
+VkResult gfxstream_vk_GetMemoryHostAddressInfoGOOGLE(VkDevice device, VkDeviceMemory memory,
+ uint64_t* pAddress, uint64_t* pSize,
+ uint64_t* pHostmemId) {
AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = (VkResult)0;
- vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = vkEnc->vkGetMemoryHostAddressInfoGOOGLE(
- device, memory, pAddress, pSize, pHostmemId, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = vkEnc->vkGetMemoryHostAddressInfoGOOGLE(
+ gfxstream_device->internal_object, gfxstream_memory->internal_object, pAddress, pSize,
+ pHostmemId, true /* do lock */);
+ }
return vkGetMemoryHostAddressInfoGOOGLE_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetMemoryHostAddressInfoGOOGLE(VkDevice device,
- VkDeviceMemory memory,
- uint64_t* pAddress, uint64_t* pSize,
- uint64_t* pHostmemId) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkGetMemoryHostAddressInfoGOOGLE", "VK_GOOGLE_gfxstream");
- }
- AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = (VkResult)0;
- vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = vkEnc->vkGetMemoryHostAddressInfoGOOGLE(
- device, memory, pAddress, pSize, pHostmemId, true /* do lock */);
- return vkGetMemoryHostAddressInfoGOOGLE_VkResult_return;
-}
-static VkResult entry_vkFreeMemorySyncGOOGLE(VkDevice device, VkDeviceMemory memory,
- const VkAllocationCallbacks* pAllocator) {
+VkResult gfxstream_vk_FreeMemorySyncGOOGLE(VkDevice device, VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkFreeMemorySyncGOOGLE_VkResult_return = (VkResult)0;
- vkFreeMemorySyncGOOGLE_VkResult_return =
- vkEnc->vkFreeMemorySyncGOOGLE(device, memory, pAllocator, true /* do lock */);
+ if (VK_NULL_HANDLE == memory) {
+ return vkFreeMemorySyncGOOGLE_VkResult_return;
+ }
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkFreeMemorySyncGOOGLE_VkResult_return = vkEnc->vkFreeMemorySyncGOOGLE(
+ gfxstream_device->internal_object,
+ gfxstream_memory ? gfxstream_memory->internal_object : VK_NULL_HANDLE, pAllocator,
+ true /* do lock */);
+ }
+ vk_device_memory_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_memory->vk);
return vkFreeMemorySyncGOOGLE_VkResult_return;
}
-static VkResult dynCheck_entry_vkFreeMemorySyncGOOGLE(VkDevice device, VkDeviceMemory memory,
- const VkAllocationCallbacks* pAllocator) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkFreeMemorySyncGOOGLE", "VK_GOOGLE_gfxstream");
- }
- AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkFreeMemorySyncGOOGLE_VkResult_return = (VkResult)0;
- vkFreeMemorySyncGOOGLE_VkResult_return =
- vkEnc->vkFreeMemorySyncGOOGLE(device, memory, pAllocator, true /* do lock */);
- return vkFreeMemorySyncGOOGLE_VkResult_return;
-}
-static void entry_vkQueueHostSyncGOOGLE(VkQueue queue, uint32_t needHostSync,
- uint32_t sequenceNumber) {
+void gfxstream_vk_QueueHostSyncGOOGLE(VkQueue queue, uint32_t needHostSync,
+ uint32_t sequenceNumber) {
AEMU_SCOPED_TRACE("vkQueueHostSyncGOOGLE");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueHostSyncGOOGLE(queue, needHostSync, sequenceNumber, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ vkEnc->vkQueueHostSyncGOOGLE(gfxstream_queue->internal_object, needHostSync, sequenceNumber,
+ true /* do lock */);
+ }
}
-static void entry_vkQueueSubmitAsyncGOOGLE(VkQueue queue, uint32_t submitCount,
- const VkSubmitInfo* pSubmits, VkFence fence) {
+void gfxstream_vk_QueueSubmitAsyncGOOGLE(VkQueue queue, uint32_t submitCount,
+ const VkSubmitInfo* pSubmits, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueSubmitAsyncGOOGLE");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueSubmitAsyncGOOGLE(queue, submitCount, pSubmits, fence, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkSubmitInfo> internal_pSubmits(submitCount);
+ std::vector<std::vector<VkSemaphore>> internal_VkSubmitInfo_pWaitSemaphores;
+ std::vector<std::vector<VkCommandBuffer>> internal_VkSubmitInfo_pCommandBuffers;
+ std::vector<std::vector<VkSemaphore>> internal_VkSubmitInfo_pSignalSemaphores;
+ for (uint32_t i = 0; i < submitCount; ++i) {
+ internal_pSubmits[i] = pSubmits[i];
+ /* VkSubmitInfo::pWaitSemaphores */
+ internal_VkSubmitInfo_pWaitSemaphores.push_back(std::vector<VkSemaphore>());
+ internal_VkSubmitInfo_pWaitSemaphores[i] = transformVkSemaphoreList(
+ internal_pSubmits[i].pWaitSemaphores, internal_pSubmits[i].waitSemaphoreCount);
+ internal_pSubmits[i].pWaitSemaphores = internal_VkSubmitInfo_pWaitSemaphores[i].data();
+ internal_pSubmits[i].waitSemaphoreCount =
+ internal_VkSubmitInfo_pWaitSemaphores[i].size();
+ /* VkSubmitInfo::pCommandBuffers */
+ internal_VkSubmitInfo_pCommandBuffers.push_back(std::vector<VkCommandBuffer>());
+ internal_VkSubmitInfo_pCommandBuffers[i].reserve(
+ internal_pSubmits[i].commandBufferCount);
+ memset(&internal_VkSubmitInfo_pCommandBuffers[i][0], 0,
+ sizeof(VkCommandBuffer) * internal_pSubmits[i].commandBufferCount);
+ for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferCount; ++j) {
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_pCommandBuffers,
+ internal_pSubmits[i].pCommandBuffers[j]);
+ internal_VkSubmitInfo_pCommandBuffers[i][j] =
+ gfxstream_pCommandBuffers->internal_object;
+ }
+ internal_pSubmits[i].pCommandBuffers = internal_VkSubmitInfo_pCommandBuffers[i].data();
+ /* VkSubmitInfo::pSignalSemaphores */
+ internal_VkSubmitInfo_pSignalSemaphores.push_back(std::vector<VkSemaphore>());
+ internal_VkSubmitInfo_pSignalSemaphores[i] = transformVkSemaphoreList(
+ internal_pSubmits[i].pSignalSemaphores, internal_pSubmits[i].signalSemaphoreCount);
+ internal_pSubmits[i].pSignalSemaphores =
+ internal_VkSubmitInfo_pSignalSemaphores[i].data();
+ internal_pSubmits[i].signalSemaphoreCount =
+ internal_VkSubmitInfo_pSignalSemaphores[i].size();
+ }
+ vkEnc->vkQueueSubmitAsyncGOOGLE(
+ gfxstream_queue->internal_object, submitCount, internal_pSubmits.data(),
+ gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+ true /* do lock */);
+ }
}
-static void entry_vkQueueWaitIdleAsyncGOOGLE(VkQueue queue) {
+void gfxstream_vk_QueueWaitIdleAsyncGOOGLE(VkQueue queue) {
AEMU_SCOPED_TRACE("vkQueueWaitIdleAsyncGOOGLE");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueWaitIdleAsyncGOOGLE(queue, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ vkEnc->vkQueueWaitIdleAsyncGOOGLE(gfxstream_queue->internal_object, true /* do lock */);
+ }
}
-static void entry_vkQueueBindSparseAsyncGOOGLE(VkQueue queue, uint32_t bindInfoCount,
- const VkBindSparseInfo* pBindInfo, VkFence fence) {
+void gfxstream_vk_QueueBindSparseAsyncGOOGLE(VkQueue queue, uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueBindSparseAsyncGOOGLE");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueBindSparseAsyncGOOGLE(queue, bindInfoCount, pBindInfo, fence, true /* do lock */);
-}
-static void entry_vkGetLinearImageLayoutGOOGLE(VkDevice device, VkFormat format,
- VkDeviceSize* pOffset,
- VkDeviceSize* pRowPitchAlignment) {
- AEMU_SCOPED_TRACE("vkGetLinearImageLayoutGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetLinearImageLayoutGOOGLE(device, format, pOffset, pRowPitchAlignment,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetLinearImageLayoutGOOGLE(VkDevice device, VkFormat format,
- VkDeviceSize* pOffset,
- VkDeviceSize* pRowPitchAlignment) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkGetLinearImageLayoutGOOGLE", "VK_GOOGLE_gfxstream");
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkBindSparseInfo> internal_pBindInfo(bindInfoCount);
+ std::vector<std::vector<VkSemaphore>> internal_VkBindSparseInfo_pWaitSemaphores;
+ std::vector<std::vector<VkSparseBufferMemoryBindInfo>>
+ internal_VkBindSparseInfo_pBufferBinds;
+ std::vector<std::vector<VkSparseMemoryBind>> internal_VkSparseBufferMemoryBindInfo_pBinds;
+ std::vector<std::vector<VkSparseImageOpaqueMemoryBindInfo>>
+ internal_VkBindSparseInfo_pImageOpaqueBinds;
+ std::vector<std::vector<VkSparseMemoryBind>>
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds;
+ std::vector<std::vector<VkSparseImageMemoryBindInfo>> internal_VkBindSparseInfo_pImageBinds;
+ std::vector<std::vector<VkSparseImageMemoryBind>>
+ internal_VkSparseImageMemoryBindInfo_pBinds;
+ std::vector<std::vector<VkSemaphore>> internal_VkBindSparseInfo_pSignalSemaphores;
+ for (uint32_t i = 0; i < bindInfoCount; ++i) {
+ internal_pBindInfo[i] = pBindInfo[i];
+ /* VkBindSparseInfo::pWaitSemaphores */
+ internal_VkBindSparseInfo_pWaitSemaphores.push_back(std::vector<VkSemaphore>());
+ internal_VkBindSparseInfo_pWaitSemaphores[i] = transformVkSemaphoreList(
+ internal_pBindInfo[i].pWaitSemaphores, internal_pBindInfo[i].waitSemaphoreCount);
+ internal_pBindInfo[i].pWaitSemaphores =
+ internal_VkBindSparseInfo_pWaitSemaphores[i].data();
+ internal_pBindInfo[i].waitSemaphoreCount =
+ internal_VkBindSparseInfo_pWaitSemaphores[i].size();
+ /* VkBindSparseInfo::pBufferBinds */
+ internal_VkBindSparseInfo_pBufferBinds.push_back(
+ std::vector<VkSparseBufferMemoryBindInfo>());
+ internal_VkBindSparseInfo_pBufferBinds[i].reserve(
+ internal_pBindInfo[i].bufferBindCount);
+ memset(&internal_VkBindSparseInfo_pBufferBinds[i][0], 0,
+ sizeof(VkSparseBufferMemoryBindInfo) * internal_pBindInfo[i].bufferBindCount);
+ for (uint32_t j = 0; j < internal_pBindInfo[i].bufferBindCount; ++j) {
+ internal_VkBindSparseInfo_pBufferBinds[i][j] =
+ internal_pBindInfo[i].pBufferBinds[j];
+ /* VkSparseBufferMemoryBindInfo::buffer */
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_VkBindSparseInfo_pBufferBinds[i][j].buffer);
+ internal_VkBindSparseInfo_pBufferBinds[i][j].buffer =
+ gfxstream_buffer->internal_object;
+ /* VkSparseBufferMemoryBindInfo::pBinds */
+ internal_VkSparseBufferMemoryBindInfo_pBinds.push_back(
+ std::vector<VkSparseMemoryBind>());
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j].reserve(
+ internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount);
+ memset(&internal_VkSparseBufferMemoryBindInfo_pBinds[j][0], 0,
+ sizeof(VkSparseMemoryBind) *
+ internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount);
+ for (uint32_t k = 0; k < internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount;
+ ++k) {
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j][k] =
+ internal_VkBindSparseInfo_pBufferBinds[i][j].pBinds[k];
+ /* VkSparseMemoryBind::memory */
+ if (internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory) {
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory);
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory =
+ gfxstream_memory->internal_object;
+ }
+ }
+ internal_VkBindSparseInfo_pBufferBinds[i][j].pBinds =
+ internal_VkSparseBufferMemoryBindInfo_pBinds[j].data();
+ }
+ internal_pBindInfo[i].pBufferBinds = internal_VkBindSparseInfo_pBufferBinds[i].data();
+ /* VkBindSparseInfo::pImageOpaqueBinds */
+ internal_VkBindSparseInfo_pImageOpaqueBinds.push_back(
+ std::vector<VkSparseImageOpaqueMemoryBindInfo>());
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i].reserve(
+ internal_pBindInfo[i].imageOpaqueBindCount);
+ memset(&internal_VkBindSparseInfo_pImageOpaqueBinds[i][0], 0,
+ sizeof(VkSparseImageOpaqueMemoryBindInfo) *
+ internal_pBindInfo[i].imageOpaqueBindCount);
+ for (uint32_t j = 0; j < internal_pBindInfo[i].imageOpaqueBindCount; ++j) {
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j] =
+ internal_pBindInfo[i].pImageOpaqueBinds[j];
+ /* VkSparseImageOpaqueMemoryBindInfo::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].image);
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].image =
+ gfxstream_image->internal_object;
+ /* VkSparseImageOpaqueMemoryBindInfo::pBinds */
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds.push_back(
+ std::vector<VkSparseMemoryBind>());
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j].reserve(
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount);
+ memset(&internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][0], 0,
+ sizeof(VkSparseMemoryBind) *
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount);
+ for (uint32_t l = 0;
+ l < internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount; ++l) {
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l] =
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].pBinds[l];
+ /* VkSparseMemoryBind::memory */
+ if (internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory) {
+ VK_FROM_HANDLE(
+ gfxstream_vk_device_memory, gfxstream_memory,
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory);
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory =
+ gfxstream_memory->internal_object;
+ }
+ }
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].pBinds =
+ internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j].data();
+ }
+ internal_pBindInfo[i].pImageOpaqueBinds =
+ internal_VkBindSparseInfo_pImageOpaqueBinds[i].data();
+ /* VkBindSparseInfo::pImageBinds */
+ internal_VkBindSparseInfo_pImageBinds.push_back(
+ std::vector<VkSparseImageMemoryBindInfo>());
+ internal_VkBindSparseInfo_pImageBinds[i].reserve(internal_pBindInfo[i].imageBindCount);
+ memset(&internal_VkBindSparseInfo_pImageBinds[i][0], 0,
+ sizeof(VkSparseImageMemoryBindInfo) * internal_pBindInfo[i].imageBindCount);
+ for (uint32_t j = 0; j < internal_pBindInfo[i].imageBindCount; ++j) {
+ internal_VkBindSparseInfo_pImageBinds[i][j] = internal_pBindInfo[i].pImageBinds[j];
+ /* VkSparseImageMemoryBindInfo::image */
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+ internal_VkBindSparseInfo_pImageBinds[i][j].image);
+ internal_VkBindSparseInfo_pImageBinds[i][j].image =
+ gfxstream_image->internal_object;
+ /* VkSparseImageMemoryBindInfo::pBinds */
+ internal_VkSparseImageMemoryBindInfo_pBinds.push_back(
+ std::vector<VkSparseImageMemoryBind>());
+ internal_VkSparseImageMemoryBindInfo_pBinds[j].reserve(
+ internal_VkBindSparseInfo_pImageBinds[i][j].bindCount);
+ memset(&internal_VkSparseImageMemoryBindInfo_pBinds[j][0], 0,
+ sizeof(VkSparseImageMemoryBind) *
+ internal_VkBindSparseInfo_pImageBinds[i][j].bindCount);
+ for (uint32_t m = 0; m < internal_VkBindSparseInfo_pImageBinds[i][j].bindCount;
+ ++m) {
+ internal_VkSparseImageMemoryBindInfo_pBinds[j][m] =
+ internal_VkBindSparseInfo_pImageBinds[i][j].pBinds[m];
+ /* VkSparseImageMemoryBind::memory */
+ if (internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory) {
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+ internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory);
+ internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory =
+ gfxstream_memory->internal_object;
+ }
+ }
+ internal_VkBindSparseInfo_pImageBinds[i][j].pBinds =
+ internal_VkSparseImageMemoryBindInfo_pBinds[j].data();
+ }
+ internal_pBindInfo[i].pImageBinds = internal_VkBindSparseInfo_pImageBinds[i].data();
+ /* VkBindSparseInfo::pSignalSemaphores */
+ internal_VkBindSparseInfo_pSignalSemaphores.push_back(std::vector<VkSemaphore>());
+ internal_VkBindSparseInfo_pSignalSemaphores[i] =
+ transformVkSemaphoreList(internal_pBindInfo[i].pSignalSemaphores,
+ internal_pBindInfo[i].signalSemaphoreCount);
+ internal_pBindInfo[i].pSignalSemaphores =
+ internal_VkBindSparseInfo_pSignalSemaphores[i].data();
+ internal_pBindInfo[i].signalSemaphoreCount =
+ internal_VkBindSparseInfo_pSignalSemaphores[i].size();
+ }
+ vkEnc->vkQueueBindSparseAsyncGOOGLE(
+ gfxstream_queue->internal_object, bindInfoCount, internal_pBindInfo.data(),
+ gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+ true /* do lock */);
}
+}
+void gfxstream_vk_GetLinearImageLayoutGOOGLE(VkDevice device, VkFormat format,
+ VkDeviceSize* pOffset,
+ VkDeviceSize* pRowPitchAlignment) {
AEMU_SCOPED_TRACE("vkGetLinearImageLayoutGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetLinearImageLayoutGOOGLE(device, format, pOffset, pRowPitchAlignment,
- true /* do lock */);
-}
-static void entry_vkGetLinearImageLayout2GOOGLE(VkDevice device,
- const VkImageCreateInfo* pCreateInfo,
- VkDeviceSize* pOffset,
- VkDeviceSize* pRowPitchAlignment) {
- AEMU_SCOPED_TRACE("vkGetLinearImageLayout2GOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetLinearImageLayout2GOOGLE(device, pCreateInfo, pOffset, pRowPitchAlignment,
- true /* do lock */);
-}
-static void dynCheck_entry_vkGetLinearImageLayout2GOOGLE(VkDevice device,
- const VkImageCreateInfo* pCreateInfo,
- VkDeviceSize* pOffset,
- VkDeviceSize* pRowPitchAlignment) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkGetLinearImageLayout2GOOGLE", "VK_GOOGLE_gfxstream");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetLinearImageLayoutGOOGLE(gfxstream_device->internal_object, format, pOffset,
+ pRowPitchAlignment, true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkGetLinearImageLayout2GOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetLinearImageLayout2GOOGLE(device, pCreateInfo, pOffset, pRowPitchAlignment,
- true /* do lock */);
}
-static void entry_vkQueueFlushCommandsGOOGLE(VkQueue queue, VkCommandBuffer commandBuffer,
- VkDeviceSize dataSize, const void* pData) {
+void gfxstream_vk_GetLinearImageLayout2GOOGLE(VkDevice device, const VkImageCreateInfo* pCreateInfo,
+ VkDeviceSize* pOffset,
+ VkDeviceSize* pRowPitchAlignment) {
+ AEMU_SCOPED_TRACE("vkGetLinearImageLayout2GOOGLE");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkGetLinearImageLayout2GOOGLE(gfxstream_device->internal_object, pCreateInfo,
+ pOffset, pRowPitchAlignment, true /* do lock */);
+ }
+}
+void gfxstream_vk_QueueFlushCommandsGOOGLE(VkQueue queue, VkCommandBuffer commandBuffer,
+ VkDeviceSize dataSize, const void* pData) {
AEMU_SCOPED_TRACE("vkQueueFlushCommandsGOOGLE");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueFlushCommandsGOOGLE(queue, commandBuffer, dataSize, pData, true /* do lock */);
-}
-static void entry_vkQueueCommitDescriptorSetUpdatesGOOGLE(
- VkQueue queue, uint32_t descriptorPoolCount, const VkDescriptorPool* pDescriptorPools,
- uint32_t descriptorSetCount, const VkDescriptorSetLayout* pSetLayouts,
- const uint64_t* pDescriptorSetPoolIds, const uint32_t* pDescriptorSetWhichPool,
- const uint32_t* pDescriptorSetPendingAllocation,
- const uint32_t* pDescriptorWriteStartingIndices, uint32_t pendingDescriptorWriteCount,
- const VkWriteDescriptorSet* pPendingDescriptorWrites) {
- AEMU_SCOPED_TRACE("vkQueueCommitDescriptorSetUpdatesGOOGLE");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueCommitDescriptorSetUpdatesGOOGLE(
- queue, descriptorPoolCount, pDescriptorPools, descriptorSetCount, pSetLayouts,
- pDescriptorSetPoolIds, pDescriptorSetWhichPool, pDescriptorSetPendingAllocation,
- pDescriptorWriteStartingIndices, pendingDescriptorWriteCount, pPendingDescriptorWrites,
- true /* do lock */);
-}
-static void entry_vkCollectDescriptorPoolIdsGOOGLE(VkDevice device, VkDescriptorPool descriptorPool,
- uint32_t* pPoolIdCount, uint64_t* pPoolIds) {
- AEMU_SCOPED_TRACE("vkCollectDescriptorPoolIdsGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkCollectDescriptorPoolIdsGOOGLE(device, descriptorPool, pPoolIdCount, pPoolIds,
- true /* do lock */);
-}
-static void dynCheck_entry_vkCollectDescriptorPoolIdsGOOGLE(VkDevice device,
- VkDescriptorPool descriptorPool,
- uint32_t* pPoolIdCount,
- uint64_t* pPoolIds) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkCollectDescriptorPoolIdsGOOGLE", "VK_GOOGLE_gfxstream");
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ vkEnc->vkQueueFlushCommandsGOOGLE(gfxstream_queue->internal_object,
+ gfxstream_commandBuffer->internal_object, dataSize, pData,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkCollectDescriptorPoolIdsGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkCollectDescriptorPoolIdsGOOGLE(device, descriptorPool, pPoolIdCount, pPoolIds,
- true /* do lock */);
}
-static void entry_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(VkQueue queue,
- uint32_t waitSemaphoreCount,
- const VkSemaphore* pWaitSemaphores,
- VkImage image) {
+void gfxstream_vk_CollectDescriptorPoolIdsGOOGLE(VkDevice device, VkDescriptorPool descriptorPool,
+ uint32_t* pPoolIdCount, uint64_t* pPoolIds) {
+ AEMU_SCOPED_TRACE("vkCollectDescriptorPoolIdsGOOGLE");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool, descriptorPool);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkEnc->vkCollectDescriptorPoolIdsGOOGLE(gfxstream_device->internal_object,
+ gfxstream_descriptorPool->internal_object,
+ pPoolIdCount, pPoolIds, true /* do lock */);
+ }
+}
+void gfxstream_vk_QueueSignalReleaseImageANDROIDAsyncGOOGLE(VkQueue queue,
+ uint32_t waitSemaphoreCount,
+ const VkSemaphore* pWaitSemaphores,
+ VkImage image) {
AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROIDAsyncGOOGLE");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(queue, waitSemaphoreCount, pWaitSemaphores,
- image, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkSemaphore> internal_pWaitSemaphores(waitSemaphoreCount);
+ for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+ if (pWaitSemaphores) {
+ VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_pWaitSemaphores,
+ pWaitSemaphores[i]);
+ internal_pWaitSemaphores[i] = gfxstream_pWaitSemaphores->internal_object;
+ }
+ }
+ vkEnc->vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(
+ gfxstream_queue->internal_object, waitSemaphoreCount, internal_pWaitSemaphores.data(),
+ gfxstream_image->internal_object, true /* do lock */);
+ }
}
-static void entry_vkQueueFlushCommandsFromAuxMemoryGOOGLE(VkQueue queue,
- VkCommandBuffer commandBuffer,
- VkDeviceMemory deviceMemory,
- VkDeviceSize dataOffset,
- VkDeviceSize dataSize) {
+void gfxstream_vk_QueueFlushCommandsFromAuxMemoryGOOGLE(VkQueue queue,
+ VkCommandBuffer commandBuffer,
+ VkDeviceMemory deviceMemory,
+ VkDeviceSize dataOffset,
+ VkDeviceSize dataSize) {
AEMU_SCOPED_TRACE("vkQueueFlushCommandsFromAuxMemoryGOOGLE");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueFlushCommandsFromAuxMemoryGOOGLE(queue, commandBuffer, deviceMemory, dataOffset,
- dataSize, true /* do lock */);
-}
-static VkResult entry_vkGetBlobGOOGLE(VkDevice device, VkDeviceMemory memory) {
- AEMU_SCOPED_TRACE("vkGetBlobGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetBlobGOOGLE_VkResult_return = (VkResult)0;
- vkGetBlobGOOGLE_VkResult_return = vkEnc->vkGetBlobGOOGLE(device, memory, true /* do lock */);
- return vkGetBlobGOOGLE_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetBlobGOOGLE(VkDevice device, VkDeviceMemory memory) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkGetBlobGOOGLE", "VK_GOOGLE_gfxstream");
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_deviceMemory, deviceMemory);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ vkEnc->vkQueueFlushCommandsFromAuxMemoryGOOGLE(
+ gfxstream_queue->internal_object, gfxstream_commandBuffer->internal_object,
+ gfxstream_deviceMemory->internal_object, dataOffset, dataSize, true /* do lock */);
}
+}
+VkResult gfxstream_vk_GetBlobGOOGLE(VkDevice device, VkDeviceMemory memory) {
AEMU_SCOPED_TRACE("vkGetBlobGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetBlobGOOGLE_VkResult_return = (VkResult)0;
- vkGetBlobGOOGLE_VkResult_return = vkEnc->vkGetBlobGOOGLE(device, memory, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ vkGetBlobGOOGLE_VkResult_return =
+ vkEnc->vkGetBlobGOOGLE(gfxstream_device->internal_object,
+ gfxstream_memory->internal_object, true /* do lock */);
+ }
return vkGetBlobGOOGLE_VkResult_return;
}
-static void entry_vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
+void gfxstream_vk_UpdateDescriptorSetWithTemplateSized2GOOGLE(
VkDevice device, VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount,
@@ -4649,39 +6203,111 @@
const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews,
const uint8_t* pInlineUniformBlockData) {
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSized2GOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
- device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
- bufferViewCount, inlineUniformBlockCount, pImageInfoEntryIndices, pBufferInfoEntryIndices,
- pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews, pInlineUniformBlockData,
- true /* do lock */);
-}
-static void dynCheck_entry_vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
- VkDevice device, VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
- uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount,
- const uint32_t* pImageInfoEntryIndices, const uint32_t* pBufferInfoEntryIndices,
- const uint32_t* pBufferViewEntryIndices, const VkDescriptorImageInfo* pImageInfos,
- const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews,
- const uint8_t* pInlineUniformBlockData) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplateSized2GOOGLE",
- "VK_GOOGLE_gfxstream");
+ VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+ VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
+ descriptorUpdateTemplate);
+ {
+ auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+ std::vector<VkDescriptorImageInfo> internal_pImageInfos(imageInfoCount);
+ for (uint32_t i = 0; i < imageInfoCount; ++i) {
+ if (pImageInfos) {
+ internal_pImageInfos[i] = pImageInfos[i];
+ /* VkDescriptorImageInfo::imageView */
+ if (internal_pImageInfos[i].imageView) {
+ VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+ internal_pImageInfos[i].imageView);
+ internal_pImageInfos[i].imageView = gfxstream_imageView->internal_object;
+ }
+ }
+ }
+ std::vector<VkDescriptorBufferInfo> internal_pBufferInfos(bufferInfoCount);
+ for (uint32_t i = 0; i < bufferInfoCount; ++i) {
+ if (pBufferInfos) {
+ internal_pBufferInfos[i] = pBufferInfos[i];
+ /* VkDescriptorBufferInfo::buffer */
+ if (internal_pBufferInfos[i].buffer) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+ internal_pBufferInfos[i].buffer);
+ internal_pBufferInfos[i].buffer = gfxstream_buffer->internal_object;
+ }
+ }
+ }
+ std::vector<VkBufferView> internal_pBufferViews(bufferViewCount);
+ for (uint32_t i = 0; i < bufferViewCount; ++i) {
+ if (pBufferViews) {
+ VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_pBufferViews, pBufferViews[i]);
+ internal_pBufferViews[i] = gfxstream_pBufferViews->internal_object;
+ }
+ }
+ vkEnc->vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
+ gfxstream_device->internal_object, descriptorSet,
+ gfxstream_descriptorUpdateTemplate->internal_object, imageInfoCount, bufferInfoCount,
+ bufferViewCount, inlineUniformBlockCount, pImageInfoEntryIndices,
+ pBufferInfoEntryIndices, pBufferViewEntryIndices, internal_pImageInfos.data(),
+ internal_pBufferInfos.data(), internal_pBufferViews.data(), pInlineUniformBlockData,
+ true /* do lock */);
}
- AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSized2GOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
- device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
- bufferViewCount, inlineUniformBlockCount, pImageInfoEntryIndices, pBufferInfoEntryIndices,
- pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews, pInlineUniformBlockData,
- true /* do lock */);
}
-static void entry_vkQueueSubmitAsync2GOOGLE(VkQueue queue, uint32_t submitCount,
- const VkSubmitInfo2* pSubmits, VkFence fence) {
+void gfxstream_vk_QueueSubmitAsync2GOOGLE(VkQueue queue, uint32_t submitCount,
+ const VkSubmitInfo2* pSubmits, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueSubmitAsync2GOOGLE");
- auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueSubmitAsync2GOOGLE(queue, submitCount, pSubmits, fence, true /* do lock */);
+ VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+ VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+ {
+ auto vkEnc =
+ gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+ std::vector<VkSubmitInfo2> internal_pSubmits(submitCount);
+ std::vector<std::vector<VkSemaphoreSubmitInfo>> internal_VkSubmitInfo2_pWaitSemaphoreInfos;
+ std::vector<std::vector<VkCommandBufferSubmitInfo>>
+ internal_VkSubmitInfo2_pCommandBufferInfos;
+ std::vector<std::vector<VkSemaphoreSubmitInfo>>
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos;
+ for (uint32_t i = 0; i < submitCount; ++i) {
+ internal_pSubmits[i] = pSubmits[i];
+ /* VkSubmitInfo2::pWaitSemaphoreInfos */
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos.push_back(
+ std::vector<VkSemaphoreSubmitInfo>());
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos[i] =
+ transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pWaitSemaphoreInfos,
+ internal_pSubmits[i].waitSemaphoreInfoCount);
+ internal_pSubmits[i].pWaitSemaphoreInfos =
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].data();
+ internal_pSubmits[i].waitSemaphoreInfoCount =
+ internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].size();
+ /* VkSubmitInfo2::pCommandBufferInfos */
+ internal_VkSubmitInfo2_pCommandBufferInfos.push_back(
+ std::vector<VkCommandBufferSubmitInfo>());
+ internal_VkSubmitInfo2_pCommandBufferInfos[i].reserve(
+ internal_pSubmits[i].commandBufferInfoCount);
+ memset(&internal_VkSubmitInfo2_pCommandBufferInfos[i][0], 0,
+ sizeof(VkCommandBufferSubmitInfo) * internal_pSubmits[i].commandBufferInfoCount);
+ for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferInfoCount; ++j) {
+ internal_VkSubmitInfo2_pCommandBufferInfos[i][j] =
+ internal_pSubmits[i].pCommandBufferInfos[j];
+ /* VkCommandBufferSubmitInfo::commandBuffer */
+ VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer,
+ internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer);
+ internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer =
+ gfxstream_commandBuffer->internal_object;
+ }
+ internal_pSubmits[i].pCommandBufferInfos =
+ internal_VkSubmitInfo2_pCommandBufferInfos[i].data();
+ /* VkSubmitInfo2::pSignalSemaphoreInfos */
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos.push_back(
+ std::vector<VkSemaphoreSubmitInfo>());
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos[i] =
+ transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pSignalSemaphoreInfos,
+ internal_pSubmits[i].signalSemaphoreInfoCount);
+ internal_pSubmits[i].pSignalSemaphoreInfos =
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].data();
+ internal_pSubmits[i].signalSemaphoreInfoCount =
+ internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].size();
+ }
+ vkEnc->vkQueueSubmitAsync2GOOGLE(
+ gfxstream_queue->internal_object, submitCount, internal_pSubmits.data(),
+ gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+ true /* do lock */);
+ }
}
#endif
#ifdef VK_EXT_load_store_op_none
@@ -4690,3561 +6316,3 @@
#endif
#ifdef VK_QNX_external_memory_screen_buffer
#endif
-void* goldfish_vulkan_get_proc_address(const char* name) {
-#ifdef VK_VERSION_1_0
- if (!strcmp(name, "vkCreateInstance")) {
- return (void*)entry_vkCreateInstance;
- }
- if (!strcmp(name, "vkDestroyInstance")) {
- return (void*)entry_vkDestroyInstance;
- }
- if (!strcmp(name, "vkEnumeratePhysicalDevices")) {
- return (void*)entry_vkEnumeratePhysicalDevices;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures")) {
- return (void*)entry_vkGetPhysicalDeviceFeatures;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties")) {
- return (void*)entry_vkGetPhysicalDeviceFormatProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties")) {
- return (void*)entry_vkGetPhysicalDeviceImageFormatProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceProperties")) {
- return (void*)entry_vkGetPhysicalDeviceProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties")) {
- return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) {
- return (void*)entry_vkGetPhysicalDeviceMemoryProperties;
- }
- if (!strcmp(name, "vkGetInstanceProcAddr")) {
- return (void*)entry_vkGetInstanceProcAddr;
- }
- if (!strcmp(name, "vkGetDeviceProcAddr")) {
- return (void*)entry_vkGetDeviceProcAddr;
- }
- if (!strcmp(name, "vkCreateDevice")) {
- return (void*)entry_vkCreateDevice;
- }
- if (!strcmp(name, "vkDestroyDevice")) {
- return (void*)entry_vkDestroyDevice;
- }
- if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
- return (void*)entry_vkEnumerateInstanceExtensionProperties;
- }
- if (!strcmp(name, "vkEnumerateDeviceExtensionProperties")) {
- return (void*)entry_vkEnumerateDeviceExtensionProperties;
- }
- if (!strcmp(name, "vkEnumerateInstanceLayerProperties")) {
- return (void*)entry_vkEnumerateInstanceLayerProperties;
- }
- if (!strcmp(name, "vkEnumerateDeviceLayerProperties")) {
- return (void*)entry_vkEnumerateDeviceLayerProperties;
- }
- if (!strcmp(name, "vkGetDeviceQueue")) {
- return (void*)entry_vkGetDeviceQueue;
- }
- if (!strcmp(name, "vkQueueSubmit")) {
- return (void*)entry_vkQueueSubmit;
- }
- if (!strcmp(name, "vkQueueWaitIdle")) {
- return (void*)entry_vkQueueWaitIdle;
- }
- if (!strcmp(name, "vkDeviceWaitIdle")) {
- return (void*)entry_vkDeviceWaitIdle;
- }
- if (!strcmp(name, "vkAllocateMemory")) {
- return (void*)entry_vkAllocateMemory;
- }
- if (!strcmp(name, "vkFreeMemory")) {
- return (void*)entry_vkFreeMemory;
- }
- if (!strcmp(name, "vkMapMemory")) {
- return (void*)entry_vkMapMemory;
- }
- if (!strcmp(name, "vkUnmapMemory")) {
- return (void*)entry_vkUnmapMemory;
- }
- if (!strcmp(name, "vkFlushMappedMemoryRanges")) {
- return (void*)entry_vkFlushMappedMemoryRanges;
- }
- if (!strcmp(name, "vkInvalidateMappedMemoryRanges")) {
- return (void*)entry_vkInvalidateMappedMemoryRanges;
- }
- if (!strcmp(name, "vkGetDeviceMemoryCommitment")) {
- return (void*)entry_vkGetDeviceMemoryCommitment;
- }
- if (!strcmp(name, "vkBindBufferMemory")) {
- return (void*)entry_vkBindBufferMemory;
- }
- if (!strcmp(name, "vkBindImageMemory")) {
- return (void*)entry_vkBindImageMemory;
- }
- if (!strcmp(name, "vkGetBufferMemoryRequirements")) {
- return (void*)entry_vkGetBufferMemoryRequirements;
- }
- if (!strcmp(name, "vkGetImageMemoryRequirements")) {
- return (void*)entry_vkGetImageMemoryRequirements;
- }
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements")) {
- return (void*)entry_vkGetImageSparseMemoryRequirements;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties")) {
- return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties;
- }
- if (!strcmp(name, "vkQueueBindSparse")) {
- return (void*)entry_vkQueueBindSparse;
- }
- if (!strcmp(name, "vkCreateFence")) {
- return (void*)entry_vkCreateFence;
- }
- if (!strcmp(name, "vkDestroyFence")) {
- return (void*)entry_vkDestroyFence;
- }
- if (!strcmp(name, "vkResetFences")) {
- return (void*)entry_vkResetFences;
- }
- if (!strcmp(name, "vkGetFenceStatus")) {
- return (void*)entry_vkGetFenceStatus;
- }
- if (!strcmp(name, "vkWaitForFences")) {
- return (void*)entry_vkWaitForFences;
- }
- if (!strcmp(name, "vkCreateSemaphore")) {
- return (void*)entry_vkCreateSemaphore;
- }
- if (!strcmp(name, "vkDestroySemaphore")) {
- return (void*)entry_vkDestroySemaphore;
- }
- if (!strcmp(name, "vkCreateEvent")) {
- return (void*)entry_vkCreateEvent;
- }
- if (!strcmp(name, "vkDestroyEvent")) {
- return (void*)entry_vkDestroyEvent;
- }
- if (!strcmp(name, "vkGetEventStatus")) {
- return (void*)entry_vkGetEventStatus;
- }
- if (!strcmp(name, "vkSetEvent")) {
- return (void*)entry_vkSetEvent;
- }
- if (!strcmp(name, "vkResetEvent")) {
- return (void*)entry_vkResetEvent;
- }
- if (!strcmp(name, "vkCreateQueryPool")) {
- return (void*)entry_vkCreateQueryPool;
- }
- if (!strcmp(name, "vkDestroyQueryPool")) {
- return (void*)entry_vkDestroyQueryPool;
- }
- if (!strcmp(name, "vkGetQueryPoolResults")) {
- return (void*)entry_vkGetQueryPoolResults;
- }
- if (!strcmp(name, "vkCreateBuffer")) {
- return (void*)entry_vkCreateBuffer;
- }
- if (!strcmp(name, "vkDestroyBuffer")) {
- return (void*)entry_vkDestroyBuffer;
- }
- if (!strcmp(name, "vkCreateBufferView")) {
- return (void*)entry_vkCreateBufferView;
- }
- if (!strcmp(name, "vkDestroyBufferView")) {
- return (void*)entry_vkDestroyBufferView;
- }
- if (!strcmp(name, "vkCreateImage")) {
- return (void*)entry_vkCreateImage;
- }
- if (!strcmp(name, "vkDestroyImage")) {
- return (void*)entry_vkDestroyImage;
- }
- if (!strcmp(name, "vkGetImageSubresourceLayout")) {
- return (void*)entry_vkGetImageSubresourceLayout;
- }
- if (!strcmp(name, "vkCreateImageView")) {
- return (void*)entry_vkCreateImageView;
- }
- if (!strcmp(name, "vkDestroyImageView")) {
- return (void*)entry_vkDestroyImageView;
- }
- if (!strcmp(name, "vkCreateShaderModule")) {
- return (void*)entry_vkCreateShaderModule;
- }
- if (!strcmp(name, "vkDestroyShaderModule")) {
- return (void*)entry_vkDestroyShaderModule;
- }
- if (!strcmp(name, "vkCreatePipelineCache")) {
- return (void*)entry_vkCreatePipelineCache;
- }
- if (!strcmp(name, "vkDestroyPipelineCache")) {
- return (void*)entry_vkDestroyPipelineCache;
- }
- if (!strcmp(name, "vkGetPipelineCacheData")) {
- return (void*)entry_vkGetPipelineCacheData;
- }
- if (!strcmp(name, "vkMergePipelineCaches")) {
- return (void*)entry_vkMergePipelineCaches;
- }
- if (!strcmp(name, "vkCreateGraphicsPipelines")) {
- return (void*)entry_vkCreateGraphicsPipelines;
- }
- if (!strcmp(name, "vkCreateComputePipelines")) {
- return (void*)entry_vkCreateComputePipelines;
- }
- if (!strcmp(name, "vkDestroyPipeline")) {
- return (void*)entry_vkDestroyPipeline;
- }
- if (!strcmp(name, "vkCreatePipelineLayout")) {
- return (void*)entry_vkCreatePipelineLayout;
- }
- if (!strcmp(name, "vkDestroyPipelineLayout")) {
- return (void*)entry_vkDestroyPipelineLayout;
- }
- if (!strcmp(name, "vkCreateSampler")) {
- return (void*)entry_vkCreateSampler;
- }
- if (!strcmp(name, "vkDestroySampler")) {
- return (void*)entry_vkDestroySampler;
- }
- if (!strcmp(name, "vkCreateDescriptorSetLayout")) {
- return (void*)entry_vkCreateDescriptorSetLayout;
- }
- if (!strcmp(name, "vkDestroyDescriptorSetLayout")) {
- return (void*)entry_vkDestroyDescriptorSetLayout;
- }
- if (!strcmp(name, "vkCreateDescriptorPool")) {
- return (void*)entry_vkCreateDescriptorPool;
- }
- if (!strcmp(name, "vkDestroyDescriptorPool")) {
- return (void*)entry_vkDestroyDescriptorPool;
- }
- if (!strcmp(name, "vkResetDescriptorPool")) {
- return (void*)entry_vkResetDescriptorPool;
- }
- if (!strcmp(name, "vkAllocateDescriptorSets")) {
- return (void*)entry_vkAllocateDescriptorSets;
- }
- if (!strcmp(name, "vkFreeDescriptorSets")) {
- return (void*)entry_vkFreeDescriptorSets;
- }
- if (!strcmp(name, "vkUpdateDescriptorSets")) {
- return (void*)entry_vkUpdateDescriptorSets;
- }
- if (!strcmp(name, "vkCreateFramebuffer")) {
- return (void*)entry_vkCreateFramebuffer;
- }
- if (!strcmp(name, "vkDestroyFramebuffer")) {
- return (void*)entry_vkDestroyFramebuffer;
- }
- if (!strcmp(name, "vkCreateRenderPass")) {
- return (void*)entry_vkCreateRenderPass;
- }
- if (!strcmp(name, "vkDestroyRenderPass")) {
- return (void*)entry_vkDestroyRenderPass;
- }
- if (!strcmp(name, "vkGetRenderAreaGranularity")) {
- return (void*)entry_vkGetRenderAreaGranularity;
- }
- if (!strcmp(name, "vkCreateCommandPool")) {
- return (void*)entry_vkCreateCommandPool;
- }
- if (!strcmp(name, "vkDestroyCommandPool")) {
- return (void*)entry_vkDestroyCommandPool;
- }
- if (!strcmp(name, "vkResetCommandPool")) {
- return (void*)entry_vkResetCommandPool;
- }
- if (!strcmp(name, "vkAllocateCommandBuffers")) {
- return (void*)entry_vkAllocateCommandBuffers;
- }
- if (!strcmp(name, "vkFreeCommandBuffers")) {
- return (void*)entry_vkFreeCommandBuffers;
- }
- if (!strcmp(name, "vkBeginCommandBuffer")) {
- return (void*)entry_vkBeginCommandBuffer;
- }
- if (!strcmp(name, "vkEndCommandBuffer")) {
- return (void*)entry_vkEndCommandBuffer;
- }
- if (!strcmp(name, "vkResetCommandBuffer")) {
- return (void*)entry_vkResetCommandBuffer;
- }
- if (!strcmp(name, "vkCmdBindPipeline")) {
- return (void*)entry_vkCmdBindPipeline;
- }
- if (!strcmp(name, "vkCmdSetViewport")) {
- return (void*)entry_vkCmdSetViewport;
- }
- if (!strcmp(name, "vkCmdSetScissor")) {
- return (void*)entry_vkCmdSetScissor;
- }
- if (!strcmp(name, "vkCmdSetLineWidth")) {
- return (void*)entry_vkCmdSetLineWidth;
- }
- if (!strcmp(name, "vkCmdSetDepthBias")) {
- return (void*)entry_vkCmdSetDepthBias;
- }
- if (!strcmp(name, "vkCmdSetBlendConstants")) {
- return (void*)entry_vkCmdSetBlendConstants;
- }
- if (!strcmp(name, "vkCmdSetDepthBounds")) {
- return (void*)entry_vkCmdSetDepthBounds;
- }
- if (!strcmp(name, "vkCmdSetStencilCompareMask")) {
- return (void*)entry_vkCmdSetStencilCompareMask;
- }
- if (!strcmp(name, "vkCmdSetStencilWriteMask")) {
- return (void*)entry_vkCmdSetStencilWriteMask;
- }
- if (!strcmp(name, "vkCmdSetStencilReference")) {
- return (void*)entry_vkCmdSetStencilReference;
- }
- if (!strcmp(name, "vkCmdBindDescriptorSets")) {
- return (void*)entry_vkCmdBindDescriptorSets;
- }
- if (!strcmp(name, "vkCmdBindIndexBuffer")) {
- return (void*)entry_vkCmdBindIndexBuffer;
- }
- if (!strcmp(name, "vkCmdBindVertexBuffers")) {
- return (void*)entry_vkCmdBindVertexBuffers;
- }
- if (!strcmp(name, "vkCmdDraw")) {
- return (void*)entry_vkCmdDraw;
- }
- if (!strcmp(name, "vkCmdDrawIndexed")) {
- return (void*)entry_vkCmdDrawIndexed;
- }
- if (!strcmp(name, "vkCmdDrawIndirect")) {
- return (void*)entry_vkCmdDrawIndirect;
- }
- if (!strcmp(name, "vkCmdDrawIndexedIndirect")) {
- return (void*)entry_vkCmdDrawIndexedIndirect;
- }
- if (!strcmp(name, "vkCmdDispatch")) {
- return (void*)entry_vkCmdDispatch;
- }
- if (!strcmp(name, "vkCmdDispatchIndirect")) {
- return (void*)entry_vkCmdDispatchIndirect;
- }
- if (!strcmp(name, "vkCmdCopyBuffer")) {
- return (void*)entry_vkCmdCopyBuffer;
- }
- if (!strcmp(name, "vkCmdCopyImage")) {
- return (void*)entry_vkCmdCopyImage;
- }
- if (!strcmp(name, "vkCmdBlitImage")) {
- return (void*)entry_vkCmdBlitImage;
- }
- if (!strcmp(name, "vkCmdCopyBufferToImage")) {
- return (void*)entry_vkCmdCopyBufferToImage;
- }
- if (!strcmp(name, "vkCmdCopyImageToBuffer")) {
- return (void*)entry_vkCmdCopyImageToBuffer;
- }
- if (!strcmp(name, "vkCmdUpdateBuffer")) {
- return (void*)entry_vkCmdUpdateBuffer;
- }
- if (!strcmp(name, "vkCmdFillBuffer")) {
- return (void*)entry_vkCmdFillBuffer;
- }
- if (!strcmp(name, "vkCmdClearColorImage")) {
- return (void*)entry_vkCmdClearColorImage;
- }
- if (!strcmp(name, "vkCmdClearDepthStencilImage")) {
- return (void*)entry_vkCmdClearDepthStencilImage;
- }
- if (!strcmp(name, "vkCmdClearAttachments")) {
- return (void*)entry_vkCmdClearAttachments;
- }
- if (!strcmp(name, "vkCmdResolveImage")) {
- return (void*)entry_vkCmdResolveImage;
- }
- if (!strcmp(name, "vkCmdSetEvent")) {
- return (void*)entry_vkCmdSetEvent;
- }
- if (!strcmp(name, "vkCmdResetEvent")) {
- return (void*)entry_vkCmdResetEvent;
- }
- if (!strcmp(name, "vkCmdWaitEvents")) {
- return (void*)entry_vkCmdWaitEvents;
- }
- if (!strcmp(name, "vkCmdPipelineBarrier")) {
- return (void*)entry_vkCmdPipelineBarrier;
- }
- if (!strcmp(name, "vkCmdBeginQuery")) {
- return (void*)entry_vkCmdBeginQuery;
- }
- if (!strcmp(name, "vkCmdEndQuery")) {
- return (void*)entry_vkCmdEndQuery;
- }
- if (!strcmp(name, "vkCmdResetQueryPool")) {
- return (void*)entry_vkCmdResetQueryPool;
- }
- if (!strcmp(name, "vkCmdWriteTimestamp")) {
- return (void*)entry_vkCmdWriteTimestamp;
- }
- if (!strcmp(name, "vkCmdCopyQueryPoolResults")) {
- return (void*)entry_vkCmdCopyQueryPoolResults;
- }
- if (!strcmp(name, "vkCmdPushConstants")) {
- return (void*)entry_vkCmdPushConstants;
- }
- if (!strcmp(name, "vkCmdBeginRenderPass")) {
- return (void*)entry_vkCmdBeginRenderPass;
- }
- if (!strcmp(name, "vkCmdNextSubpass")) {
- return (void*)entry_vkCmdNextSubpass;
- }
- if (!strcmp(name, "vkCmdEndRenderPass")) {
- return (void*)entry_vkCmdEndRenderPass;
- }
- if (!strcmp(name, "vkCmdExecuteCommands")) {
- return (void*)entry_vkCmdExecuteCommands;
- }
-#endif
-#ifdef VK_VERSION_1_1
- if (!strcmp(name, "vkEnumerateInstanceVersion")) {
- return nullptr;
- }
- if (!strcmp(name, "vkBindBufferMemory2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkBindImageMemory2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDeviceMask")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdDispatchBase")) {
- return nullptr;
- }
- if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetImageMemoryRequirements2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetBufferMemoryRequirements2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceProperties2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkTrimCommandPool")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceQueue2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCreateSamplerYcbcrConversion")) {
- return nullptr;
- }
- if (!strcmp(name, "vkDestroySamplerYcbcrConversion")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCreateDescriptorUpdateTemplate")) {
- return nullptr;
- }
- if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate")) {
- return nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDescriptorSetLayoutSupport")) {
- return nullptr;
- }
-#endif
-#ifdef VK_VERSION_1_2
- if (!strcmp(name, "vkCmdDrawIndirectCount")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdDrawIndexedIndirectCount")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCreateRenderPass2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdBeginRenderPass2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdNextSubpass2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdEndRenderPass2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkResetQueryPool")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetSemaphoreCounterValue")) {
- return nullptr;
- }
- if (!strcmp(name, "vkWaitSemaphores")) {
- return nullptr;
- }
- if (!strcmp(name, "vkSignalSemaphore")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetBufferDeviceAddress")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetBufferOpaqueCaptureAddress")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddress")) {
- return nullptr;
- }
-#endif
-#ifdef VK_VERSION_1_3
- if (!strcmp(name, "vkGetPhysicalDeviceToolProperties")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCreatePrivateDataSlot")) {
- return nullptr;
- }
- if (!strcmp(name, "vkDestroyPrivateDataSlot")) {
- return nullptr;
- }
- if (!strcmp(name, "vkSetPrivateData")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPrivateData")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetEvent2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdResetEvent2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdWaitEvents2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdPipelineBarrier2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdWriteTimestamp2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueSubmit2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdCopyBuffer2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImage2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdCopyBufferToImage2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImageToBuffer2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdBlitImage2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdResolveImage2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdBeginRendering")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdEndRendering")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetCullMode")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetFrontFace")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveTopology")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetViewportWithCount")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetScissorWithCount")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdBindVertexBuffers2")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthTestEnable")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthWriteEnable")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthCompareOp")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBoundsTestEnable")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilTestEnable")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilOp")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetRasterizerDiscardEnable")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBiasEnable")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveRestartEnable")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceBufferMemoryRequirements")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageMemoryRequirements")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirements")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_android_surface
- if (!strcmp(name, "vkCreateAndroidSurfaceKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_dynamic_rendering
- if (!strcmp(name, "vkCmdBeginRenderingKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdEndRenderingKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_get_physical_device_properties2
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_maintenance1
- if (!strcmp(name, "vkTrimCommandPoolKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_external_memory_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_external_semaphore_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_external_semaphore_fd
- if (!strcmp(name, "vkImportSemaphoreFdKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetSemaphoreFdKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_descriptor_update_template
- if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_create_renderpass2
- if (!strcmp(name, "vkCreateRenderPass2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdBeginRenderPass2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdNextSubpass2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdEndRenderPass2KHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_external_fence_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_external_fence_fd
- if (!strcmp(name, "vkImportFenceFdKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetFenceFdKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_get_memory_requirements2
- if (!strcmp(name, "vkGetImageMemoryRequirements2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_sampler_ycbcr_conversion
- if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_bind_memory2
- if (!strcmp(name, "vkBindBufferMemory2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkBindImageMemory2KHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_maintenance3
- if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_buffer_device_address
- if (!strcmp(name, "vkGetBufferDeviceAddressKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetBufferOpaqueCaptureAddressKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_pipeline_executable_properties
- if (!strcmp(name, "vkGetPipelineExecutablePropertiesKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPipelineExecutableStatisticsKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPipelineExecutableInternalRepresentationsKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_synchronization2
- if (!strcmp(name, "vkCmdSetEvent2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdResetEvent2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdWaitEvents2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdPipelineBarrier2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdWriteTimestamp2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueSubmit2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdWriteBufferMarker2AMD")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetQueueCheckpointData2NV")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_copy_commands2
- if (!strcmp(name, "vkCmdCopyBuffer2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImage2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdCopyBufferToImage2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImageToBuffer2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdBlitImage2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdResolveImage2KHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_maintenance4
- if (!strcmp(name, "vkGetDeviceBufferMemoryRequirementsKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageMemoryRequirementsKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirementsKHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_KHR_maintenance5
- if (!strcmp(name, "vkCmdBindIndexBuffer2KHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetRenderingAreaGranularityKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageSubresourceLayoutKHR")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetImageSubresourceLayout2KHR")) {
- return nullptr;
- }
-#endif
-#ifdef VK_ANDROID_native_buffer
- if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID")) {
- return nullptr;
- }
- if (!strcmp(name, "vkAcquireImageANDROID")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetSwapchainGrallocUsage2ANDROID")) {
- return nullptr;
- }
-#endif
-#ifdef VK_EXT_transform_feedback
- if (!strcmp(name, "vkCmdBindTransformFeedbackBuffersEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdBeginTransformFeedbackEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdEndTransformFeedbackEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdBeginQueryIndexedEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdEndQueryIndexedEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdDrawIndirectByteCountEXT")) {
- return nullptr;
- }
-#endif
-#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID")) {
- return nullptr;
- }
-#endif
-#ifdef VK_EXT_tooling_info
- if (!strcmp(name, "vkGetPhysicalDeviceToolPropertiesEXT")) {
- return nullptr;
- }
-#endif
-#ifdef VK_EXT_line_rasterization
- if (!strcmp(name, "vkCmdSetLineStippleEXT")) {
- return nullptr;
- }
-#endif
-#ifdef VK_EXT_extended_dynamic_state
- if (!strcmp(name, "vkCmdSetCullModeEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetFrontFaceEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveTopologyEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetViewportWithCountEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetScissorWithCountEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdBindVertexBuffers2EXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthTestEnableEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthWriteEnableEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthCompareOpEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBoundsTestEnableEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilTestEnableEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilOpEXT")) {
- return nullptr;
- }
-#endif
-#ifdef VK_EXT_host_image_copy
- if (!strcmp(name, "vkCopyMemoryToImageEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCopyImageToMemoryEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCopyImageToImageEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkTransitionImageLayoutEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetImageSubresourceLayout2EXT")) {
- return nullptr;
- }
-#endif
-#ifdef VK_EXT_private_data
- if (!strcmp(name, "vkCreatePrivateDataSlotEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkDestroyPrivateDataSlotEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkSetPrivateDataEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetPrivateDataEXT")) {
- return nullptr;
- }
-#endif
-#ifdef VK_EXT_extended_dynamic_state2
- if (!strcmp(name, "vkCmdSetPatchControlPointsEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetRasterizerDiscardEnableEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBiasEnableEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetLogicOpEXT")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveRestartEnableEXT")) {
- return nullptr;
- }
-#endif
-#ifdef VK_GOOGLE_gfxstream
- if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetMemoryHostAddressInfoGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkFreeMemorySyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueHostSyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetLinearImageLayout2GOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueFlushCommandsGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueCommitDescriptorSetUpdatesGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkCollectDescriptorPoolIdsGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueFlushCommandsFromAuxMemoryGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetBlobGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSized2GOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkQueueSubmitAsync2GOOGLE")) {
- return nullptr;
- }
-#endif
- return nullptr;
-}
-void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char* name) {
- auto resources = ResourceTracker::get();
- bool has1_1OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_1;
- bool has1_2OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_2;
- bool has1_3OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_3;
-#ifdef VK_VERSION_1_0
- if (!strcmp(name, "vkCreateInstance")) {
- return (void*)entry_vkCreateInstance;
- }
- if (!strcmp(name, "vkDestroyInstance")) {
- return (void*)entry_vkDestroyInstance;
- }
- if (!strcmp(name, "vkEnumeratePhysicalDevices")) {
- return (void*)entry_vkEnumeratePhysicalDevices;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures")) {
- return (void*)entry_vkGetPhysicalDeviceFeatures;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties")) {
- return (void*)entry_vkGetPhysicalDeviceFormatProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties")) {
- return (void*)entry_vkGetPhysicalDeviceImageFormatProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceProperties")) {
- return (void*)entry_vkGetPhysicalDeviceProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties")) {
- return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) {
- return (void*)entry_vkGetPhysicalDeviceMemoryProperties;
- }
- if (!strcmp(name, "vkGetInstanceProcAddr")) {
- return (void*)entry_vkGetInstanceProcAddr;
- }
- if (!strcmp(name, "vkGetDeviceProcAddr")) {
- return (void*)entry_vkGetDeviceProcAddr;
- }
- if (!strcmp(name, "vkCreateDevice")) {
- return (void*)entry_vkCreateDevice;
- }
- if (!strcmp(name, "vkDestroyDevice")) {
- return (void*)entry_vkDestroyDevice;
- }
- if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
- return (void*)entry_vkEnumerateInstanceExtensionProperties;
- }
- if (!strcmp(name, "vkEnumerateDeviceExtensionProperties")) {
- return (void*)entry_vkEnumerateDeviceExtensionProperties;
- }
- if (!strcmp(name, "vkEnumerateInstanceLayerProperties")) {
- return (void*)entry_vkEnumerateInstanceLayerProperties;
- }
- if (!strcmp(name, "vkEnumerateDeviceLayerProperties")) {
- return (void*)entry_vkEnumerateDeviceLayerProperties;
- }
- if (!strcmp(name, "vkGetDeviceQueue")) {
- return (void*)entry_vkGetDeviceQueue;
- }
- if (!strcmp(name, "vkQueueSubmit")) {
- return (void*)entry_vkQueueSubmit;
- }
- if (!strcmp(name, "vkQueueWaitIdle")) {
- return (void*)entry_vkQueueWaitIdle;
- }
- if (!strcmp(name, "vkDeviceWaitIdle")) {
- return (void*)entry_vkDeviceWaitIdle;
- }
- if (!strcmp(name, "vkAllocateMemory")) {
- return (void*)entry_vkAllocateMemory;
- }
- if (!strcmp(name, "vkFreeMemory")) {
- return (void*)entry_vkFreeMemory;
- }
- if (!strcmp(name, "vkMapMemory")) {
- return (void*)entry_vkMapMemory;
- }
- if (!strcmp(name, "vkUnmapMemory")) {
- return (void*)entry_vkUnmapMemory;
- }
- if (!strcmp(name, "vkFlushMappedMemoryRanges")) {
- return (void*)entry_vkFlushMappedMemoryRanges;
- }
- if (!strcmp(name, "vkInvalidateMappedMemoryRanges")) {
- return (void*)entry_vkInvalidateMappedMemoryRanges;
- }
- if (!strcmp(name, "vkGetDeviceMemoryCommitment")) {
- return (void*)entry_vkGetDeviceMemoryCommitment;
- }
- if (!strcmp(name, "vkBindBufferMemory")) {
- return (void*)entry_vkBindBufferMemory;
- }
- if (!strcmp(name, "vkBindImageMemory")) {
- return (void*)entry_vkBindImageMemory;
- }
- if (!strcmp(name, "vkGetBufferMemoryRequirements")) {
- return (void*)entry_vkGetBufferMemoryRequirements;
- }
- if (!strcmp(name, "vkGetImageMemoryRequirements")) {
- return (void*)entry_vkGetImageMemoryRequirements;
- }
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements")) {
- return (void*)entry_vkGetImageSparseMemoryRequirements;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties")) {
- return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties;
- }
- if (!strcmp(name, "vkQueueBindSparse")) {
- return (void*)entry_vkQueueBindSparse;
- }
- if (!strcmp(name, "vkCreateFence")) {
- return (void*)entry_vkCreateFence;
- }
- if (!strcmp(name, "vkDestroyFence")) {
- return (void*)entry_vkDestroyFence;
- }
- if (!strcmp(name, "vkResetFences")) {
- return (void*)entry_vkResetFences;
- }
- if (!strcmp(name, "vkGetFenceStatus")) {
- return (void*)entry_vkGetFenceStatus;
- }
- if (!strcmp(name, "vkWaitForFences")) {
- return (void*)entry_vkWaitForFences;
- }
- if (!strcmp(name, "vkCreateSemaphore")) {
- return (void*)entry_vkCreateSemaphore;
- }
- if (!strcmp(name, "vkDestroySemaphore")) {
- return (void*)entry_vkDestroySemaphore;
- }
- if (!strcmp(name, "vkCreateEvent")) {
- return (void*)entry_vkCreateEvent;
- }
- if (!strcmp(name, "vkDestroyEvent")) {
- return (void*)entry_vkDestroyEvent;
- }
- if (!strcmp(name, "vkGetEventStatus")) {
- return (void*)entry_vkGetEventStatus;
- }
- if (!strcmp(name, "vkSetEvent")) {
- return (void*)entry_vkSetEvent;
- }
- if (!strcmp(name, "vkResetEvent")) {
- return (void*)entry_vkResetEvent;
- }
- if (!strcmp(name, "vkCreateQueryPool")) {
- return (void*)entry_vkCreateQueryPool;
- }
- if (!strcmp(name, "vkDestroyQueryPool")) {
- return (void*)entry_vkDestroyQueryPool;
- }
- if (!strcmp(name, "vkGetQueryPoolResults")) {
- return (void*)entry_vkGetQueryPoolResults;
- }
- if (!strcmp(name, "vkCreateBuffer")) {
- return (void*)entry_vkCreateBuffer;
- }
- if (!strcmp(name, "vkDestroyBuffer")) {
- return (void*)entry_vkDestroyBuffer;
- }
- if (!strcmp(name, "vkCreateBufferView")) {
- return (void*)entry_vkCreateBufferView;
- }
- if (!strcmp(name, "vkDestroyBufferView")) {
- return (void*)entry_vkDestroyBufferView;
- }
- if (!strcmp(name, "vkCreateImage")) {
- return (void*)entry_vkCreateImage;
- }
- if (!strcmp(name, "vkDestroyImage")) {
- return (void*)entry_vkDestroyImage;
- }
- if (!strcmp(name, "vkGetImageSubresourceLayout")) {
- return (void*)entry_vkGetImageSubresourceLayout;
- }
- if (!strcmp(name, "vkCreateImageView")) {
- return (void*)entry_vkCreateImageView;
- }
- if (!strcmp(name, "vkDestroyImageView")) {
- return (void*)entry_vkDestroyImageView;
- }
- if (!strcmp(name, "vkCreateShaderModule")) {
- return (void*)entry_vkCreateShaderModule;
- }
- if (!strcmp(name, "vkDestroyShaderModule")) {
- return (void*)entry_vkDestroyShaderModule;
- }
- if (!strcmp(name, "vkCreatePipelineCache")) {
- return (void*)entry_vkCreatePipelineCache;
- }
- if (!strcmp(name, "vkDestroyPipelineCache")) {
- return (void*)entry_vkDestroyPipelineCache;
- }
- if (!strcmp(name, "vkGetPipelineCacheData")) {
- return (void*)entry_vkGetPipelineCacheData;
- }
- if (!strcmp(name, "vkMergePipelineCaches")) {
- return (void*)entry_vkMergePipelineCaches;
- }
- if (!strcmp(name, "vkCreateGraphicsPipelines")) {
- return (void*)entry_vkCreateGraphicsPipelines;
- }
- if (!strcmp(name, "vkCreateComputePipelines")) {
- return (void*)entry_vkCreateComputePipelines;
- }
- if (!strcmp(name, "vkDestroyPipeline")) {
- return (void*)entry_vkDestroyPipeline;
- }
- if (!strcmp(name, "vkCreatePipelineLayout")) {
- return (void*)entry_vkCreatePipelineLayout;
- }
- if (!strcmp(name, "vkDestroyPipelineLayout")) {
- return (void*)entry_vkDestroyPipelineLayout;
- }
- if (!strcmp(name, "vkCreateSampler")) {
- return (void*)entry_vkCreateSampler;
- }
- if (!strcmp(name, "vkDestroySampler")) {
- return (void*)entry_vkDestroySampler;
- }
- if (!strcmp(name, "vkCreateDescriptorSetLayout")) {
- return (void*)entry_vkCreateDescriptorSetLayout;
- }
- if (!strcmp(name, "vkDestroyDescriptorSetLayout")) {
- return (void*)entry_vkDestroyDescriptorSetLayout;
- }
- if (!strcmp(name, "vkCreateDescriptorPool")) {
- return (void*)entry_vkCreateDescriptorPool;
- }
- if (!strcmp(name, "vkDestroyDescriptorPool")) {
- return (void*)entry_vkDestroyDescriptorPool;
- }
- if (!strcmp(name, "vkResetDescriptorPool")) {
- return (void*)entry_vkResetDescriptorPool;
- }
- if (!strcmp(name, "vkAllocateDescriptorSets")) {
- return (void*)entry_vkAllocateDescriptorSets;
- }
- if (!strcmp(name, "vkFreeDescriptorSets")) {
- return (void*)entry_vkFreeDescriptorSets;
- }
- if (!strcmp(name, "vkUpdateDescriptorSets")) {
- return (void*)entry_vkUpdateDescriptorSets;
- }
- if (!strcmp(name, "vkCreateFramebuffer")) {
- return (void*)entry_vkCreateFramebuffer;
- }
- if (!strcmp(name, "vkDestroyFramebuffer")) {
- return (void*)entry_vkDestroyFramebuffer;
- }
- if (!strcmp(name, "vkCreateRenderPass")) {
- return (void*)entry_vkCreateRenderPass;
- }
- if (!strcmp(name, "vkDestroyRenderPass")) {
- return (void*)entry_vkDestroyRenderPass;
- }
- if (!strcmp(name, "vkGetRenderAreaGranularity")) {
- return (void*)entry_vkGetRenderAreaGranularity;
- }
- if (!strcmp(name, "vkCreateCommandPool")) {
- return (void*)entry_vkCreateCommandPool;
- }
- if (!strcmp(name, "vkDestroyCommandPool")) {
- return (void*)entry_vkDestroyCommandPool;
- }
- if (!strcmp(name, "vkResetCommandPool")) {
- return (void*)entry_vkResetCommandPool;
- }
- if (!strcmp(name, "vkAllocateCommandBuffers")) {
- return (void*)entry_vkAllocateCommandBuffers;
- }
- if (!strcmp(name, "vkFreeCommandBuffers")) {
- return (void*)entry_vkFreeCommandBuffers;
- }
- if (!strcmp(name, "vkBeginCommandBuffer")) {
- return (void*)entry_vkBeginCommandBuffer;
- }
- if (!strcmp(name, "vkEndCommandBuffer")) {
- return (void*)entry_vkEndCommandBuffer;
- }
- if (!strcmp(name, "vkResetCommandBuffer")) {
- return (void*)entry_vkResetCommandBuffer;
- }
- if (!strcmp(name, "vkCmdBindPipeline")) {
- return (void*)entry_vkCmdBindPipeline;
- }
- if (!strcmp(name, "vkCmdSetViewport")) {
- return (void*)entry_vkCmdSetViewport;
- }
- if (!strcmp(name, "vkCmdSetScissor")) {
- return (void*)entry_vkCmdSetScissor;
- }
- if (!strcmp(name, "vkCmdSetLineWidth")) {
- return (void*)entry_vkCmdSetLineWidth;
- }
- if (!strcmp(name, "vkCmdSetDepthBias")) {
- return (void*)entry_vkCmdSetDepthBias;
- }
- if (!strcmp(name, "vkCmdSetBlendConstants")) {
- return (void*)entry_vkCmdSetBlendConstants;
- }
- if (!strcmp(name, "vkCmdSetDepthBounds")) {
- return (void*)entry_vkCmdSetDepthBounds;
- }
- if (!strcmp(name, "vkCmdSetStencilCompareMask")) {
- return (void*)entry_vkCmdSetStencilCompareMask;
- }
- if (!strcmp(name, "vkCmdSetStencilWriteMask")) {
- return (void*)entry_vkCmdSetStencilWriteMask;
- }
- if (!strcmp(name, "vkCmdSetStencilReference")) {
- return (void*)entry_vkCmdSetStencilReference;
- }
- if (!strcmp(name, "vkCmdBindDescriptorSets")) {
- return (void*)entry_vkCmdBindDescriptorSets;
- }
- if (!strcmp(name, "vkCmdBindIndexBuffer")) {
- return (void*)entry_vkCmdBindIndexBuffer;
- }
- if (!strcmp(name, "vkCmdBindVertexBuffers")) {
- return (void*)entry_vkCmdBindVertexBuffers;
- }
- if (!strcmp(name, "vkCmdDraw")) {
- return (void*)entry_vkCmdDraw;
- }
- if (!strcmp(name, "vkCmdDrawIndexed")) {
- return (void*)entry_vkCmdDrawIndexed;
- }
- if (!strcmp(name, "vkCmdDrawIndirect")) {
- return (void*)entry_vkCmdDrawIndirect;
- }
- if (!strcmp(name, "vkCmdDrawIndexedIndirect")) {
- return (void*)entry_vkCmdDrawIndexedIndirect;
- }
- if (!strcmp(name, "vkCmdDispatch")) {
- return (void*)entry_vkCmdDispatch;
- }
- if (!strcmp(name, "vkCmdDispatchIndirect")) {
- return (void*)entry_vkCmdDispatchIndirect;
- }
- if (!strcmp(name, "vkCmdCopyBuffer")) {
- return (void*)entry_vkCmdCopyBuffer;
- }
- if (!strcmp(name, "vkCmdCopyImage")) {
- return (void*)entry_vkCmdCopyImage;
- }
- if (!strcmp(name, "vkCmdBlitImage")) {
- return (void*)entry_vkCmdBlitImage;
- }
- if (!strcmp(name, "vkCmdCopyBufferToImage")) {
- return (void*)entry_vkCmdCopyBufferToImage;
- }
- if (!strcmp(name, "vkCmdCopyImageToBuffer")) {
- return (void*)entry_vkCmdCopyImageToBuffer;
- }
- if (!strcmp(name, "vkCmdUpdateBuffer")) {
- return (void*)entry_vkCmdUpdateBuffer;
- }
- if (!strcmp(name, "vkCmdFillBuffer")) {
- return (void*)entry_vkCmdFillBuffer;
- }
- if (!strcmp(name, "vkCmdClearColorImage")) {
- return (void*)entry_vkCmdClearColorImage;
- }
- if (!strcmp(name, "vkCmdClearDepthStencilImage")) {
- return (void*)entry_vkCmdClearDepthStencilImage;
- }
- if (!strcmp(name, "vkCmdClearAttachments")) {
- return (void*)entry_vkCmdClearAttachments;
- }
- if (!strcmp(name, "vkCmdResolveImage")) {
- return (void*)entry_vkCmdResolveImage;
- }
- if (!strcmp(name, "vkCmdSetEvent")) {
- return (void*)entry_vkCmdSetEvent;
- }
- if (!strcmp(name, "vkCmdResetEvent")) {
- return (void*)entry_vkCmdResetEvent;
- }
- if (!strcmp(name, "vkCmdWaitEvents")) {
- return (void*)entry_vkCmdWaitEvents;
- }
- if (!strcmp(name, "vkCmdPipelineBarrier")) {
- return (void*)entry_vkCmdPipelineBarrier;
- }
- if (!strcmp(name, "vkCmdBeginQuery")) {
- return (void*)entry_vkCmdBeginQuery;
- }
- if (!strcmp(name, "vkCmdEndQuery")) {
- return (void*)entry_vkCmdEndQuery;
- }
- if (!strcmp(name, "vkCmdResetQueryPool")) {
- return (void*)entry_vkCmdResetQueryPool;
- }
- if (!strcmp(name, "vkCmdWriteTimestamp")) {
- return (void*)entry_vkCmdWriteTimestamp;
- }
- if (!strcmp(name, "vkCmdCopyQueryPoolResults")) {
- return (void*)entry_vkCmdCopyQueryPoolResults;
- }
- if (!strcmp(name, "vkCmdPushConstants")) {
- return (void*)entry_vkCmdPushConstants;
- }
- if (!strcmp(name, "vkCmdBeginRenderPass")) {
- return (void*)entry_vkCmdBeginRenderPass;
- }
- if (!strcmp(name, "vkCmdNextSubpass")) {
- return (void*)entry_vkCmdNextSubpass;
- }
- if (!strcmp(name, "vkCmdEndRenderPass")) {
- return (void*)entry_vkCmdEndRenderPass;
- }
- if (!strcmp(name, "vkCmdExecuteCommands")) {
- return (void*)entry_vkCmdExecuteCommands;
- }
-#endif
-#ifdef VK_VERSION_1_1
- if (!strcmp(name, "vkEnumerateInstanceVersion")) {
- return has1_1OrHigher ? (void*)entry_vkEnumerateInstanceVersion : nullptr;
- }
- if (!strcmp(name, "vkBindBufferMemory2")) {
- return (void*)dynCheck_entry_vkBindBufferMemory2;
- }
- if (!strcmp(name, "vkBindImageMemory2")) {
- return (void*)dynCheck_entry_vkBindImageMemory2;
- }
- if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures")) {
- return (void*)dynCheck_entry_vkGetDeviceGroupPeerMemoryFeatures;
- }
- if (!strcmp(name, "vkCmdSetDeviceMask")) {
- return has1_1OrHigher ? (void*)entry_vkCmdSetDeviceMask : nullptr;
- }
- if (!strcmp(name, "vkCmdDispatchBase")) {
- return has1_1OrHigher ? (void*)entry_vkCmdDispatchBase : nullptr;
- }
- if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetImageMemoryRequirements2")) {
- return (void*)dynCheck_entry_vkGetImageMemoryRequirements2;
- }
- if (!strcmp(name, "vkGetBufferMemoryRequirements2")) {
- return (void*)dynCheck_entry_vkGetBufferMemoryRequirements2;
- }
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements2")) {
- return (void*)dynCheck_entry_vkGetImageSparseMemoryRequirements2;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFeatures2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFormatProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2
- : nullptr;
- }
- if (!strcmp(name, "vkTrimCommandPool")) {
- return (void*)dynCheck_entry_vkTrimCommandPool;
- }
- if (!strcmp(name, "vkGetDeviceQueue2")) {
- return (void*)dynCheck_entry_vkGetDeviceQueue2;
- }
- if (!strcmp(name, "vkCreateSamplerYcbcrConversion")) {
- return (void*)dynCheck_entry_vkCreateSamplerYcbcrConversion;
- }
- if (!strcmp(name, "vkDestroySamplerYcbcrConversion")) {
- return (void*)dynCheck_entry_vkDestroySamplerYcbcrConversion;
- }
- if (!strcmp(name, "vkCreateDescriptorUpdateTemplate")) {
- return (void*)dynCheck_entry_vkCreateDescriptorUpdateTemplate;
- }
- if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate")) {
- return (void*)dynCheck_entry_vkDestroyDescriptorUpdateTemplate;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate")) {
- return (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplate;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalBufferProperties : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalFenceProperties : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalSemaphoreProperties
- : nullptr;
- }
- if (!strcmp(name, "vkGetDescriptorSetLayoutSupport")) {
- return (void*)dynCheck_entry_vkGetDescriptorSetLayoutSupport;
- }
-#endif
-#ifdef VK_VERSION_1_2
- if (!strcmp(name, "vkCmdDrawIndirectCount")) {
- return has1_2OrHigher ? (void*)entry_vkCmdDrawIndirectCount : nullptr;
- }
- if (!strcmp(name, "vkCmdDrawIndexedIndirectCount")) {
- return has1_2OrHigher ? (void*)entry_vkCmdDrawIndexedIndirectCount : nullptr;
- }
- if (!strcmp(name, "vkCreateRenderPass2")) {
- return (void*)dynCheck_entry_vkCreateRenderPass2;
- }
- if (!strcmp(name, "vkCmdBeginRenderPass2")) {
- return has1_2OrHigher ? (void*)entry_vkCmdBeginRenderPass2 : nullptr;
- }
- if (!strcmp(name, "vkCmdNextSubpass2")) {
- return has1_2OrHigher ? (void*)entry_vkCmdNextSubpass2 : nullptr;
- }
- if (!strcmp(name, "vkCmdEndRenderPass2")) {
- return has1_2OrHigher ? (void*)entry_vkCmdEndRenderPass2 : nullptr;
- }
- if (!strcmp(name, "vkResetQueryPool")) {
- return (void*)dynCheck_entry_vkResetQueryPool;
- }
- if (!strcmp(name, "vkGetSemaphoreCounterValue")) {
- return (void*)dynCheck_entry_vkGetSemaphoreCounterValue;
- }
- if (!strcmp(name, "vkWaitSemaphores")) {
- return (void*)dynCheck_entry_vkWaitSemaphores;
- }
- if (!strcmp(name, "vkSignalSemaphore")) {
- return (void*)dynCheck_entry_vkSignalSemaphore;
- }
- if (!strcmp(name, "vkGetBufferDeviceAddress")) {
- return (void*)dynCheck_entry_vkGetBufferDeviceAddress;
- }
- if (!strcmp(name, "vkGetBufferOpaqueCaptureAddress")) {
- return (void*)dynCheck_entry_vkGetBufferOpaqueCaptureAddress;
- }
- if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddress")) {
- return (void*)dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddress;
- }
-#endif
-#ifdef VK_VERSION_1_3
- if (!strcmp(name, "vkGetPhysicalDeviceToolProperties")) {
- return has1_3OrHigher ? (void*)entry_vkGetPhysicalDeviceToolProperties : nullptr;
- }
- if (!strcmp(name, "vkCreatePrivateDataSlot")) {
- return (void*)dynCheck_entry_vkCreatePrivateDataSlot;
- }
- if (!strcmp(name, "vkDestroyPrivateDataSlot")) {
- return (void*)dynCheck_entry_vkDestroyPrivateDataSlot;
- }
- if (!strcmp(name, "vkSetPrivateData")) {
- return (void*)dynCheck_entry_vkSetPrivateData;
- }
- if (!strcmp(name, "vkGetPrivateData")) {
- return (void*)dynCheck_entry_vkGetPrivateData;
- }
- if (!strcmp(name, "vkCmdSetEvent2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetEvent2 : nullptr;
- }
- if (!strcmp(name, "vkCmdResetEvent2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdResetEvent2 : nullptr;
- }
- if (!strcmp(name, "vkCmdWaitEvents2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdWaitEvents2 : nullptr;
- }
- if (!strcmp(name, "vkCmdPipelineBarrier2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdPipelineBarrier2 : nullptr;
- }
- if (!strcmp(name, "vkCmdWriteTimestamp2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdWriteTimestamp2 : nullptr;
- }
- if (!strcmp(name, "vkQueueSubmit2")) {
- return has1_3OrHigher ? (void*)entry_vkQueueSubmit2 : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyBuffer2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdCopyBuffer2 : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImage2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdCopyImage2 : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyBufferToImage2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdCopyBufferToImage2 : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImageToBuffer2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdCopyImageToBuffer2 : nullptr;
- }
- if (!strcmp(name, "vkCmdBlitImage2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdBlitImage2 : nullptr;
- }
- if (!strcmp(name, "vkCmdResolveImage2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdResolveImage2 : nullptr;
- }
- if (!strcmp(name, "vkCmdBeginRendering")) {
- return has1_3OrHigher ? (void*)entry_vkCmdBeginRendering : nullptr;
- }
- if (!strcmp(name, "vkCmdEndRendering")) {
- return has1_3OrHigher ? (void*)entry_vkCmdEndRendering : nullptr;
- }
- if (!strcmp(name, "vkCmdSetCullMode")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetCullMode : nullptr;
- }
- if (!strcmp(name, "vkCmdSetFrontFace")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetFrontFace : nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveTopology")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetPrimitiveTopology : nullptr;
- }
- if (!strcmp(name, "vkCmdSetViewportWithCount")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetViewportWithCount : nullptr;
- }
- if (!strcmp(name, "vkCmdSetScissorWithCount")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetScissorWithCount : nullptr;
- }
- if (!strcmp(name, "vkCmdBindVertexBuffers2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdBindVertexBuffers2 : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthTestEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthTestEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthWriteEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthWriteEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthCompareOp")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthCompareOp : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBoundsTestEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthBoundsTestEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilTestEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetStencilTestEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilOp")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetStencilOp : nullptr;
- }
- if (!strcmp(name, "vkCmdSetRasterizerDiscardEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetRasterizerDiscardEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBiasEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthBiasEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveRestartEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetPrimitiveRestartEnable : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceBufferMemoryRequirements")) {
- return (void*)dynCheck_entry_vkGetDeviceBufferMemoryRequirements;
- }
- if (!strcmp(name, "vkGetDeviceImageMemoryRequirements")) {
- return (void*)dynCheck_entry_vkGetDeviceImageMemoryRequirements;
- }
- if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirements")) {
- return (void*)dynCheck_entry_vkGetDeviceImageSparseMemoryRequirements;
- }
-#endif
-#ifdef VK_KHR_android_surface
- if (!strcmp(name, "vkCreateAndroidSurfaceKHR")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_android_surface");
- return hasExt ? (void*)entry_vkCreateAndroidSurfaceKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_dynamic_rendering
- if (!strcmp(name, "vkCmdBeginRenderingKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdBeginRenderingKHR;
- }
- if (!strcmp(name, "vkCmdEndRenderingKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdEndRenderingKHR;
- }
-#endif
-#ifdef VK_KHR_get_physical_device_properties2
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceFeatures2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceFormatProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_maintenance1
- if (!strcmp(name, "vkTrimCommandPoolKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkTrimCommandPoolKHR;
- }
-#endif
-#ifdef VK_KHR_external_memory_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_external_memory_capabilities");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_external_semaphore_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_external_semaphore_capabilities");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_external_semaphore_fd
- if (!strcmp(name, "vkImportSemaphoreFdKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkImportSemaphoreFdKHR;
- }
- if (!strcmp(name, "vkGetSemaphoreFdKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetSemaphoreFdKHR;
- }
-#endif
-#ifdef VK_KHR_descriptor_update_template
- if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCreateDescriptorUpdateTemplateKHR;
- }
- if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkDestroyDescriptorUpdateTemplateKHR;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplateKHR;
- }
-#endif
-#ifdef VK_KHR_create_renderpass2
- if (!strcmp(name, "vkCreateRenderPass2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCreateRenderPass2KHR;
- }
- if (!strcmp(name, "vkCmdBeginRenderPass2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdBeginRenderPass2KHR;
- }
- if (!strcmp(name, "vkCmdNextSubpass2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdNextSubpass2KHR;
- }
- if (!strcmp(name, "vkCmdEndRenderPass2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdEndRenderPass2KHR;
- }
-#endif
-#ifdef VK_KHR_external_fence_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR")) {
- bool hasExt =
- resources->hasInstanceExtension(instance, "VK_KHR_external_fence_capabilities");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalFencePropertiesKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_external_fence_fd
- if (!strcmp(name, "vkImportFenceFdKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkImportFenceFdKHR;
- }
- if (!strcmp(name, "vkGetFenceFdKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetFenceFdKHR;
- }
-#endif
-#ifdef VK_KHR_get_memory_requirements2
- if (!strcmp(name, "vkGetImageMemoryRequirements2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetImageMemoryRequirements2KHR;
- }
- if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetBufferMemoryRequirements2KHR;
- }
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetImageSparseMemoryRequirements2KHR;
- }
-#endif
-#ifdef VK_KHR_sampler_ycbcr_conversion
- if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCreateSamplerYcbcrConversionKHR;
- }
- if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkDestroySamplerYcbcrConversionKHR;
- }
-#endif
-#ifdef VK_KHR_bind_memory2
- if (!strcmp(name, "vkBindBufferMemory2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkBindBufferMemory2KHR;
- }
- if (!strcmp(name, "vkBindImageMemory2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkBindImageMemory2KHR;
- }
-#endif
-#ifdef VK_KHR_maintenance3
- if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetDescriptorSetLayoutSupportKHR;
- }
-#endif
-#ifdef VK_KHR_buffer_device_address
- if (!strcmp(name, "vkGetBufferDeviceAddressKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetBufferDeviceAddressKHR;
- }
- if (!strcmp(name, "vkGetBufferOpaqueCaptureAddressKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetBufferOpaqueCaptureAddressKHR;
- }
- if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR;
- }
-#endif
-#ifdef VK_KHR_pipeline_executable_properties
- if (!strcmp(name, "vkGetPipelineExecutablePropertiesKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetPipelineExecutablePropertiesKHR;
- }
- if (!strcmp(name, "vkGetPipelineExecutableStatisticsKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetPipelineExecutableStatisticsKHR;
- }
- if (!strcmp(name, "vkGetPipelineExecutableInternalRepresentationsKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetPipelineExecutableInternalRepresentationsKHR;
- }
-#endif
-#ifdef VK_KHR_synchronization2
- if (!strcmp(name, "vkCmdSetEvent2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetEvent2KHR;
- }
- if (!strcmp(name, "vkCmdResetEvent2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdResetEvent2KHR;
- }
- if (!strcmp(name, "vkCmdWaitEvents2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdWaitEvents2KHR;
- }
- if (!strcmp(name, "vkCmdPipelineBarrier2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdPipelineBarrier2KHR;
- }
- if (!strcmp(name, "vkCmdWriteTimestamp2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdWriteTimestamp2KHR;
- }
- if (!strcmp(name, "vkQueueSubmit2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)entry_vkQueueSubmit2KHR;
- }
- if (!strcmp(name, "vkCmdWriteBufferMarker2AMD")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdWriteBufferMarker2AMD;
- }
- if (!strcmp(name, "vkGetQueueCheckpointData2NV")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)entry_vkGetQueueCheckpointData2NV;
- }
-#endif
-#ifdef VK_KHR_copy_commands2
- if (!strcmp(name, "vkCmdCopyBuffer2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdCopyBuffer2KHR;
- }
- if (!strcmp(name, "vkCmdCopyImage2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdCopyImage2KHR;
- }
- if (!strcmp(name, "vkCmdCopyBufferToImage2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdCopyBufferToImage2KHR;
- }
- if (!strcmp(name, "vkCmdCopyImageToBuffer2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdCopyImageToBuffer2KHR;
- }
- if (!strcmp(name, "vkCmdBlitImage2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdBlitImage2KHR;
- }
- if (!strcmp(name, "vkCmdResolveImage2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdResolveImage2KHR;
- }
-#endif
-#ifdef VK_KHR_maintenance4
- if (!strcmp(name, "vkGetDeviceBufferMemoryRequirementsKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetDeviceBufferMemoryRequirementsKHR;
- }
- if (!strcmp(name, "vkGetDeviceImageMemoryRequirementsKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetDeviceImageMemoryRequirementsKHR;
- }
- if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirementsKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetDeviceImageSparseMemoryRequirementsKHR;
- }
-#endif
-#ifdef VK_KHR_maintenance5
- if (!strcmp(name, "vkCmdBindIndexBuffer2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdBindIndexBuffer2KHR;
- }
- if (!strcmp(name, "vkGetRenderingAreaGranularityKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetRenderingAreaGranularityKHR;
- }
- if (!strcmp(name, "vkGetDeviceImageSubresourceLayoutKHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetDeviceImageSubresourceLayoutKHR;
- }
- if (!strcmp(name, "vkGetImageSubresourceLayout2KHR")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetImageSubresourceLayout2KHR;
- }
-#endif
-#ifdef VK_ANDROID_native_buffer
- if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetSwapchainGrallocUsageANDROID;
- }
- if (!strcmp(name, "vkAcquireImageANDROID")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkAcquireImageANDROID;
- }
- if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)entry_vkQueueSignalReleaseImageANDROID;
- }
- if (!strcmp(name, "vkGetSwapchainGrallocUsage2ANDROID")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetSwapchainGrallocUsage2ANDROID;
- }
-#endif
-#ifdef VK_EXT_transform_feedback
- if (!strcmp(name, "vkCmdBindTransformFeedbackBuffersEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdBindTransformFeedbackBuffersEXT;
- }
- if (!strcmp(name, "vkCmdBeginTransformFeedbackEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdBeginTransformFeedbackEXT;
- }
- if (!strcmp(name, "vkCmdEndTransformFeedbackEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdEndTransformFeedbackEXT;
- }
- if (!strcmp(name, "vkCmdBeginQueryIndexedEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdBeginQueryIndexedEXT;
- }
- if (!strcmp(name, "vkCmdEndQueryIndexedEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdEndQueryIndexedEXT;
- }
- if (!strcmp(name, "vkCmdDrawIndirectByteCountEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdDrawIndirectByteCountEXT;
- }
-#endif
-#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetAndroidHardwareBufferPropertiesANDROID;
- }
- if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetMemoryAndroidHardwareBufferANDROID;
- }
-#endif
-#ifdef VK_EXT_tooling_info
- if (!strcmp(name, "vkGetPhysicalDeviceToolPropertiesEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)entry_vkGetPhysicalDeviceToolPropertiesEXT;
- }
-#endif
-#ifdef VK_EXT_line_rasterization
- if (!strcmp(name, "vkCmdSetLineStippleEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetLineStippleEXT;
- }
-#endif
-#ifdef VK_EXT_extended_dynamic_state
- if (!strcmp(name, "vkCmdSetCullModeEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetCullModeEXT;
- }
- if (!strcmp(name, "vkCmdSetFrontFaceEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetFrontFaceEXT;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveTopologyEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetPrimitiveTopologyEXT;
- }
- if (!strcmp(name, "vkCmdSetViewportWithCountEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetViewportWithCountEXT;
- }
- if (!strcmp(name, "vkCmdSetScissorWithCountEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetScissorWithCountEXT;
- }
- if (!strcmp(name, "vkCmdBindVertexBuffers2EXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdBindVertexBuffers2EXT;
- }
- if (!strcmp(name, "vkCmdSetDepthTestEnableEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetDepthTestEnableEXT;
- }
- if (!strcmp(name, "vkCmdSetDepthWriteEnableEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetDepthWriteEnableEXT;
- }
- if (!strcmp(name, "vkCmdSetDepthCompareOpEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetDepthCompareOpEXT;
- }
- if (!strcmp(name, "vkCmdSetDepthBoundsTestEnableEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetDepthBoundsTestEnableEXT;
- }
- if (!strcmp(name, "vkCmdSetStencilTestEnableEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetStencilTestEnableEXT;
- }
- if (!strcmp(name, "vkCmdSetStencilOpEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetStencilOpEXT;
- }
-#endif
-#ifdef VK_EXT_host_image_copy
- if (!strcmp(name, "vkCopyMemoryToImageEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCopyMemoryToImageEXT;
- }
- if (!strcmp(name, "vkCopyImageToMemoryEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCopyImageToMemoryEXT;
- }
- if (!strcmp(name, "vkCopyImageToImageEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCopyImageToImageEXT;
- }
- if (!strcmp(name, "vkTransitionImageLayoutEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkTransitionImageLayoutEXT;
- }
- if (!strcmp(name, "vkGetImageSubresourceLayout2EXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetImageSubresourceLayout2EXT;
- }
-#endif
-#ifdef VK_EXT_private_data
- if (!strcmp(name, "vkCreatePrivateDataSlotEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCreatePrivateDataSlotEXT;
- }
- if (!strcmp(name, "vkDestroyPrivateDataSlotEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkDestroyPrivateDataSlotEXT;
- }
- if (!strcmp(name, "vkSetPrivateDataEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkSetPrivateDataEXT;
- }
- if (!strcmp(name, "vkGetPrivateDataEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkGetPrivateDataEXT;
- }
-#endif
-#ifdef VK_EXT_extended_dynamic_state2
- if (!strcmp(name, "vkCmdSetPatchControlPointsEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetPatchControlPointsEXT;
- }
- if (!strcmp(name, "vkCmdSetRasterizerDiscardEnableEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetRasterizerDiscardEnableEXT;
- }
- if (!strcmp(name, "vkCmdSetDepthBiasEnableEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetDepthBiasEnableEXT;
- }
- if (!strcmp(name, "vkCmdSetLogicOpEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetLogicOpEXT;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveRestartEnableEXT")) {
- // TODO(b/236246382): Check support for device extension;
- return (void*)dynCheck_entry_vkCmdSetPrimitiveRestartEnableEXT;
- }
-#endif
-#ifdef VK_GOOGLE_gfxstream
- if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkMapMemoryIntoAddressSpaceGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE
- : nullptr;
- }
- if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkBeginCommandBufferAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkEndCommandBufferAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkResetCommandBufferAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkCommandBufferHostSyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkCreateImageWithRequirementsGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkCreateBufferWithRequirementsGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkGetMemoryHostAddressInfoGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkGetMemoryHostAddressInfoGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkFreeMemorySyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkFreeMemorySyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueHostSyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueHostSyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueSubmitAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueWaitIdleAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueBindSparseAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkGetLinearImageLayoutGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkGetLinearImageLayout2GOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkGetLinearImageLayout2GOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueFlushCommandsGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueFlushCommandsGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueCommitDescriptorSetUpdatesGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueCommitDescriptorSetUpdatesGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkCollectDescriptorPoolIdsGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkCollectDescriptorPoolIdsGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueFlushCommandsFromAuxMemoryGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueFlushCommandsFromAuxMemoryGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkGetBlobGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkGetBlobGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSized2GOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplateSized2GOOGLE
- : nullptr;
- }
- if (!strcmp(name, "vkQueueSubmitAsync2GOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueSubmitAsync2GOOGLE : nullptr;
- }
-#endif
- return nullptr;
-}
-void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name) {
- auto resources = ResourceTracker::get();
- bool has1_1OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_1;
- bool has1_2OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_2;
- bool has1_3OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_3;
-#ifdef VK_VERSION_1_0
- if (!strcmp(name, "vkCreateInstance")) {
- return (void*)entry_vkCreateInstance;
- }
- if (!strcmp(name, "vkDestroyInstance")) {
- return (void*)entry_vkDestroyInstance;
- }
- if (!strcmp(name, "vkEnumeratePhysicalDevices")) {
- return (void*)entry_vkEnumeratePhysicalDevices;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures")) {
- return (void*)entry_vkGetPhysicalDeviceFeatures;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties")) {
- return (void*)entry_vkGetPhysicalDeviceFormatProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties")) {
- return (void*)entry_vkGetPhysicalDeviceImageFormatProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceProperties")) {
- return (void*)entry_vkGetPhysicalDeviceProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties")) {
- return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) {
- return (void*)entry_vkGetPhysicalDeviceMemoryProperties;
- }
- if (!strcmp(name, "vkGetInstanceProcAddr")) {
- return (void*)entry_vkGetInstanceProcAddr;
- }
- if (!strcmp(name, "vkGetDeviceProcAddr")) {
- return (void*)entry_vkGetDeviceProcAddr;
- }
- if (!strcmp(name, "vkCreateDevice")) {
- return (void*)entry_vkCreateDevice;
- }
- if (!strcmp(name, "vkDestroyDevice")) {
- return (void*)entry_vkDestroyDevice;
- }
- if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
- return (void*)entry_vkEnumerateInstanceExtensionProperties;
- }
- if (!strcmp(name, "vkEnumerateDeviceExtensionProperties")) {
- return (void*)entry_vkEnumerateDeviceExtensionProperties;
- }
- if (!strcmp(name, "vkEnumerateInstanceLayerProperties")) {
- return (void*)entry_vkEnumerateInstanceLayerProperties;
- }
- if (!strcmp(name, "vkEnumerateDeviceLayerProperties")) {
- return (void*)entry_vkEnumerateDeviceLayerProperties;
- }
- if (!strcmp(name, "vkGetDeviceQueue")) {
- return (void*)entry_vkGetDeviceQueue;
- }
- if (!strcmp(name, "vkQueueSubmit")) {
- return (void*)entry_vkQueueSubmit;
- }
- if (!strcmp(name, "vkQueueWaitIdle")) {
- return (void*)entry_vkQueueWaitIdle;
- }
- if (!strcmp(name, "vkDeviceWaitIdle")) {
- return (void*)entry_vkDeviceWaitIdle;
- }
- if (!strcmp(name, "vkAllocateMemory")) {
- return (void*)entry_vkAllocateMemory;
- }
- if (!strcmp(name, "vkFreeMemory")) {
- return (void*)entry_vkFreeMemory;
- }
- if (!strcmp(name, "vkMapMemory")) {
- return (void*)entry_vkMapMemory;
- }
- if (!strcmp(name, "vkUnmapMemory")) {
- return (void*)entry_vkUnmapMemory;
- }
- if (!strcmp(name, "vkFlushMappedMemoryRanges")) {
- return (void*)entry_vkFlushMappedMemoryRanges;
- }
- if (!strcmp(name, "vkInvalidateMappedMemoryRanges")) {
- return (void*)entry_vkInvalidateMappedMemoryRanges;
- }
- if (!strcmp(name, "vkGetDeviceMemoryCommitment")) {
- return (void*)entry_vkGetDeviceMemoryCommitment;
- }
- if (!strcmp(name, "vkBindBufferMemory")) {
- return (void*)entry_vkBindBufferMemory;
- }
- if (!strcmp(name, "vkBindImageMemory")) {
- return (void*)entry_vkBindImageMemory;
- }
- if (!strcmp(name, "vkGetBufferMemoryRequirements")) {
- return (void*)entry_vkGetBufferMemoryRequirements;
- }
- if (!strcmp(name, "vkGetImageMemoryRequirements")) {
- return (void*)entry_vkGetImageMemoryRequirements;
- }
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements")) {
- return (void*)entry_vkGetImageSparseMemoryRequirements;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties")) {
- return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties;
- }
- if (!strcmp(name, "vkQueueBindSparse")) {
- return (void*)entry_vkQueueBindSparse;
- }
- if (!strcmp(name, "vkCreateFence")) {
- return (void*)entry_vkCreateFence;
- }
- if (!strcmp(name, "vkDestroyFence")) {
- return (void*)entry_vkDestroyFence;
- }
- if (!strcmp(name, "vkResetFences")) {
- return (void*)entry_vkResetFences;
- }
- if (!strcmp(name, "vkGetFenceStatus")) {
- return (void*)entry_vkGetFenceStatus;
- }
- if (!strcmp(name, "vkWaitForFences")) {
- return (void*)entry_vkWaitForFences;
- }
- if (!strcmp(name, "vkCreateSemaphore")) {
- return (void*)entry_vkCreateSemaphore;
- }
- if (!strcmp(name, "vkDestroySemaphore")) {
- return (void*)entry_vkDestroySemaphore;
- }
- if (!strcmp(name, "vkCreateEvent")) {
- return (void*)entry_vkCreateEvent;
- }
- if (!strcmp(name, "vkDestroyEvent")) {
- return (void*)entry_vkDestroyEvent;
- }
- if (!strcmp(name, "vkGetEventStatus")) {
- return (void*)entry_vkGetEventStatus;
- }
- if (!strcmp(name, "vkSetEvent")) {
- return (void*)entry_vkSetEvent;
- }
- if (!strcmp(name, "vkResetEvent")) {
- return (void*)entry_vkResetEvent;
- }
- if (!strcmp(name, "vkCreateQueryPool")) {
- return (void*)entry_vkCreateQueryPool;
- }
- if (!strcmp(name, "vkDestroyQueryPool")) {
- return (void*)entry_vkDestroyQueryPool;
- }
- if (!strcmp(name, "vkGetQueryPoolResults")) {
- return (void*)entry_vkGetQueryPoolResults;
- }
- if (!strcmp(name, "vkCreateBuffer")) {
- return (void*)entry_vkCreateBuffer;
- }
- if (!strcmp(name, "vkDestroyBuffer")) {
- return (void*)entry_vkDestroyBuffer;
- }
- if (!strcmp(name, "vkCreateBufferView")) {
- return (void*)entry_vkCreateBufferView;
- }
- if (!strcmp(name, "vkDestroyBufferView")) {
- return (void*)entry_vkDestroyBufferView;
- }
- if (!strcmp(name, "vkCreateImage")) {
- return (void*)entry_vkCreateImage;
- }
- if (!strcmp(name, "vkDestroyImage")) {
- return (void*)entry_vkDestroyImage;
- }
- if (!strcmp(name, "vkGetImageSubresourceLayout")) {
- return (void*)entry_vkGetImageSubresourceLayout;
- }
- if (!strcmp(name, "vkCreateImageView")) {
- return (void*)entry_vkCreateImageView;
- }
- if (!strcmp(name, "vkDestroyImageView")) {
- return (void*)entry_vkDestroyImageView;
- }
- if (!strcmp(name, "vkCreateShaderModule")) {
- return (void*)entry_vkCreateShaderModule;
- }
- if (!strcmp(name, "vkDestroyShaderModule")) {
- return (void*)entry_vkDestroyShaderModule;
- }
- if (!strcmp(name, "vkCreatePipelineCache")) {
- return (void*)entry_vkCreatePipelineCache;
- }
- if (!strcmp(name, "vkDestroyPipelineCache")) {
- return (void*)entry_vkDestroyPipelineCache;
- }
- if (!strcmp(name, "vkGetPipelineCacheData")) {
- return (void*)entry_vkGetPipelineCacheData;
- }
- if (!strcmp(name, "vkMergePipelineCaches")) {
- return (void*)entry_vkMergePipelineCaches;
- }
- if (!strcmp(name, "vkCreateGraphicsPipelines")) {
- return (void*)entry_vkCreateGraphicsPipelines;
- }
- if (!strcmp(name, "vkCreateComputePipelines")) {
- return (void*)entry_vkCreateComputePipelines;
- }
- if (!strcmp(name, "vkDestroyPipeline")) {
- return (void*)entry_vkDestroyPipeline;
- }
- if (!strcmp(name, "vkCreatePipelineLayout")) {
- return (void*)entry_vkCreatePipelineLayout;
- }
- if (!strcmp(name, "vkDestroyPipelineLayout")) {
- return (void*)entry_vkDestroyPipelineLayout;
- }
- if (!strcmp(name, "vkCreateSampler")) {
- return (void*)entry_vkCreateSampler;
- }
- if (!strcmp(name, "vkDestroySampler")) {
- return (void*)entry_vkDestroySampler;
- }
- if (!strcmp(name, "vkCreateDescriptorSetLayout")) {
- return (void*)entry_vkCreateDescriptorSetLayout;
- }
- if (!strcmp(name, "vkDestroyDescriptorSetLayout")) {
- return (void*)entry_vkDestroyDescriptorSetLayout;
- }
- if (!strcmp(name, "vkCreateDescriptorPool")) {
- return (void*)entry_vkCreateDescriptorPool;
- }
- if (!strcmp(name, "vkDestroyDescriptorPool")) {
- return (void*)entry_vkDestroyDescriptorPool;
- }
- if (!strcmp(name, "vkResetDescriptorPool")) {
- return (void*)entry_vkResetDescriptorPool;
- }
- if (!strcmp(name, "vkAllocateDescriptorSets")) {
- return (void*)entry_vkAllocateDescriptorSets;
- }
- if (!strcmp(name, "vkFreeDescriptorSets")) {
- return (void*)entry_vkFreeDescriptorSets;
- }
- if (!strcmp(name, "vkUpdateDescriptorSets")) {
- return (void*)entry_vkUpdateDescriptorSets;
- }
- if (!strcmp(name, "vkCreateFramebuffer")) {
- return (void*)entry_vkCreateFramebuffer;
- }
- if (!strcmp(name, "vkDestroyFramebuffer")) {
- return (void*)entry_vkDestroyFramebuffer;
- }
- if (!strcmp(name, "vkCreateRenderPass")) {
- return (void*)entry_vkCreateRenderPass;
- }
- if (!strcmp(name, "vkDestroyRenderPass")) {
- return (void*)entry_vkDestroyRenderPass;
- }
- if (!strcmp(name, "vkGetRenderAreaGranularity")) {
- return (void*)entry_vkGetRenderAreaGranularity;
- }
- if (!strcmp(name, "vkCreateCommandPool")) {
- return (void*)entry_vkCreateCommandPool;
- }
- if (!strcmp(name, "vkDestroyCommandPool")) {
- return (void*)entry_vkDestroyCommandPool;
- }
- if (!strcmp(name, "vkResetCommandPool")) {
- return (void*)entry_vkResetCommandPool;
- }
- if (!strcmp(name, "vkAllocateCommandBuffers")) {
- return (void*)entry_vkAllocateCommandBuffers;
- }
- if (!strcmp(name, "vkFreeCommandBuffers")) {
- return (void*)entry_vkFreeCommandBuffers;
- }
- if (!strcmp(name, "vkBeginCommandBuffer")) {
- return (void*)entry_vkBeginCommandBuffer;
- }
- if (!strcmp(name, "vkEndCommandBuffer")) {
- return (void*)entry_vkEndCommandBuffer;
- }
- if (!strcmp(name, "vkResetCommandBuffer")) {
- return (void*)entry_vkResetCommandBuffer;
- }
- if (!strcmp(name, "vkCmdBindPipeline")) {
- return (void*)entry_vkCmdBindPipeline;
- }
- if (!strcmp(name, "vkCmdSetViewport")) {
- return (void*)entry_vkCmdSetViewport;
- }
- if (!strcmp(name, "vkCmdSetScissor")) {
- return (void*)entry_vkCmdSetScissor;
- }
- if (!strcmp(name, "vkCmdSetLineWidth")) {
- return (void*)entry_vkCmdSetLineWidth;
- }
- if (!strcmp(name, "vkCmdSetDepthBias")) {
- return (void*)entry_vkCmdSetDepthBias;
- }
- if (!strcmp(name, "vkCmdSetBlendConstants")) {
- return (void*)entry_vkCmdSetBlendConstants;
- }
- if (!strcmp(name, "vkCmdSetDepthBounds")) {
- return (void*)entry_vkCmdSetDepthBounds;
- }
- if (!strcmp(name, "vkCmdSetStencilCompareMask")) {
- return (void*)entry_vkCmdSetStencilCompareMask;
- }
- if (!strcmp(name, "vkCmdSetStencilWriteMask")) {
- return (void*)entry_vkCmdSetStencilWriteMask;
- }
- if (!strcmp(name, "vkCmdSetStencilReference")) {
- return (void*)entry_vkCmdSetStencilReference;
- }
- if (!strcmp(name, "vkCmdBindDescriptorSets")) {
- return (void*)entry_vkCmdBindDescriptorSets;
- }
- if (!strcmp(name, "vkCmdBindIndexBuffer")) {
- return (void*)entry_vkCmdBindIndexBuffer;
- }
- if (!strcmp(name, "vkCmdBindVertexBuffers")) {
- return (void*)entry_vkCmdBindVertexBuffers;
- }
- if (!strcmp(name, "vkCmdDraw")) {
- return (void*)entry_vkCmdDraw;
- }
- if (!strcmp(name, "vkCmdDrawIndexed")) {
- return (void*)entry_vkCmdDrawIndexed;
- }
- if (!strcmp(name, "vkCmdDrawIndirect")) {
- return (void*)entry_vkCmdDrawIndirect;
- }
- if (!strcmp(name, "vkCmdDrawIndexedIndirect")) {
- return (void*)entry_vkCmdDrawIndexedIndirect;
- }
- if (!strcmp(name, "vkCmdDispatch")) {
- return (void*)entry_vkCmdDispatch;
- }
- if (!strcmp(name, "vkCmdDispatchIndirect")) {
- return (void*)entry_vkCmdDispatchIndirect;
- }
- if (!strcmp(name, "vkCmdCopyBuffer")) {
- return (void*)entry_vkCmdCopyBuffer;
- }
- if (!strcmp(name, "vkCmdCopyImage")) {
- return (void*)entry_vkCmdCopyImage;
- }
- if (!strcmp(name, "vkCmdBlitImage")) {
- return (void*)entry_vkCmdBlitImage;
- }
- if (!strcmp(name, "vkCmdCopyBufferToImage")) {
- return (void*)entry_vkCmdCopyBufferToImage;
- }
- if (!strcmp(name, "vkCmdCopyImageToBuffer")) {
- return (void*)entry_vkCmdCopyImageToBuffer;
- }
- if (!strcmp(name, "vkCmdUpdateBuffer")) {
- return (void*)entry_vkCmdUpdateBuffer;
- }
- if (!strcmp(name, "vkCmdFillBuffer")) {
- return (void*)entry_vkCmdFillBuffer;
- }
- if (!strcmp(name, "vkCmdClearColorImage")) {
- return (void*)entry_vkCmdClearColorImage;
- }
- if (!strcmp(name, "vkCmdClearDepthStencilImage")) {
- return (void*)entry_vkCmdClearDepthStencilImage;
- }
- if (!strcmp(name, "vkCmdClearAttachments")) {
- return (void*)entry_vkCmdClearAttachments;
- }
- if (!strcmp(name, "vkCmdResolveImage")) {
- return (void*)entry_vkCmdResolveImage;
- }
- if (!strcmp(name, "vkCmdSetEvent")) {
- return (void*)entry_vkCmdSetEvent;
- }
- if (!strcmp(name, "vkCmdResetEvent")) {
- return (void*)entry_vkCmdResetEvent;
- }
- if (!strcmp(name, "vkCmdWaitEvents")) {
- return (void*)entry_vkCmdWaitEvents;
- }
- if (!strcmp(name, "vkCmdPipelineBarrier")) {
- return (void*)entry_vkCmdPipelineBarrier;
- }
- if (!strcmp(name, "vkCmdBeginQuery")) {
- return (void*)entry_vkCmdBeginQuery;
- }
- if (!strcmp(name, "vkCmdEndQuery")) {
- return (void*)entry_vkCmdEndQuery;
- }
- if (!strcmp(name, "vkCmdResetQueryPool")) {
- return (void*)entry_vkCmdResetQueryPool;
- }
- if (!strcmp(name, "vkCmdWriteTimestamp")) {
- return (void*)entry_vkCmdWriteTimestamp;
- }
- if (!strcmp(name, "vkCmdCopyQueryPoolResults")) {
- return (void*)entry_vkCmdCopyQueryPoolResults;
- }
- if (!strcmp(name, "vkCmdPushConstants")) {
- return (void*)entry_vkCmdPushConstants;
- }
- if (!strcmp(name, "vkCmdBeginRenderPass")) {
- return (void*)entry_vkCmdBeginRenderPass;
- }
- if (!strcmp(name, "vkCmdNextSubpass")) {
- return (void*)entry_vkCmdNextSubpass;
- }
- if (!strcmp(name, "vkCmdEndRenderPass")) {
- return (void*)entry_vkCmdEndRenderPass;
- }
- if (!strcmp(name, "vkCmdExecuteCommands")) {
- return (void*)entry_vkCmdExecuteCommands;
- }
-#endif
-#ifdef VK_VERSION_1_1
- if (!strcmp(name, "vkEnumerateInstanceVersion")) {
- return has1_1OrHigher ? (void*)entry_vkEnumerateInstanceVersion : nullptr;
- }
- if (!strcmp(name, "vkBindBufferMemory2")) {
- return has1_1OrHigher ? (void*)entry_vkBindBufferMemory2 : nullptr;
- }
- if (!strcmp(name, "vkBindImageMemory2")) {
- return has1_1OrHigher ? (void*)entry_vkBindImageMemory2 : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures")) {
- return has1_1OrHigher ? (void*)entry_vkGetDeviceGroupPeerMemoryFeatures : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDeviceMask")) {
- return has1_1OrHigher ? (void*)entry_vkCmdSetDeviceMask : nullptr;
- }
- if (!strcmp(name, "vkCmdDispatchBase")) {
- return has1_1OrHigher ? (void*)entry_vkCmdDispatchBase : nullptr;
- }
- if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups")) {
- return nullptr;
- }
- if (!strcmp(name, "vkGetImageMemoryRequirements2")) {
- return has1_1OrHigher ? (void*)entry_vkGetImageMemoryRequirements2 : nullptr;
- }
- if (!strcmp(name, "vkGetBufferMemoryRequirements2")) {
- return has1_1OrHigher ? (void*)entry_vkGetBufferMemoryRequirements2 : nullptr;
- }
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements2")) {
- return has1_1OrHigher ? (void*)entry_vkGetImageSparseMemoryRequirements2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFeatures2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFormatProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2 : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2
- : nullptr;
- }
- if (!strcmp(name, "vkTrimCommandPool")) {
- return has1_1OrHigher ? (void*)entry_vkTrimCommandPool : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceQueue2")) {
- return has1_1OrHigher ? (void*)entry_vkGetDeviceQueue2 : nullptr;
- }
- if (!strcmp(name, "vkCreateSamplerYcbcrConversion")) {
- return has1_1OrHigher ? (void*)entry_vkCreateSamplerYcbcrConversion : nullptr;
- }
- if (!strcmp(name, "vkDestroySamplerYcbcrConversion")) {
- return has1_1OrHigher ? (void*)entry_vkDestroySamplerYcbcrConversion : nullptr;
- }
- if (!strcmp(name, "vkCreateDescriptorUpdateTemplate")) {
- return has1_1OrHigher ? (void*)entry_vkCreateDescriptorUpdateTemplate : nullptr;
- }
- if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate")) {
- return has1_1OrHigher ? (void*)entry_vkDestroyDescriptorUpdateTemplate : nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate")) {
- return has1_1OrHigher ? (void*)entry_vkUpdateDescriptorSetWithTemplate : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalBufferProperties : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalFenceProperties : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties")) {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalSemaphoreProperties
- : nullptr;
- }
- if (!strcmp(name, "vkGetDescriptorSetLayoutSupport")) {
- return has1_1OrHigher ? (void*)entry_vkGetDescriptorSetLayoutSupport : nullptr;
- }
-#endif
-#ifdef VK_VERSION_1_2
- if (!strcmp(name, "vkCmdDrawIndirectCount")) {
- return has1_2OrHigher ? (void*)entry_vkCmdDrawIndirectCount : nullptr;
- }
- if (!strcmp(name, "vkCmdDrawIndexedIndirectCount")) {
- return has1_2OrHigher ? (void*)entry_vkCmdDrawIndexedIndirectCount : nullptr;
- }
- if (!strcmp(name, "vkCreateRenderPass2")) {
- return has1_2OrHigher ? (void*)entry_vkCreateRenderPass2 : nullptr;
- }
- if (!strcmp(name, "vkCmdBeginRenderPass2")) {
- return has1_2OrHigher ? (void*)entry_vkCmdBeginRenderPass2 : nullptr;
- }
- if (!strcmp(name, "vkCmdNextSubpass2")) {
- return has1_2OrHigher ? (void*)entry_vkCmdNextSubpass2 : nullptr;
- }
- if (!strcmp(name, "vkCmdEndRenderPass2")) {
- return has1_2OrHigher ? (void*)entry_vkCmdEndRenderPass2 : nullptr;
- }
- if (!strcmp(name, "vkResetQueryPool")) {
- return has1_2OrHigher ? (void*)entry_vkResetQueryPool : nullptr;
- }
- if (!strcmp(name, "vkGetSemaphoreCounterValue")) {
- return has1_2OrHigher ? (void*)entry_vkGetSemaphoreCounterValue : nullptr;
- }
- if (!strcmp(name, "vkWaitSemaphores")) {
- return has1_2OrHigher ? (void*)entry_vkWaitSemaphores : nullptr;
- }
- if (!strcmp(name, "vkSignalSemaphore")) {
- return has1_2OrHigher ? (void*)entry_vkSignalSemaphore : nullptr;
- }
- if (!strcmp(name, "vkGetBufferDeviceAddress")) {
- return has1_2OrHigher ? (void*)entry_vkGetBufferDeviceAddress : nullptr;
- }
- if (!strcmp(name, "vkGetBufferOpaqueCaptureAddress")) {
- return has1_2OrHigher ? (void*)entry_vkGetBufferOpaqueCaptureAddress : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddress")) {
- return has1_2OrHigher ? (void*)entry_vkGetDeviceMemoryOpaqueCaptureAddress : nullptr;
- }
-#endif
-#ifdef VK_VERSION_1_3
- if (!strcmp(name, "vkGetPhysicalDeviceToolProperties")) {
- return has1_3OrHigher ? (void*)entry_vkGetPhysicalDeviceToolProperties : nullptr;
- }
- if (!strcmp(name, "vkCreatePrivateDataSlot")) {
- return has1_3OrHigher ? (void*)entry_vkCreatePrivateDataSlot : nullptr;
- }
- if (!strcmp(name, "vkDestroyPrivateDataSlot")) {
- return has1_3OrHigher ? (void*)entry_vkDestroyPrivateDataSlot : nullptr;
- }
- if (!strcmp(name, "vkSetPrivateData")) {
- return has1_3OrHigher ? (void*)entry_vkSetPrivateData : nullptr;
- }
- if (!strcmp(name, "vkGetPrivateData")) {
- return has1_3OrHigher ? (void*)entry_vkGetPrivateData : nullptr;
- }
- if (!strcmp(name, "vkCmdSetEvent2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetEvent2 : nullptr;
- }
- if (!strcmp(name, "vkCmdResetEvent2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdResetEvent2 : nullptr;
- }
- if (!strcmp(name, "vkCmdWaitEvents2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdWaitEvents2 : nullptr;
- }
- if (!strcmp(name, "vkCmdPipelineBarrier2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdPipelineBarrier2 : nullptr;
- }
- if (!strcmp(name, "vkCmdWriteTimestamp2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdWriteTimestamp2 : nullptr;
- }
- if (!strcmp(name, "vkQueueSubmit2")) {
- return has1_3OrHigher ? (void*)entry_vkQueueSubmit2 : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyBuffer2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdCopyBuffer2 : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImage2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdCopyImage2 : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyBufferToImage2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdCopyBufferToImage2 : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImageToBuffer2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdCopyImageToBuffer2 : nullptr;
- }
- if (!strcmp(name, "vkCmdBlitImage2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdBlitImage2 : nullptr;
- }
- if (!strcmp(name, "vkCmdResolveImage2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdResolveImage2 : nullptr;
- }
- if (!strcmp(name, "vkCmdBeginRendering")) {
- return has1_3OrHigher ? (void*)entry_vkCmdBeginRendering : nullptr;
- }
- if (!strcmp(name, "vkCmdEndRendering")) {
- return has1_3OrHigher ? (void*)entry_vkCmdEndRendering : nullptr;
- }
- if (!strcmp(name, "vkCmdSetCullMode")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetCullMode : nullptr;
- }
- if (!strcmp(name, "vkCmdSetFrontFace")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetFrontFace : nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveTopology")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetPrimitiveTopology : nullptr;
- }
- if (!strcmp(name, "vkCmdSetViewportWithCount")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetViewportWithCount : nullptr;
- }
- if (!strcmp(name, "vkCmdSetScissorWithCount")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetScissorWithCount : nullptr;
- }
- if (!strcmp(name, "vkCmdBindVertexBuffers2")) {
- return has1_3OrHigher ? (void*)entry_vkCmdBindVertexBuffers2 : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthTestEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthTestEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthWriteEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthWriteEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthCompareOp")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthCompareOp : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBoundsTestEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthBoundsTestEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilTestEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetStencilTestEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilOp")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetStencilOp : nullptr;
- }
- if (!strcmp(name, "vkCmdSetRasterizerDiscardEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetRasterizerDiscardEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBiasEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetDepthBiasEnable : nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveRestartEnable")) {
- return has1_3OrHigher ? (void*)entry_vkCmdSetPrimitiveRestartEnable : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceBufferMemoryRequirements")) {
- return has1_3OrHigher ? (void*)entry_vkGetDeviceBufferMemoryRequirements : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageMemoryRequirements")) {
- return has1_3OrHigher ? (void*)entry_vkGetDeviceImageMemoryRequirements : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirements")) {
- return has1_3OrHigher ? (void*)entry_vkGetDeviceImageSparseMemoryRequirements : nullptr;
- }
-#endif
-#ifdef VK_KHR_android_surface
- if (!strcmp(name, "vkCreateAndroidSurfaceKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_android_surface");
- return hasExt ? (void*)entry_vkCreateAndroidSurfaceKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_dynamic_rendering
- if (!strcmp(name, "vkCmdBeginRenderingKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering");
- return hasExt ? (void*)entry_vkCmdBeginRenderingKHR : nullptr;
- }
- if (!strcmp(name, "vkCmdEndRenderingKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering");
- return hasExt ? (void*)entry_vkCmdEndRenderingKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_get_physical_device_properties2
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceFeatures2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceFormatProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_maintenance1
- if (!strcmp(name, "vkTrimCommandPoolKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance1");
- return hasExt ? (void*)entry_vkTrimCommandPoolKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_external_memory_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_memory_capabilities");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_external_semaphore_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_capabilities");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_external_semaphore_fd
- if (!strcmp(name, "vkImportSemaphoreFdKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd");
- return hasExt ? (void*)entry_vkImportSemaphoreFdKHR : nullptr;
- }
- if (!strcmp(name, "vkGetSemaphoreFdKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd");
- return hasExt ? (void*)entry_vkGetSemaphoreFdKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_descriptor_update_template
- if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template");
- return hasExt ? (void*)entry_vkCreateDescriptorUpdateTemplateKHR : nullptr;
- }
- if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template");
- return hasExt ? (void*)entry_vkDestroyDescriptorUpdateTemplateKHR : nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template");
- return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_create_renderpass2
- if (!strcmp(name, "vkCreateRenderPass2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
- return hasExt ? (void*)entry_vkCreateRenderPass2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdBeginRenderPass2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
- return hasExt ? (void*)entry_vkCmdBeginRenderPass2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdNextSubpass2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
- return hasExt ? (void*)entry_vkCmdNextSubpass2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdEndRenderPass2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
- return hasExt ? (void*)entry_vkCmdEndRenderPass2KHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_external_fence_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_capabilities");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalFencePropertiesKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_external_fence_fd
- if (!strcmp(name, "vkImportFenceFdKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd");
- return hasExt ? (void*)entry_vkImportFenceFdKHR : nullptr;
- }
- if (!strcmp(name, "vkGetFenceFdKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd");
- return hasExt ? (void*)entry_vkGetFenceFdKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_get_memory_requirements2
- if (!strcmp(name, "vkGetImageMemoryRequirements2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2");
- return hasExt ? (void*)entry_vkGetImageMemoryRequirements2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2");
- return hasExt ? (void*)entry_vkGetBufferMemoryRequirements2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2");
- return hasExt ? (void*)entry_vkGetImageSparseMemoryRequirements2KHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_sampler_ycbcr_conversion
- if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion");
- return hasExt ? (void*)entry_vkCreateSamplerYcbcrConversionKHR : nullptr;
- }
- if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion");
- return hasExt ? (void*)entry_vkDestroySamplerYcbcrConversionKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_bind_memory2
- if (!strcmp(name, "vkBindBufferMemory2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_bind_memory2");
- return hasExt ? (void*)entry_vkBindBufferMemory2KHR : nullptr;
- }
- if (!strcmp(name, "vkBindImageMemory2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_bind_memory2");
- return hasExt ? (void*)entry_vkBindImageMemory2KHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_maintenance3
- if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance3");
- return hasExt ? (void*)entry_vkGetDescriptorSetLayoutSupportKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_buffer_device_address
- if (!strcmp(name, "vkGetBufferDeviceAddressKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address");
- return hasExt ? (void*)entry_vkGetBufferDeviceAddressKHR : nullptr;
- }
- if (!strcmp(name, "vkGetBufferOpaqueCaptureAddressKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address");
- return hasExt ? (void*)entry_vkGetBufferOpaqueCaptureAddressKHR : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address");
- return hasExt ? (void*)entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_pipeline_executable_properties
- if (!strcmp(name, "vkGetPipelineExecutablePropertiesKHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties");
- return hasExt ? (void*)entry_vkGetPipelineExecutablePropertiesKHR : nullptr;
- }
- if (!strcmp(name, "vkGetPipelineExecutableStatisticsKHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties");
- return hasExt ? (void*)entry_vkGetPipelineExecutableStatisticsKHR : nullptr;
- }
- if (!strcmp(name, "vkGetPipelineExecutableInternalRepresentationsKHR")) {
- bool hasExt =
- resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties");
- return hasExt ? (void*)entry_vkGetPipelineExecutableInternalRepresentationsKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_synchronization2
- if (!strcmp(name, "vkCmdSetEvent2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
- return hasExt ? (void*)entry_vkCmdSetEvent2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdResetEvent2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
- return hasExt ? (void*)entry_vkCmdResetEvent2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdWaitEvents2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
- return hasExt ? (void*)entry_vkCmdWaitEvents2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdPipelineBarrier2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
- return hasExt ? (void*)entry_vkCmdPipelineBarrier2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdWriteTimestamp2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
- return hasExt ? (void*)entry_vkCmdWriteTimestamp2KHR : nullptr;
- }
- if (!strcmp(name, "vkQueueSubmit2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
- return hasExt ? (void*)entry_vkQueueSubmit2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdWriteBufferMarker2AMD")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
- return hasExt ? (void*)entry_vkCmdWriteBufferMarker2AMD : nullptr;
- }
- if (!strcmp(name, "vkGetQueueCheckpointData2NV")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
- return hasExt ? (void*)entry_vkGetQueueCheckpointData2NV : nullptr;
- }
-#endif
-#ifdef VK_KHR_copy_commands2
- if (!strcmp(name, "vkCmdCopyBuffer2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
- return hasExt ? (void*)entry_vkCmdCopyBuffer2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImage2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
- return hasExt ? (void*)entry_vkCmdCopyImage2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyBufferToImage2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
- return hasExt ? (void*)entry_vkCmdCopyBufferToImage2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdCopyImageToBuffer2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
- return hasExt ? (void*)entry_vkCmdCopyImageToBuffer2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdBlitImage2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
- return hasExt ? (void*)entry_vkCmdBlitImage2KHR : nullptr;
- }
- if (!strcmp(name, "vkCmdResolveImage2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
- return hasExt ? (void*)entry_vkCmdResolveImage2KHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_maintenance4
- if (!strcmp(name, "vkGetDeviceBufferMemoryRequirementsKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance4");
- return hasExt ? (void*)entry_vkGetDeviceBufferMemoryRequirementsKHR : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageMemoryRequirementsKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance4");
- return hasExt ? (void*)entry_vkGetDeviceImageMemoryRequirementsKHR : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirementsKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance4");
- return hasExt ? (void*)entry_vkGetDeviceImageSparseMemoryRequirementsKHR : nullptr;
- }
-#endif
-#ifdef VK_KHR_maintenance5
- if (!strcmp(name, "vkCmdBindIndexBuffer2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance5");
- return hasExt ? (void*)entry_vkCmdBindIndexBuffer2KHR : nullptr;
- }
- if (!strcmp(name, "vkGetRenderingAreaGranularityKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance5");
- return hasExt ? (void*)entry_vkGetRenderingAreaGranularityKHR : nullptr;
- }
- if (!strcmp(name, "vkGetDeviceImageSubresourceLayoutKHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance5");
- return hasExt ? (void*)entry_vkGetDeviceImageSubresourceLayoutKHR : nullptr;
- }
- if (!strcmp(name, "vkGetImageSubresourceLayout2KHR")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance5");
- return hasExt ? (void*)entry_vkGetImageSubresourceLayout2KHR : nullptr;
- }
-#endif
-#ifdef VK_ANDROID_native_buffer
- if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
- return hasExt ? (void*)entry_vkGetSwapchainGrallocUsageANDROID : nullptr;
- }
- if (!strcmp(name, "vkAcquireImageANDROID")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
- return hasExt ? (void*)entry_vkAcquireImageANDROID : nullptr;
- }
- if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
- return hasExt ? (void*)entry_vkQueueSignalReleaseImageANDROID : nullptr;
- }
- if (!strcmp(name, "vkGetSwapchainGrallocUsage2ANDROID")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
- return hasExt ? (void*)entry_vkGetSwapchainGrallocUsage2ANDROID : nullptr;
- }
-#endif
-#ifdef VK_EXT_transform_feedback
- if (!strcmp(name, "vkCmdBindTransformFeedbackBuffersEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
- return hasExt ? (void*)entry_vkCmdBindTransformFeedbackBuffersEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdBeginTransformFeedbackEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
- return hasExt ? (void*)entry_vkCmdBeginTransformFeedbackEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdEndTransformFeedbackEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
- return hasExt ? (void*)entry_vkCmdEndTransformFeedbackEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdBeginQueryIndexedEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
- return hasExt ? (void*)entry_vkCmdBeginQueryIndexedEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdEndQueryIndexedEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
- return hasExt ? (void*)entry_vkCmdEndQueryIndexedEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdDrawIndirectByteCountEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
- return hasExt ? (void*)entry_vkCmdDrawIndirectByteCountEXT : nullptr;
- }
-#endif
-#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID")) {
- bool hasExt = resources->hasDeviceExtension(
- device, "VK_ANDROID_external_memory_android_hardware_buffer");
- return hasExt ? (void*)entry_vkGetAndroidHardwareBufferPropertiesANDROID : nullptr;
- }
- if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID")) {
- bool hasExt = resources->hasDeviceExtension(
- device, "VK_ANDROID_external_memory_android_hardware_buffer");
- return hasExt ? (void*)entry_vkGetMemoryAndroidHardwareBufferANDROID : nullptr;
- }
-#endif
-#ifdef VK_EXT_tooling_info
- if (!strcmp(name, "vkGetPhysicalDeviceToolPropertiesEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_tooling_info");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceToolPropertiesEXT : nullptr;
- }
-#endif
-#ifdef VK_EXT_line_rasterization
- if (!strcmp(name, "vkCmdSetLineStippleEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_line_rasterization");
- return hasExt ? (void*)entry_vkCmdSetLineStippleEXT : nullptr;
- }
-#endif
-#ifdef VK_EXT_extended_dynamic_state
- if (!strcmp(name, "vkCmdSetCullModeEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetCullModeEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetFrontFaceEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetFrontFaceEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveTopologyEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetPrimitiveTopologyEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetViewportWithCountEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetViewportWithCountEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetScissorWithCountEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetScissorWithCountEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdBindVertexBuffers2EXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdBindVertexBuffers2EXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthTestEnableEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetDepthTestEnableEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthWriteEnableEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetDepthWriteEnableEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthCompareOpEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetDepthCompareOpEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBoundsTestEnableEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetDepthBoundsTestEnableEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilTestEnableEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetStencilTestEnableEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetStencilOpEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
- return hasExt ? (void*)entry_vkCmdSetStencilOpEXT : nullptr;
- }
-#endif
-#ifdef VK_EXT_host_image_copy
- if (!strcmp(name, "vkCopyMemoryToImageEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
- return hasExt ? (void*)entry_vkCopyMemoryToImageEXT : nullptr;
- }
- if (!strcmp(name, "vkCopyImageToMemoryEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
- return hasExt ? (void*)entry_vkCopyImageToMemoryEXT : nullptr;
- }
- if (!strcmp(name, "vkCopyImageToImageEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
- return hasExt ? (void*)entry_vkCopyImageToImageEXT : nullptr;
- }
- if (!strcmp(name, "vkTransitionImageLayoutEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
- return hasExt ? (void*)entry_vkTransitionImageLayoutEXT : nullptr;
- }
- if (!strcmp(name, "vkGetImageSubresourceLayout2EXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
- return hasExt ? (void*)entry_vkGetImageSubresourceLayout2EXT : nullptr;
- }
-#endif
-#ifdef VK_EXT_private_data
- if (!strcmp(name, "vkCreatePrivateDataSlotEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
- return hasExt ? (void*)entry_vkCreatePrivateDataSlotEXT : nullptr;
- }
- if (!strcmp(name, "vkDestroyPrivateDataSlotEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
- return hasExt ? (void*)entry_vkDestroyPrivateDataSlotEXT : nullptr;
- }
- if (!strcmp(name, "vkSetPrivateDataEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
- return hasExt ? (void*)entry_vkSetPrivateDataEXT : nullptr;
- }
- if (!strcmp(name, "vkGetPrivateDataEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
- return hasExt ? (void*)entry_vkGetPrivateDataEXT : nullptr;
- }
-#endif
-#ifdef VK_EXT_extended_dynamic_state2
- if (!strcmp(name, "vkCmdSetPatchControlPointsEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
- return hasExt ? (void*)entry_vkCmdSetPatchControlPointsEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetRasterizerDiscardEnableEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
- return hasExt ? (void*)entry_vkCmdSetRasterizerDiscardEnableEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetDepthBiasEnableEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
- return hasExt ? (void*)entry_vkCmdSetDepthBiasEnableEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetLogicOpEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
- return hasExt ? (void*)entry_vkCmdSetLogicOpEXT : nullptr;
- }
- if (!strcmp(name, "vkCmdSetPrimitiveRestartEnableEXT")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
- return hasExt ? (void*)entry_vkCmdSetPrimitiveRestartEnableEXT : nullptr;
- }
-#endif
-#ifdef VK_GOOGLE_gfxstream
- if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkMapMemoryIntoAddressSpaceGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkBeginCommandBufferAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkEndCommandBufferAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkResetCommandBufferAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkCommandBufferHostSyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkCreateImageWithRequirementsGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkCreateBufferWithRequirementsGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkGetMemoryHostAddressInfoGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkGetMemoryHostAddressInfoGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkFreeMemorySyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkFreeMemorySyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueHostSyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueHostSyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueSubmitAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueWaitIdleAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueBindSparseAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkGetLinearImageLayoutGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkGetLinearImageLayout2GOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkGetLinearImageLayout2GOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueFlushCommandsGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueFlushCommandsGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueCommitDescriptorSetUpdatesGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueCommitDescriptorSetUpdatesGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkCollectDescriptorPoolIdsGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkCollectDescriptorPoolIdsGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueFlushCommandsFromAuxMemoryGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueFlushCommandsFromAuxMemoryGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkGetBlobGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkGetBlobGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSized2GOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateSized2GOOGLE : nullptr;
- }
- if (!strcmp(name, "vkQueueSubmitAsync2GOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkQueueSubmitAsync2GOOGLE : nullptr;
- }
-#endif
- return nullptr;
-}
-
-} // namespace vk
-} // namespace gfxstream
diff --git a/guest/vulkan_enc/func_table.h b/guest/vulkan_enc/func_table.h
index 795853d..370a866 100644
--- a/guest/vulkan_enc/func_table.h
+++ b/guest/vulkan_enc/func_table.h
@@ -144,8 +144,6 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
-#ifdef VK_EXT_depth_clip_enable
-#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
@@ -166,16 +164,12 @@
#endif
#ifdef VK_EXT_metal_surface
#endif
-#ifdef VK_EXT_fragment_density_map
-#endif
#ifdef VK_EXT_scalar_block_layout
#endif
#ifdef VK_EXT_subgroup_size_control
#endif
#ifdef VK_EXT_tooling_info
#endif
-#ifdef VK_EXT_validation_features
-#endif
#ifdef VK_EXT_provoking_vertex
#endif
#ifdef VK_EXT_line_rasterization
@@ -194,8 +188,6 @@
#endif
#ifdef VK_EXT_device_memory_report
#endif
-#ifdef VK_EXT_robustness2
-#endif
#ifdef VK_EXT_custom_border_color
#endif
#ifdef VK_EXT_private_data
@@ -222,8 +214,6 @@
#endif
#ifdef VK_EXT_image_compression_control_swapchain
#endif
-#ifdef VK_QNX_external_memory_screen_buffer
-#endif
void* goldfish_vulkan_get_proc_address(const char* name);
void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char* name);
void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name);
diff --git a/guest/vulkan_enc/goldfish_vk_counting_guest.cpp b/guest/vulkan_enc/goldfish_vk_counting_guest.cpp
index 41864f0..36f36f2 100644
--- a/guest/vulkan_enc/goldfish_vk_counting_guest.cpp
+++ b/guest/vulkan_enc/goldfish_vk_counting_guest.cpp
@@ -32,6 +32,7 @@
#include "goldfish_vk_counting_guest.h"
+#include <cstdlib>
#include <cstring>
#include "goldfish_vk_extension_structs_guest.h"
diff --git a/guest/vulkan_enc/mesa_func_table.cpp b/guest/vulkan_enc/mesa_func_table.cpp
deleted file mode 100644
index 5a10648..0000000
--- a/guest/vulkan_enc/mesa_func_table.cpp
+++ /dev/null
@@ -1,6265 +0,0 @@
-// Copyright (C) 2018 The Android Open Source Project
-// Copyright (C) 2018 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Autogenerated module mesa_func_table
-//
-// (impl) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
-//
-// Please do not modify directly;
-// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
-// or directly from Python by defining:
-// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
-// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
-// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-//
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
-// $CEREAL_OUTPUT_DIR
-//
-
-#include <log/log.h>
-
-#include <cstring>
-
-#include "../OpenglSystemCommon/HostConnection.h"
-#include "ResourceTracker.h"
-#include "VkEncoder.h"
-#include "gfxstream_vk_entrypoints.h"
-#include "gfxstream_vk_private.h"
-#include "goldfish_vk_private_defs.h"
-
-// Stuff we are not going to use but if included,
-// will cause compile errors. These are Android Vulkan
-// required extensions, but the approach will be to
-// implement them completely on the guest side.
-#undef VK_KHR_android_surface
-#if defined(LINUX_GUEST_BUILD) || defined(__Fuchsia__)
-#undef VK_ANDROID_native_buffer
-#endif
-#ifdef VK_VERSION_1_0
-void gfxstream_vk_GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures* pFeatures) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFeatures(gfxstream_physicalDevice->internal_object, pFeatures,
- true /* do lock */);
- }
-}
-void gfxstream_vk_GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties* pFormatProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFormatProperties(gfxstream_physicalDevice->internal_object,
- format, pFormatProperties, true /* do lock */);
- }
-}
-VkResult gfxstream_vk_GetPhysicalDeviceImageFormatProperties(
- VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling,
- VkImageUsageFlags usage, VkImageCreateFlags flags,
- VkImageFormatProperties* pImageFormatProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties");
- VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkGetPhysicalDeviceImageFormatProperties_VkResult_return =
- vkEnc->vkGetPhysicalDeviceImageFormatProperties(
- gfxstream_physicalDevice->internal_object, format, type, tiling, usage, flags,
- pImageFormatProperties, true /* do lock */);
- }
- return vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
-}
-void gfxstream_vk_GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties* pProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceProperties(gfxstream_physicalDevice->internal_object, pProperties,
- true /* do lock */);
- }
-}
-void gfxstream_vk_GetPhysicalDeviceQueueFamilyProperties(
- VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
- VkQueueFamilyProperties* pQueueFamilyProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceQueueFamilyProperties(gfxstream_physicalDevice->internal_object,
- pQueueFamilyPropertyCount,
- pQueueFamilyProperties, true /* do lock */);
- }
-}
-void gfxstream_vk_GetPhysicalDeviceMemoryProperties(
- VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceMemoryProperties(gfxstream_physicalDevice->internal_object,
- pMemoryProperties, true /* do lock */);
- }
-}
-VkResult gfxstream_vk_EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkLayerProperties* pProperties) {
- AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties");
- VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnumerateDeviceLayerProperties_VkResult_return = vkEnc->vkEnumerateDeviceLayerProperties(
- gfxstream_physicalDevice->internal_object, pPropertyCount, pProperties,
- true /* do lock */);
- }
- return vkEnumerateDeviceLayerProperties_VkResult_return;
-}
-VkResult gfxstream_vk_QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits,
- VkFence fence) {
- AEMU_SCOPED_TRACE("vkQueueSubmit");
- VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
- VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
- {
- auto vkEnc =
- gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
- std::vector<VkSubmitInfo> internal_pSubmits(submitCount);
- std::vector<std::vector<VkSemaphore>> internal_VkSubmitInfo_pWaitSemaphores;
- std::vector<std::vector<VkCommandBuffer>> internal_VkSubmitInfo_pCommandBuffers;
- std::vector<std::vector<VkSemaphore>> internal_VkSubmitInfo_pSignalSemaphores;
- for (uint32_t i = 0; i < submitCount; ++i) {
- internal_pSubmits[i] = pSubmits[i];
- /* VkSubmitInfo::pWaitSemaphores */
- internal_VkSubmitInfo_pWaitSemaphores.push_back(std::vector<VkSemaphore>());
- internal_VkSubmitInfo_pWaitSemaphores[i] = transformVkSemaphoreList(
- internal_pSubmits[i].pWaitSemaphores, internal_pSubmits[i].waitSemaphoreCount);
- internal_pSubmits[i].pWaitSemaphores = internal_VkSubmitInfo_pWaitSemaphores[i].data();
- internal_pSubmits[i].waitSemaphoreCount =
- internal_VkSubmitInfo_pWaitSemaphores[i].size();
- /* VkSubmitInfo::pCommandBuffers */
- internal_VkSubmitInfo_pCommandBuffers.push_back(std::vector<VkCommandBuffer>());
- internal_VkSubmitInfo_pCommandBuffers[i].reserve(
- internal_pSubmits[i].commandBufferCount);
- memset(&internal_VkSubmitInfo_pCommandBuffers[i][0], 0,
- sizeof(VkCommandBuffer) * internal_pSubmits[i].commandBufferCount);
- for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferCount; ++j) {
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_pCommandBuffers,
- internal_pSubmits[i].pCommandBuffers[j]);
- internal_VkSubmitInfo_pCommandBuffers[i][j] =
- gfxstream_pCommandBuffers->internal_object;
- }
- internal_pSubmits[i].pCommandBuffers = internal_VkSubmitInfo_pCommandBuffers[i].data();
- /* VkSubmitInfo::pSignalSemaphores */
- internal_VkSubmitInfo_pSignalSemaphores.push_back(std::vector<VkSemaphore>());
- internal_VkSubmitInfo_pSignalSemaphores[i] = transformVkSemaphoreList(
- internal_pSubmits[i].pSignalSemaphores, internal_pSubmits[i].signalSemaphoreCount);
- internal_pSubmits[i].pSignalSemaphores =
- internal_VkSubmitInfo_pSignalSemaphores[i].data();
- internal_pSubmits[i].signalSemaphoreCount =
- internal_VkSubmitInfo_pSignalSemaphores[i].size();
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkQueueSubmit_VkResult_return = resources->on_vkQueueSubmit(
- vkEnc, VK_SUCCESS, gfxstream_queue->internal_object, submitCount,
- internal_pSubmits.data(),
- gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE);
- }
- return vkQueueSubmit_VkResult_return;
-}
-VkResult gfxstream_vk_QueueWaitIdle(VkQueue queue) {
- AEMU_SCOPED_TRACE("vkQueueWaitIdle");
- VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
- {
- auto vkEnc =
- gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkQueueWaitIdle_VkResult_return =
- resources->on_vkQueueWaitIdle(vkEnc, VK_SUCCESS, gfxstream_queue->internal_object);
- }
- return vkQueueWaitIdle_VkResult_return;
-}
-VkResult gfxstream_vk_DeviceWaitIdle(VkDevice device) {
- AEMU_SCOPED_TRACE("vkDeviceWaitIdle");
- VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkDeviceWaitIdle_VkResult_return =
- vkEnc->vkDeviceWaitIdle(gfxstream_device->internal_object, true /* do lock */);
- }
- return vkDeviceWaitIdle_VkResult_return;
-}
-void gfxstream_vk_FreeMemory(VkDevice device, VkDeviceMemory memory,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkFreeMemory");
- if (VK_NULL_HANDLE == memory) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkFreeMemory(
- vkEnc, gfxstream_device->internal_object,
- gfxstream_memory ? gfxstream_memory->internal_object : VK_NULL_HANDLE, pAllocator);
- }
- vk_device_memory_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_memory->vk);
-}
-VkResult gfxstream_vk_MapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset,
- VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
- AEMU_SCOPED_TRACE("vkMapMemory");
- VkResult vkMapMemory_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkMapMemory_VkResult_return =
- vkEnc->vkMapMemory(gfxstream_device->internal_object, gfxstream_memory->internal_object,
- offset, size, flags, ppData, true /* do lock */);
- }
- return vkMapMemory_VkResult_return;
-}
-void gfxstream_vk_UnmapMemory(VkDevice device, VkDeviceMemory memory) {
- AEMU_SCOPED_TRACE("vkUnmapMemory");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUnmapMemory(gfxstream_device->internal_object, gfxstream_memory->internal_object,
- true /* do lock */);
- }
-}
-VkResult gfxstream_vk_FlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
- const VkMappedMemoryRange* pMemoryRanges) {
- AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges");
- VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkMappedMemoryRange> internal_pMemoryRanges(memoryRangeCount);
- for (uint32_t i = 0; i < memoryRangeCount; ++i) {
- internal_pMemoryRanges[i] = pMemoryRanges[i];
- /* VkMappedMemoryRange::memory */
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
- internal_pMemoryRanges[i].memory);
- internal_pMemoryRanges[i].memory = gfxstream_memory->internal_object;
- }
- vkFlushMappedMemoryRanges_VkResult_return =
- vkEnc->vkFlushMappedMemoryRanges(gfxstream_device->internal_object, memoryRangeCount,
- internal_pMemoryRanges.data(), true /* do lock */);
- }
- return vkFlushMappedMemoryRanges_VkResult_return;
-}
-VkResult gfxstream_vk_InvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
- const VkMappedMemoryRange* pMemoryRanges) {
- AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges");
- VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkMappedMemoryRange> internal_pMemoryRanges(memoryRangeCount);
- for (uint32_t i = 0; i < memoryRangeCount; ++i) {
- internal_pMemoryRanges[i] = pMemoryRanges[i];
- /* VkMappedMemoryRange::memory */
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
- internal_pMemoryRanges[i].memory);
- internal_pMemoryRanges[i].memory = gfxstream_memory->internal_object;
- }
- vkInvalidateMappedMemoryRanges_VkResult_return = vkEnc->vkInvalidateMappedMemoryRanges(
- gfxstream_device->internal_object, memoryRangeCount, internal_pMemoryRanges.data(),
- true /* do lock */);
- }
- return vkInvalidateMappedMemoryRanges_VkResult_return;
-}
-void gfxstream_vk_GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
- VkDeviceSize* pCommittedMemoryInBytes) {
- AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceMemoryCommitment(gfxstream_device->internal_object,
- gfxstream_memory->internal_object,
- pCommittedMemoryInBytes, true /* do lock */);
- }
-}
-VkResult gfxstream_vk_BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
- VkDeviceSize memoryOffset) {
- AEMU_SCOPED_TRACE("vkBindBufferMemory");
- VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkBindBufferMemory_VkResult_return = resources->on_vkBindBufferMemory(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object, gfxstream_buffer->internal_object,
- gfxstream_memory->internal_object, memoryOffset);
- }
- return vkBindBufferMemory_VkResult_return;
-}
-VkResult gfxstream_vk_BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory,
- VkDeviceSize memoryOffset) {
- AEMU_SCOPED_TRACE("vkBindImageMemory");
- VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkBindImageMemory_VkResult_return = resources->on_vkBindImageMemory(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object, gfxstream_image->internal_object,
- gfxstream_memory->internal_object, memoryOffset);
- }
- return vkBindImageMemory_VkResult_return;
-}
-void gfxstream_vk_GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
- VkMemoryRequirements* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkGetBufferMemoryRequirements(vkEnc, gfxstream_device->internal_object,
- gfxstream_buffer->internal_object,
- pMemoryRequirements);
- }
-}
-void gfxstream_vk_GetImageMemoryRequirements(VkDevice device, VkImage image,
- VkMemoryRequirements* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkGetImageMemoryRequirements(vkEnc, gfxstream_device->internal_object,
- gfxstream_image->internal_object,
- pMemoryRequirements);
- }
-}
-void gfxstream_vk_GetImageSparseMemoryRequirements(
- VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSparseMemoryRequirements(
- gfxstream_device->internal_object, gfxstream_image->internal_object,
- pSparseMemoryRequirementCount, pSparseMemoryRequirements, true /* do lock */);
- }
-}
-void gfxstream_vk_GetPhysicalDeviceSparseImageFormatProperties(
- VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
- VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling,
- uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties(
- gfxstream_physicalDevice->internal_object, format, type, samples, usage, tiling,
- pPropertyCount, pProperties, true /* do lock */);
- }
-}
-VkResult gfxstream_vk_QueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
- const VkBindSparseInfo* pBindInfo, VkFence fence) {
- AEMU_SCOPED_TRACE("vkQueueBindSparse");
- VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
- VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
- {
- auto vkEnc =
- gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
- std::vector<VkBindSparseInfo> internal_pBindInfo(bindInfoCount);
- std::vector<std::vector<VkSemaphore>> internal_VkBindSparseInfo_pWaitSemaphores;
- std::vector<std::vector<VkSparseBufferMemoryBindInfo>>
- internal_VkBindSparseInfo_pBufferBinds;
- std::vector<std::vector<VkSparseMemoryBind>> internal_VkSparseBufferMemoryBindInfo_pBinds;
- std::vector<std::vector<VkSparseImageOpaqueMemoryBindInfo>>
- internal_VkBindSparseInfo_pImageOpaqueBinds;
- std::vector<std::vector<VkSparseMemoryBind>>
- internal_VkSparseImageOpaqueMemoryBindInfo_pBinds;
- std::vector<std::vector<VkSparseImageMemoryBindInfo>> internal_VkBindSparseInfo_pImageBinds;
- std::vector<std::vector<VkSparseImageMemoryBind>>
- internal_VkSparseImageMemoryBindInfo_pBinds;
- std::vector<std::vector<VkSemaphore>> internal_VkBindSparseInfo_pSignalSemaphores;
- for (uint32_t i = 0; i < bindInfoCount; ++i) {
- internal_pBindInfo[i] = pBindInfo[i];
- /* VkBindSparseInfo::pWaitSemaphores */
- internal_VkBindSparseInfo_pWaitSemaphores.push_back(std::vector<VkSemaphore>());
- internal_VkBindSparseInfo_pWaitSemaphores[i] = transformVkSemaphoreList(
- internal_pBindInfo[i].pWaitSemaphores, internal_pBindInfo[i].waitSemaphoreCount);
- internal_pBindInfo[i].pWaitSemaphores =
- internal_VkBindSparseInfo_pWaitSemaphores[i].data();
- internal_pBindInfo[i].waitSemaphoreCount =
- internal_VkBindSparseInfo_pWaitSemaphores[i].size();
- /* VkBindSparseInfo::pBufferBinds */
- internal_VkBindSparseInfo_pBufferBinds.push_back(
- std::vector<VkSparseBufferMemoryBindInfo>());
- internal_VkBindSparseInfo_pBufferBinds[i].reserve(
- internal_pBindInfo[i].bufferBindCount);
- memset(&internal_VkBindSparseInfo_pBufferBinds[i][0], 0,
- sizeof(VkSparseBufferMemoryBindInfo) * internal_pBindInfo[i].bufferBindCount);
- for (uint32_t j = 0; j < internal_pBindInfo[i].bufferBindCount; ++j) {
- internal_VkBindSparseInfo_pBufferBinds[i][j] =
- internal_pBindInfo[i].pBufferBinds[j];
- /* VkSparseBufferMemoryBindInfo::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
- internal_VkBindSparseInfo_pBufferBinds[i][j].buffer);
- internal_VkBindSparseInfo_pBufferBinds[i][j].buffer =
- gfxstream_buffer->internal_object;
- /* VkSparseBufferMemoryBindInfo::pBinds */
- internal_VkSparseBufferMemoryBindInfo_pBinds.push_back(
- std::vector<VkSparseMemoryBind>());
- internal_VkSparseBufferMemoryBindInfo_pBinds[j].reserve(
- internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount);
- memset(&internal_VkSparseBufferMemoryBindInfo_pBinds[j][0], 0,
- sizeof(VkSparseMemoryBind) *
- internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount);
- for (uint32_t k = 0; k < internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount;
- ++k) {
- internal_VkSparseBufferMemoryBindInfo_pBinds[j][k] =
- internal_VkBindSparseInfo_pBufferBinds[i][j].pBinds[k];
- /* VkSparseMemoryBind::memory */
- if (internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory) {
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
- internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory);
- internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory =
- gfxstream_memory->internal_object;
- }
- }
- internal_VkBindSparseInfo_pBufferBinds[i][j].pBinds =
- internal_VkSparseBufferMemoryBindInfo_pBinds[j].data();
- }
- internal_pBindInfo[i].pBufferBinds = internal_VkBindSparseInfo_pBufferBinds[i].data();
- /* VkBindSparseInfo::pImageOpaqueBinds */
- internal_VkBindSparseInfo_pImageOpaqueBinds.push_back(
- std::vector<VkSparseImageOpaqueMemoryBindInfo>());
- internal_VkBindSparseInfo_pImageOpaqueBinds[i].reserve(
- internal_pBindInfo[i].imageOpaqueBindCount);
- memset(&internal_VkBindSparseInfo_pImageOpaqueBinds[i][0], 0,
- sizeof(VkSparseImageOpaqueMemoryBindInfo) *
- internal_pBindInfo[i].imageOpaqueBindCount);
- for (uint32_t j = 0; j < internal_pBindInfo[i].imageOpaqueBindCount; ++j) {
- internal_VkBindSparseInfo_pImageOpaqueBinds[i][j] =
- internal_pBindInfo[i].pImageOpaqueBinds[j];
- /* VkSparseImageOpaqueMemoryBindInfo::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
- internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].image);
- internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].image =
- gfxstream_image->internal_object;
- /* VkSparseImageOpaqueMemoryBindInfo::pBinds */
- internal_VkSparseImageOpaqueMemoryBindInfo_pBinds.push_back(
- std::vector<VkSparseMemoryBind>());
- internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j].reserve(
- internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount);
- memset(&internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][0], 0,
- sizeof(VkSparseMemoryBind) *
- internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount);
- for (uint32_t l = 0;
- l < internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount; ++l) {
- internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l] =
- internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].pBinds[l];
- /* VkSparseMemoryBind::memory */
- if (internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory) {
- VK_FROM_HANDLE(
- gfxstream_vk_device_memory, gfxstream_memory,
- internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory);
- internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory =
- gfxstream_memory->internal_object;
- }
- }
- internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].pBinds =
- internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j].data();
- }
- internal_pBindInfo[i].pImageOpaqueBinds =
- internal_VkBindSparseInfo_pImageOpaqueBinds[i].data();
- /* VkBindSparseInfo::pImageBinds */
- internal_VkBindSparseInfo_pImageBinds.push_back(
- std::vector<VkSparseImageMemoryBindInfo>());
- internal_VkBindSparseInfo_pImageBinds[i].reserve(internal_pBindInfo[i].imageBindCount);
- memset(&internal_VkBindSparseInfo_pImageBinds[i][0], 0,
- sizeof(VkSparseImageMemoryBindInfo) * internal_pBindInfo[i].imageBindCount);
- for (uint32_t j = 0; j < internal_pBindInfo[i].imageBindCount; ++j) {
- internal_VkBindSparseInfo_pImageBinds[i][j] = internal_pBindInfo[i].pImageBinds[j];
- /* VkSparseImageMemoryBindInfo::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
- internal_VkBindSparseInfo_pImageBinds[i][j].image);
- internal_VkBindSparseInfo_pImageBinds[i][j].image =
- gfxstream_image->internal_object;
- /* VkSparseImageMemoryBindInfo::pBinds */
- internal_VkSparseImageMemoryBindInfo_pBinds.push_back(
- std::vector<VkSparseImageMemoryBind>());
- internal_VkSparseImageMemoryBindInfo_pBinds[j].reserve(
- internal_VkBindSparseInfo_pImageBinds[i][j].bindCount);
- memset(&internal_VkSparseImageMemoryBindInfo_pBinds[j][0], 0,
- sizeof(VkSparseImageMemoryBind) *
- internal_VkBindSparseInfo_pImageBinds[i][j].bindCount);
- for (uint32_t m = 0; m < internal_VkBindSparseInfo_pImageBinds[i][j].bindCount;
- ++m) {
- internal_VkSparseImageMemoryBindInfo_pBinds[j][m] =
- internal_VkBindSparseInfo_pImageBinds[i][j].pBinds[m];
- /* VkSparseImageMemoryBind::memory */
- if (internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory) {
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
- internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory);
- internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory =
- gfxstream_memory->internal_object;
- }
- }
- internal_VkBindSparseInfo_pImageBinds[i][j].pBinds =
- internal_VkSparseImageMemoryBindInfo_pBinds[j].data();
- }
- internal_pBindInfo[i].pImageBinds = internal_VkBindSparseInfo_pImageBinds[i].data();
- /* VkBindSparseInfo::pSignalSemaphores */
- internal_VkBindSparseInfo_pSignalSemaphores.push_back(std::vector<VkSemaphore>());
- internal_VkBindSparseInfo_pSignalSemaphores[i] =
- transformVkSemaphoreList(internal_pBindInfo[i].pSignalSemaphores,
- internal_pBindInfo[i].signalSemaphoreCount);
- internal_pBindInfo[i].pSignalSemaphores =
- internal_VkBindSparseInfo_pSignalSemaphores[i].data();
- internal_pBindInfo[i].signalSemaphoreCount =
- internal_VkBindSparseInfo_pSignalSemaphores[i].size();
- }
- vkQueueBindSparse_VkResult_return = vkEnc->vkQueueBindSparse(
- gfxstream_queue->internal_object, bindInfoCount, internal_pBindInfo.data(),
- gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
- true /* do lock */);
- }
- return vkQueueBindSparse_VkResult_return;
-}
-VkResult gfxstream_vk_CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
- AEMU_SCOPED_TRACE("vkCreateFence");
- VkResult vkCreateFence_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_fence* gfxstream_pFence = (gfxstream_vk_fence*)vk_object_zalloc(
- &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_fence), VK_OBJECT_TYPE_FENCE);
- vkCreateFence_VkResult_return = gfxstream_pFence ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateFence_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkCreateFence_VkResult_return = resources->on_vkCreateFence(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
- &gfxstream_pFence->internal_object);
- }
- *pFence = gfxstream_vk_fence_to_handle(gfxstream_pFence);
- return vkCreateFence_VkResult_return;
-}
-void gfxstream_vk_DestroyFence(VkDevice device, VkFence fence,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyFence");
- if (VK_NULL_HANDLE == fence) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyFence(gfxstream_device->internal_object,
- gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
- pAllocator, true /* do lock */);
- }
- vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_fence);
-}
-VkResult gfxstream_vk_ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
- AEMU_SCOPED_TRACE("vkResetFences");
- VkResult vkResetFences_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkFence> internal_pFences(fenceCount);
- for (uint32_t i = 0; i < fenceCount; ++i) {
- VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_pFences, pFences[i]);
- internal_pFences[i] = gfxstream_pFences->internal_object;
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkResetFences_VkResult_return =
- resources->on_vkResetFences(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
- fenceCount, internal_pFences.data());
- }
- return vkResetFences_VkResult_return;
-}
-VkResult gfxstream_vk_GetFenceStatus(VkDevice device, VkFence fence) {
- AEMU_SCOPED_TRACE("vkGetFenceStatus");
- VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkGetFenceStatus_VkResult_return =
- vkEnc->vkGetFenceStatus(gfxstream_device->internal_object,
- gfxstream_fence->internal_object, true /* do lock */);
- }
- return vkGetFenceStatus_VkResult_return;
-}
-VkResult gfxstream_vk_WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences,
- VkBool32 waitAll, uint64_t timeout) {
- AEMU_SCOPED_TRACE("vkWaitForFences");
- VkResult vkWaitForFences_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkFence> internal_pFences(fenceCount);
- for (uint32_t i = 0; i < fenceCount; ++i) {
- VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_pFences, pFences[i]);
- internal_pFences[i] = gfxstream_pFences->internal_object;
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkWaitForFences_VkResult_return =
- resources->on_vkWaitForFences(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
- fenceCount, internal_pFences.data(), waitAll, timeout);
- }
- return vkWaitForFences_VkResult_return;
-}
-VkResult gfxstream_vk_CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSemaphore* pSemaphore) {
- AEMU_SCOPED_TRACE("vkCreateSemaphore");
- VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_semaphore* gfxstream_pSemaphore = (gfxstream_vk_semaphore*)vk_object_zalloc(
- &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_semaphore),
- VK_OBJECT_TYPE_SEMAPHORE);
- vkCreateSemaphore_VkResult_return =
- gfxstream_pSemaphore ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateSemaphore_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkCreateSemaphore_VkResult_return = resources->on_vkCreateSemaphore(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
- &gfxstream_pSemaphore->internal_object);
- }
- *pSemaphore = gfxstream_vk_semaphore_to_handle(gfxstream_pSemaphore);
- return vkCreateSemaphore_VkResult_return;
-}
-void gfxstream_vk_DestroySemaphore(VkDevice device, VkSemaphore semaphore,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroySemaphore");
- if (VK_NULL_HANDLE == semaphore) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore, semaphore);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkDestroySemaphore(
- vkEnc, gfxstream_device->internal_object,
- gfxstream_semaphore ? gfxstream_semaphore->internal_object : VK_NULL_HANDLE,
- pAllocator);
- }
- vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_semaphore);
-}
-VkResult gfxstream_vk_CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
- AEMU_SCOPED_TRACE("vkCreateEvent");
- VkResult vkCreateEvent_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_event* gfxstream_pEvent = (gfxstream_vk_event*)vk_object_zalloc(
- &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_event), VK_OBJECT_TYPE_EVENT);
- vkCreateEvent_VkResult_return = gfxstream_pEvent ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateEvent_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkCreateEvent_VkResult_return =
- vkEnc->vkCreateEvent(gfxstream_device->internal_object, pCreateInfo, pAllocator,
- &gfxstream_pEvent->internal_object, true /* do lock */);
- }
- *pEvent = gfxstream_vk_event_to_handle(gfxstream_pEvent);
- return vkCreateEvent_VkResult_return;
-}
-void gfxstream_vk_DestroyEvent(VkDevice device, VkEvent event,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyEvent");
- if (VK_NULL_HANDLE == event) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyEvent(gfxstream_device->internal_object,
- gfxstream_event ? gfxstream_event->internal_object : VK_NULL_HANDLE,
- pAllocator, true /* do lock */);
- }
- vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_event);
-}
-VkResult gfxstream_vk_GetEventStatus(VkDevice device, VkEvent event) {
- AEMU_SCOPED_TRACE("vkGetEventStatus");
- VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkGetEventStatus_VkResult_return =
- vkEnc->vkGetEventStatus(gfxstream_device->internal_object,
- gfxstream_event->internal_object, true /* do lock */);
- }
- return vkGetEventStatus_VkResult_return;
-}
-VkResult gfxstream_vk_SetEvent(VkDevice device, VkEvent event) {
- AEMU_SCOPED_TRACE("vkSetEvent");
- VkResult vkSetEvent_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkSetEvent_VkResult_return =
- vkEnc->vkSetEvent(gfxstream_device->internal_object, gfxstream_event->internal_object,
- true /* do lock */);
- }
- return vkSetEvent_VkResult_return;
-}
-VkResult gfxstream_vk_ResetEvent(VkDevice device, VkEvent event) {
- AEMU_SCOPED_TRACE("vkResetEvent");
- VkResult vkResetEvent_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkResetEvent_VkResult_return =
- vkEnc->vkResetEvent(gfxstream_device->internal_object, gfxstream_event->internal_object,
- true /* do lock */);
- }
- return vkResetEvent_VkResult_return;
-}
-VkResult gfxstream_vk_CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkQueryPool* pQueryPool) {
- AEMU_SCOPED_TRACE("vkCreateQueryPool");
- VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_query_pool* gfxstream_pQueryPool =
- (struct gfxstream_vk_query_pool*)vk_query_pool_create(
- (vk_device*)gfxstream_device, pCreateInfo, pAllocator,
- sizeof(struct gfxstream_vk_query_pool));
- vkCreateQueryPool_VkResult_return =
- gfxstream_pQueryPool ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateQueryPool_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkCreateQueryPool_VkResult_return =
- vkEnc->vkCreateQueryPool(gfxstream_device->internal_object, pCreateInfo, pAllocator,
- &gfxstream_pQueryPool->internal_object, true /* do lock */);
- }
- *pQueryPool = gfxstream_vk_query_pool_to_handle(gfxstream_pQueryPool);
- return vkCreateQueryPool_VkResult_return;
-}
-void gfxstream_vk_DestroyQueryPool(VkDevice device, VkQueryPool queryPool,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyQueryPool");
- if (VK_NULL_HANDLE == queryPool) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyQueryPool(
- gfxstream_device->internal_object,
- gfxstream_queryPool ? gfxstream_queryPool->internal_object : VK_NULL_HANDLE, pAllocator,
- true /* do lock */);
- }
- vk_query_pool_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_queryPool->vk);
-}
-VkResult gfxstream_vk_GetQueryPoolResults(VkDevice device, VkQueryPool queryPool,
- uint32_t firstQuery, uint32_t queryCount, size_t dataSize,
- void* pData, VkDeviceSize stride,
- VkQueryResultFlags flags) {
- AEMU_SCOPED_TRACE("vkGetQueryPoolResults");
- VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkGetQueryPoolResults_VkResult_return = vkEnc->vkGetQueryPoolResults(
- gfxstream_device->internal_object, gfxstream_queryPool->internal_object, firstQuery,
- queryCount, dataSize, pData, stride, flags, true /* do lock */);
- }
- return vkGetQueryPoolResults_VkResult_return;
-}
-VkResult gfxstream_vk_CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
- AEMU_SCOPED_TRACE("vkCreateBuffer");
- VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_buffer* gfxstream_pBuffer = (struct gfxstream_vk_buffer*)vk_buffer_create(
- (vk_device*)gfxstream_device, pCreateInfo, pAllocator, sizeof(struct gfxstream_vk_buffer));
- vkCreateBuffer_VkResult_return = gfxstream_pBuffer ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateBuffer_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkCreateBuffer_VkResult_return = resources->on_vkCreateBuffer(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
- &gfxstream_pBuffer->internal_object);
- }
- *pBuffer = gfxstream_vk_buffer_to_handle(gfxstream_pBuffer);
- return vkCreateBuffer_VkResult_return;
-}
-void gfxstream_vk_DestroyBuffer(VkDevice device, VkBuffer buffer,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyBuffer");
- if (VK_NULL_HANDLE == buffer) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkDestroyBuffer(
- vkEnc, gfxstream_device->internal_object,
- gfxstream_buffer ? gfxstream_buffer->internal_object : VK_NULL_HANDLE, pAllocator);
- }
- vk_buffer_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_buffer->vk);
-}
-VkResult gfxstream_vk_CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBufferView* pView) {
- AEMU_SCOPED_TRACE("vkCreateBufferView");
- VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_buffer_view* gfxstream_pView =
- (struct gfxstream_vk_buffer_view*)vk_buffer_view_create(
- (vk_device*)gfxstream_device, pCreateInfo, pAllocator,
- sizeof(struct gfxstream_vk_buffer_view));
- vkCreateBufferView_VkResult_return = gfxstream_pView ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateBufferView_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkBufferViewCreateInfo> internal_pCreateInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pCreateInfo[i] = pCreateInfo[i];
- /* VkBufferViewCreateInfo::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pCreateInfo[i].buffer);
- internal_pCreateInfo[i].buffer = gfxstream_buffer->internal_object;
- }
- vkCreateBufferView_VkResult_return = vkEnc->vkCreateBufferView(
- gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
- &gfxstream_pView->internal_object, true /* do lock */);
- }
- *pView = gfxstream_vk_buffer_view_to_handle(gfxstream_pView);
- return vkCreateBufferView_VkResult_return;
-}
-void gfxstream_vk_DestroyBufferView(VkDevice device, VkBufferView bufferView,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyBufferView");
- if (VK_NULL_HANDLE == bufferView) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_bufferView, bufferView);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyBufferView(
- gfxstream_device->internal_object,
- gfxstream_bufferView ? gfxstream_bufferView->internal_object : VK_NULL_HANDLE,
- pAllocator, true /* do lock */);
- }
- vk_buffer_view_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_bufferView->vk);
-}
-VkResult gfxstream_vk_CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
- AEMU_SCOPED_TRACE("vkCreateImage");
- VkResult vkCreateImage_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_image* gfxstream_pImage = (struct gfxstream_vk_image*)vk_image_create(
- (vk_device*)gfxstream_device, pCreateInfo, pAllocator, sizeof(struct gfxstream_vk_image));
- vkCreateImage_VkResult_return = gfxstream_pImage ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateImage_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkCreateImage_VkResult_return = resources->on_vkCreateImage(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
- &gfxstream_pImage->internal_object);
- }
- *pImage = gfxstream_vk_image_to_handle(gfxstream_pImage);
- return vkCreateImage_VkResult_return;
-}
-void gfxstream_vk_DestroyImage(VkDevice device, VkImage image,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyImage");
- if (VK_NULL_HANDLE == image) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkDestroyImage(
- vkEnc, gfxstream_device->internal_object,
- gfxstream_image ? gfxstream_image->internal_object : VK_NULL_HANDLE, pAllocator);
- }
- vk_image_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_image->vk);
-}
-void gfxstream_vk_GetImageSubresourceLayout(VkDevice device, VkImage image,
- const VkImageSubresource* pSubresource,
- VkSubresourceLayout* pLayout) {
- AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSubresourceLayout(gfxstream_device->internal_object,
- gfxstream_image->internal_object, pSubresource, pLayout,
- true /* do lock */);
- }
-}
-VkResult gfxstream_vk_CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
- AEMU_SCOPED_TRACE("vkCreateImageView");
- VkResult vkCreateImageView_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_image_view* gfxstream_pView =
- (struct gfxstream_vk_image_view*)vk_image_view_create(
- (vk_device*)gfxstream_device, false /* driver_internal */, pCreateInfo, pAllocator,
- sizeof(struct gfxstream_vk_image_view));
- vkCreateImageView_VkResult_return = gfxstream_pView ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateImageView_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkImageViewCreateInfo> internal_pCreateInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pCreateInfo[i] = pCreateInfo[i];
- /* VkImageViewCreateInfo::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pCreateInfo[i].image);
- internal_pCreateInfo[i].image = gfxstream_image->internal_object;
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkCreateImageView_VkResult_return = resources->on_vkCreateImageView(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object, internal_pCreateInfo.data(),
- pAllocator, &gfxstream_pView->internal_object);
- }
- *pView = gfxstream_vk_image_view_to_handle(gfxstream_pView);
- return vkCreateImageView_VkResult_return;
-}
-void gfxstream_vk_DestroyImageView(VkDevice device, VkImageView imageView,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyImageView");
- if (VK_NULL_HANDLE == imageView) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView, imageView);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyImageView(
- gfxstream_device->internal_object,
- gfxstream_imageView ? gfxstream_imageView->internal_object : VK_NULL_HANDLE, pAllocator,
- true /* do lock */);
- }
- vk_image_view_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_imageView->vk);
-}
-VkResult gfxstream_vk_CreateShaderModule(VkDevice device,
- const VkShaderModuleCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkShaderModule* pShaderModule) {
- AEMU_SCOPED_TRACE("vkCreateShaderModule");
- VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_shader_module* gfxstream_pShaderModule =
- (gfxstream_vk_shader_module*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
- sizeof(gfxstream_vk_shader_module),
- VK_OBJECT_TYPE_SHADER_MODULE);
- vkCreateShaderModule_VkResult_return =
- gfxstream_pShaderModule ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateShaderModule_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkCreateShaderModule_VkResult_return = vkEnc->vkCreateShaderModule(
- gfxstream_device->internal_object, pCreateInfo, pAllocator,
- &gfxstream_pShaderModule->internal_object, true /* do lock */);
- }
- *pShaderModule = gfxstream_vk_shader_module_to_handle(gfxstream_pShaderModule);
- return vkCreateShaderModule_VkResult_return;
-}
-void gfxstream_vk_DestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyShaderModule");
- if (VK_NULL_HANDLE == shaderModule) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_shader_module, gfxstream_shaderModule, shaderModule);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyShaderModule(
- gfxstream_device->internal_object,
- gfxstream_shaderModule ? gfxstream_shaderModule->internal_object : VK_NULL_HANDLE,
- pAllocator, true /* do lock */);
- }
- vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_shaderModule);
-}
-VkResult gfxstream_vk_CreatePipelineCache(VkDevice device,
- const VkPipelineCacheCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPipelineCache* pPipelineCache) {
- AEMU_SCOPED_TRACE("vkCreatePipelineCache");
- VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_pipeline_cache* gfxstream_pPipelineCache =
- (gfxstream_vk_pipeline_cache*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
- sizeof(gfxstream_vk_pipeline_cache),
- VK_OBJECT_TYPE_PIPELINE_CACHE);
- vkCreatePipelineCache_VkResult_return =
- gfxstream_pPipelineCache ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreatePipelineCache_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkCreatePipelineCache_VkResult_return = vkEnc->vkCreatePipelineCache(
- gfxstream_device->internal_object, pCreateInfo, pAllocator,
- &gfxstream_pPipelineCache->internal_object, true /* do lock */);
- }
- *pPipelineCache = gfxstream_vk_pipeline_cache_to_handle(gfxstream_pPipelineCache);
- return vkCreatePipelineCache_VkResult_return;
-}
-void gfxstream_vk_DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyPipelineCache");
- if (VK_NULL_HANDLE == pipelineCache) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_pipelineCache, pipelineCache);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPipelineCache(
- gfxstream_device->internal_object,
- gfxstream_pipelineCache ? gfxstream_pipelineCache->internal_object : VK_NULL_HANDLE,
- pAllocator, true /* do lock */);
- }
- vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_pipelineCache);
-}
-VkResult gfxstream_vk_GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
- size_t* pDataSize, void* pData) {
- AEMU_SCOPED_TRACE("vkGetPipelineCacheData");
- VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_pipelineCache, pipelineCache);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkGetPipelineCacheData_VkResult_return = vkEnc->vkGetPipelineCacheData(
- gfxstream_device->internal_object, gfxstream_pipelineCache->internal_object, pDataSize,
- pData, true /* do lock */);
- }
- return vkGetPipelineCacheData_VkResult_return;
-}
-VkResult gfxstream_vk_MergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
- uint32_t srcCacheCount,
- const VkPipelineCache* pSrcCaches) {
- AEMU_SCOPED_TRACE("vkMergePipelineCaches");
- VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_dstCache, dstCache);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkPipelineCache> internal_pSrcCaches(srcCacheCount);
- for (uint32_t i = 0; i < srcCacheCount; ++i) {
- VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_pSrcCaches, pSrcCaches[i]);
- internal_pSrcCaches[i] = gfxstream_pSrcCaches->internal_object;
- }
- vkMergePipelineCaches_VkResult_return = vkEnc->vkMergePipelineCaches(
- gfxstream_device->internal_object, gfxstream_dstCache->internal_object, srcCacheCount,
- internal_pSrcCaches.data(), true /* do lock */);
- }
- return vkMergePipelineCaches_VkResult_return;
-}
-VkResult gfxstream_vk_CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkGraphicsPipelineCreateInfo* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines) {
- AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines");
- VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_pipelineCache, pipelineCache);
- struct gfxstream_vk_pipeline* gfxstream_pPipelines = (gfxstream_vk_pipeline*)vk_object_zalloc(
- &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_pipeline), VK_OBJECT_TYPE_PIPELINE);
- vkCreateGraphicsPipelines_VkResult_return =
- gfxstream_pPipelines ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateGraphicsPipelines_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkGraphicsPipelineCreateInfo> internal_pCreateInfos(createInfoCount);
- std::vector<std::vector<VkPipelineShaderStageCreateInfo>>
- internal_VkGraphicsPipelineCreateInfo_pStages;
- for (uint32_t i = 0; i < createInfoCount; ++i) {
- internal_pCreateInfos[i] = pCreateInfos[i];
- /* VkGraphicsPipelineCreateInfo::pStages */
- internal_VkGraphicsPipelineCreateInfo_pStages.push_back(
- std::vector<VkPipelineShaderStageCreateInfo>());
- internal_VkGraphicsPipelineCreateInfo_pStages[i].reserve(
- internal_pCreateInfos[i].stageCount);
- memset(&internal_VkGraphicsPipelineCreateInfo_pStages[i][0], 0,
- sizeof(VkPipelineShaderStageCreateInfo) * internal_pCreateInfos[i].stageCount);
- for (uint32_t j = 0; j < internal_pCreateInfos[i].stageCount; ++j) {
- if (internal_pCreateInfos[i].pStages) {
- internal_VkGraphicsPipelineCreateInfo_pStages[i][j] =
- internal_pCreateInfos[i].pStages[j];
- /* VkPipelineShaderStageCreateInfo::module */
- if (internal_VkGraphicsPipelineCreateInfo_pStages[i][j].module) {
- VK_FROM_HANDLE(gfxstream_vk_shader_module, gfxstream_module,
- internal_VkGraphicsPipelineCreateInfo_pStages[i][j].module);
- internal_VkGraphicsPipelineCreateInfo_pStages[i][j].module =
- gfxstream_module->internal_object;
- }
- }
- }
- internal_pCreateInfos[i].pStages =
- internal_VkGraphicsPipelineCreateInfo_pStages[i].data();
- /* VkGraphicsPipelineCreateInfo::layout */
- if (internal_pCreateInfos[i].layout) {
- VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_layout,
- internal_pCreateInfos[i].layout);
- internal_pCreateInfos[i].layout = gfxstream_layout->internal_object;
- }
- /* VkGraphicsPipelineCreateInfo::renderPass */
- if (internal_pCreateInfos[i].renderPass) {
- VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass,
- internal_pCreateInfos[i].renderPass);
- internal_pCreateInfos[i].renderPass = gfxstream_renderPass->internal_object;
- }
- /* VkGraphicsPipelineCreateInfo::basePipelineHandle */
- if (internal_pCreateInfos[i].basePipelineHandle) {
- VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_basePipelineHandle,
- internal_pCreateInfos[i].basePipelineHandle);
- internal_pCreateInfos[i].basePipelineHandle =
- gfxstream_basePipelineHandle->internal_object;
- }
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkCreateGraphicsPipelines_VkResult_return = resources->on_vkCreateGraphicsPipelines(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
- gfxstream_pipelineCache ? gfxstream_pipelineCache->internal_object : VK_NULL_HANDLE,
- createInfoCount, internal_pCreateInfos.data(), pAllocator,
- &gfxstream_pPipelines->internal_object);
- }
- *pPipelines = gfxstream_vk_pipeline_to_handle(gfxstream_pPipelines);
- return vkCreateGraphicsPipelines_VkResult_return;
-}
-void gfxstream_vk_DestroyPipeline(VkDevice device, VkPipeline pipeline,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyPipeline");
- if (VK_NULL_HANDLE == pipeline) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline, pipeline);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPipeline(
- gfxstream_device->internal_object,
- gfxstream_pipeline ? gfxstream_pipeline->internal_object : VK_NULL_HANDLE, pAllocator,
- true /* do lock */);
- }
- vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_pipeline);
-}
-VkResult gfxstream_vk_CreatePipelineLayout(VkDevice device,
- const VkPipelineLayoutCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPipelineLayout* pPipelineLayout) {
- AEMU_SCOPED_TRACE("vkCreatePipelineLayout");
- VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_pipeline_layout* gfxstream_pPipelineLayout =
- (gfxstream_vk_pipeline_layout*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
- sizeof(gfxstream_vk_pipeline_layout),
- VK_OBJECT_TYPE_PIPELINE_LAYOUT);
- vkCreatePipelineLayout_VkResult_return =
- gfxstream_pPipelineLayout ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreatePipelineLayout_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkPipelineLayoutCreateInfo> internal_pCreateInfo(1);
- std::vector<std::vector<VkDescriptorSetLayout>>
- internal_VkPipelineLayoutCreateInfo_pSetLayouts;
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pCreateInfo[i] = pCreateInfo[i];
- /* VkPipelineLayoutCreateInfo::pSetLayouts */
- internal_VkPipelineLayoutCreateInfo_pSetLayouts.push_back(
- std::vector<VkDescriptorSetLayout>());
- internal_VkPipelineLayoutCreateInfo_pSetLayouts[i].reserve(
- internal_pCreateInfo[i].setLayoutCount);
- memset(&internal_VkPipelineLayoutCreateInfo_pSetLayouts[i][0], 0,
- sizeof(VkDescriptorSetLayout) * internal_pCreateInfo[i].setLayoutCount);
- for (uint32_t j = 0; j < internal_pCreateInfo[i].setLayoutCount; ++j) {
- if (internal_pCreateInfo[i].pSetLayouts) {
- VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_pSetLayouts,
- internal_pCreateInfo[i].pSetLayouts[j]);
- internal_VkPipelineLayoutCreateInfo_pSetLayouts[i][j] =
- gfxstream_pSetLayouts->internal_object;
- }
- }
- internal_pCreateInfo[i].pSetLayouts =
- internal_VkPipelineLayoutCreateInfo_pSetLayouts[i].data();
- }
- vkCreatePipelineLayout_VkResult_return = vkEnc->vkCreatePipelineLayout(
- gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
- &gfxstream_pPipelineLayout->internal_object, true /* do lock */);
- }
- *pPipelineLayout = gfxstream_vk_pipeline_layout_to_handle(gfxstream_pPipelineLayout);
- return vkCreatePipelineLayout_VkResult_return;
-}
-void gfxstream_vk_DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyPipelineLayout");
- if (VK_NULL_HANDLE == pipelineLayout) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_pipelineLayout, pipelineLayout);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPipelineLayout(
- gfxstream_device->internal_object,
- gfxstream_pipelineLayout ? gfxstream_pipelineLayout->internal_object : VK_NULL_HANDLE,
- pAllocator, true /* do lock */);
- }
- vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_pipelineLayout);
-}
-VkResult gfxstream_vk_CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
- AEMU_SCOPED_TRACE("vkCreateSampler");
- VkResult vkCreateSampler_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkCreateSampler_VkResult_return =
- resources->on_vkCreateSampler(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
- pCreateInfo, pAllocator, pSampler);
- }
- return vkCreateSampler_VkResult_return;
-}
-void gfxstream_vk_DestroySampler(VkDevice device, VkSampler sampler,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroySampler");
- if (VK_NULL_HANDLE == sampler) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroySampler(gfxstream_device->internal_object, sampler, pAllocator,
- true /* do lock */);
- }
-}
-VkResult gfxstream_vk_CreateDescriptorSetLayout(VkDevice device,
- const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorSetLayout* pSetLayout) {
- AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout");
- VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_descriptor_set_layout* gfxstream_pSetLayout =
- (gfxstream_vk_descriptor_set_layout*)vk_object_zalloc(
- &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_descriptor_set_layout),
- VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT);
- vkCreateDescriptorSetLayout_VkResult_return =
- gfxstream_pSetLayout ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateDescriptorSetLayout_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkCreateDescriptorSetLayout_VkResult_return = resources->on_vkCreateDescriptorSetLayout(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
- &gfxstream_pSetLayout->internal_object);
- }
- *pSetLayout = gfxstream_vk_descriptor_set_layout_to_handle(gfxstream_pSetLayout);
- return vkCreateDescriptorSetLayout_VkResult_return;
-}
-void gfxstream_vk_DestroyDescriptorSetLayout(VkDevice device,
- VkDescriptorSetLayout descriptorSetLayout,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout");
- if (VK_NULL_HANDLE == descriptorSetLayout) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_descriptorSetLayout,
- descriptorSetLayout);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkDestroyDescriptorSetLayout(
- vkEnc, gfxstream_device->internal_object,
- gfxstream_descriptorSetLayout ? gfxstream_descriptorSetLayout->internal_object
- : VK_NULL_HANDLE,
- pAllocator);
- }
- vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_descriptorSetLayout);
-}
-VkResult gfxstream_vk_CreateDescriptorPool(VkDevice device,
- const VkDescriptorPoolCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorPool* pDescriptorPool) {
- AEMU_SCOPED_TRACE("vkCreateDescriptorPool");
- VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_descriptor_pool* gfxstream_pDescriptorPool =
- (gfxstream_vk_descriptor_pool*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
- sizeof(gfxstream_vk_descriptor_pool),
- VK_OBJECT_TYPE_DESCRIPTOR_POOL);
- vkCreateDescriptorPool_VkResult_return =
- gfxstream_pDescriptorPool ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateDescriptorPool_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkCreateDescriptorPool_VkResult_return = resources->on_vkCreateDescriptorPool(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
- &gfxstream_pDescriptorPool->internal_object);
- }
- *pDescriptorPool = gfxstream_vk_descriptor_pool_to_handle(gfxstream_pDescriptorPool);
- return vkCreateDescriptorPool_VkResult_return;
-}
-void gfxstream_vk_DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyDescriptorPool");
- if (VK_NULL_HANDLE == descriptorPool) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool, descriptorPool);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkDestroyDescriptorPool(
- vkEnc, gfxstream_device->internal_object,
- gfxstream_descriptorPool ? gfxstream_descriptorPool->internal_object : VK_NULL_HANDLE,
- pAllocator);
- }
- vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_descriptorPool);
-}
-VkResult gfxstream_vk_ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
- VkDescriptorPoolResetFlags flags) {
- AEMU_SCOPED_TRACE("vkResetDescriptorPool");
- VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool, descriptorPool);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkResetDescriptorPool_VkResult_return = resources->on_vkResetDescriptorPool(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
- gfxstream_descriptorPool->internal_object, flags);
- }
- return vkResetDescriptorPool_VkResult_return;
-}
-VkResult gfxstream_vk_AllocateDescriptorSets(VkDevice device,
- const VkDescriptorSetAllocateInfo* pAllocateInfo,
- VkDescriptorSet* pDescriptorSets) {
- AEMU_SCOPED_TRACE("vkAllocateDescriptorSets");
- VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkDescriptorSetAllocateInfo> internal_pAllocateInfo(1);
- std::vector<std::vector<VkDescriptorSetLayout>>
- internal_VkDescriptorSetAllocateInfo_pSetLayouts;
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pAllocateInfo[i] = pAllocateInfo[i];
- /* VkDescriptorSetAllocateInfo::descriptorPool */
- VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool,
- internal_pAllocateInfo[i].descriptorPool);
- internal_pAllocateInfo[i].descriptorPool = gfxstream_descriptorPool->internal_object;
- /* VkDescriptorSetAllocateInfo::pSetLayouts */
- internal_VkDescriptorSetAllocateInfo_pSetLayouts.push_back(
- std::vector<VkDescriptorSetLayout>());
- internal_VkDescriptorSetAllocateInfo_pSetLayouts[i].reserve(
- internal_pAllocateInfo[i].descriptorSetCount);
- memset(&internal_VkDescriptorSetAllocateInfo_pSetLayouts[i][0], 0,
- sizeof(VkDescriptorSetLayout) * internal_pAllocateInfo[i].descriptorSetCount);
- for (uint32_t j = 0; j < internal_pAllocateInfo[i].descriptorSetCount; ++j) {
- VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_pSetLayouts,
- internal_pAllocateInfo[i].pSetLayouts[j]);
- internal_VkDescriptorSetAllocateInfo_pSetLayouts[i][j] =
- gfxstream_pSetLayouts->internal_object;
- }
- internal_pAllocateInfo[i].pSetLayouts =
- internal_VkDescriptorSetAllocateInfo_pSetLayouts[i].data();
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkAllocateDescriptorSets_VkResult_return = resources->on_vkAllocateDescriptorSets(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object, internal_pAllocateInfo.data(),
- pDescriptorSets);
- }
- return vkAllocateDescriptorSets_VkResult_return;
-}
-VkResult gfxstream_vk_FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
- uint32_t descriptorSetCount,
- const VkDescriptorSet* pDescriptorSets) {
- AEMU_SCOPED_TRACE("vkFreeDescriptorSets");
- VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0;
- if (VK_NULL_HANDLE == pDescriptorSets) {
- return vkFreeDescriptorSets_VkResult_return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool, descriptorPool);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkFreeDescriptorSets_VkResult_return = resources->on_vkFreeDescriptorSets(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
- gfxstream_descriptorPool->internal_object, descriptorSetCount, pDescriptorSets);
- }
- return vkFreeDescriptorSets_VkResult_return;
-}
-VkResult gfxstream_vk_CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkFramebuffer* pFramebuffer) {
- AEMU_SCOPED_TRACE("vkCreateFramebuffer");
- VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_framebuffer* gfxstream_pFramebuffer =
- (gfxstream_vk_framebuffer*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
- sizeof(gfxstream_vk_framebuffer),
- VK_OBJECT_TYPE_FRAMEBUFFER);
- vkCreateFramebuffer_VkResult_return =
- gfxstream_pFramebuffer ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateFramebuffer_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkFramebufferCreateInfo> internal_pCreateInfo(1);
- std::vector<std::vector<VkImageView>> internal_VkFramebufferCreateInfo_pAttachments;
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pCreateInfo[i] = pCreateInfo[i];
- /* VkFramebufferCreateInfo::renderPass */
- VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass,
- internal_pCreateInfo[i].renderPass);
- internal_pCreateInfo[i].renderPass = gfxstream_renderPass->internal_object;
- /* VkFramebufferCreateInfo::pAttachments */
- internal_VkFramebufferCreateInfo_pAttachments.push_back(std::vector<VkImageView>());
- internal_VkFramebufferCreateInfo_pAttachments[i].reserve(
- internal_pCreateInfo[i].attachmentCount);
- memset(&internal_VkFramebufferCreateInfo_pAttachments[i][0], 0,
- sizeof(VkImageView) * internal_pCreateInfo[i].attachmentCount);
- for (uint32_t j = 0; j < internal_pCreateInfo[i].attachmentCount; ++j) {
- if (internal_pCreateInfo[i].pAttachments) {
- VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_pAttachments,
- internal_pCreateInfo[i].pAttachments[j]);
- internal_VkFramebufferCreateInfo_pAttachments[i][j] =
- gfxstream_pAttachments->internal_object;
- }
- }
- internal_pCreateInfo[i].pAttachments =
- internal_VkFramebufferCreateInfo_pAttachments[i].data();
- }
- vkCreateFramebuffer_VkResult_return = vkEnc->vkCreateFramebuffer(
- gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
- &gfxstream_pFramebuffer->internal_object, true /* do lock */);
- }
- *pFramebuffer = gfxstream_vk_framebuffer_to_handle(gfxstream_pFramebuffer);
- return vkCreateFramebuffer_VkResult_return;
-}
-void gfxstream_vk_DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyFramebuffer");
- if (VK_NULL_HANDLE == framebuffer) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_framebuffer, gfxstream_framebuffer, framebuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyFramebuffer(
- gfxstream_device->internal_object,
- gfxstream_framebuffer ? gfxstream_framebuffer->internal_object : VK_NULL_HANDLE,
- pAllocator, true /* do lock */);
- }
- vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_framebuffer);
-}
-VkResult gfxstream_vk_CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass) {
- AEMU_SCOPED_TRACE("vkCreateRenderPass");
- VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_render_pass* gfxstream_pRenderPass =
- (gfxstream_vk_render_pass*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
- sizeof(gfxstream_vk_render_pass),
- VK_OBJECT_TYPE_RENDER_PASS);
- vkCreateRenderPass_VkResult_return =
- gfxstream_pRenderPass ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateRenderPass_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkCreateRenderPass_VkResult_return =
- vkEnc->vkCreateRenderPass(gfxstream_device->internal_object, pCreateInfo, pAllocator,
- &gfxstream_pRenderPass->internal_object, true /* do lock */);
- }
- *pRenderPass = gfxstream_vk_render_pass_to_handle(gfxstream_pRenderPass);
- return vkCreateRenderPass_VkResult_return;
-}
-void gfxstream_vk_DestroyRenderPass(VkDevice device, VkRenderPass renderPass,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyRenderPass");
- if (VK_NULL_HANDLE == renderPass) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass, renderPass);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyRenderPass(
- gfxstream_device->internal_object,
- gfxstream_renderPass ? gfxstream_renderPass->internal_object : VK_NULL_HANDLE,
- pAllocator, true /* do lock */);
- }
- vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_renderPass);
-}
-void gfxstream_vk_GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
- VkExtent2D* pGranularity) {
- AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass, renderPass);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetRenderAreaGranularity(gfxstream_device->internal_object,
- gfxstream_renderPass->internal_object, pGranularity,
- true /* do lock */);
- }
-}
-VkResult gfxstream_vk_BeginCommandBuffer(VkCommandBuffer commandBuffer,
- const VkCommandBufferBeginInfo* pBeginInfo) {
- AEMU_SCOPED_TRACE("vkBeginCommandBuffer");
- VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkCommandBufferBeginInfo> internal_pBeginInfo(1);
- std::vector<VkCommandBufferInheritanceInfo>
- internal_VkCommandBufferBeginInfo_pInheritanceInfo;
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pBeginInfo[i] = pBeginInfo[i];
- /* VkCommandBufferBeginInfo::pInheritanceInfo */
- if (internal_pBeginInfo[i].pInheritanceInfo) {
- internal_VkCommandBufferBeginInfo_pInheritanceInfo[i] =
- internal_pBeginInfo[i].pInheritanceInfo[0];
- /* VkCommandBufferInheritanceInfo::renderPass */
- if (internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass) {
- VK_FROM_HANDLE(
- gfxstream_vk_render_pass, gfxstream_renderPass,
- internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass);
- internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass =
- gfxstream_renderPass->internal_object;
- }
- /* VkCommandBufferInheritanceInfo::framebuffer */
- if (internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer) {
- VK_FROM_HANDLE(
- gfxstream_vk_framebuffer, gfxstream_framebuffer,
- internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer);
- internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer =
- gfxstream_framebuffer->internal_object;
- }
- internal_pBeginInfo[i].pInheritanceInfo =
- &internal_VkCommandBufferBeginInfo_pInheritanceInfo[i];
- }
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkBeginCommandBuffer_VkResult_return = resources->on_vkBeginCommandBuffer(
- vkEnc, VK_SUCCESS, gfxstream_commandBuffer->internal_object,
- internal_pBeginInfo.data());
- }
- return vkBeginCommandBuffer_VkResult_return;
-}
-VkResult gfxstream_vk_EndCommandBuffer(VkCommandBuffer commandBuffer) {
- AEMU_SCOPED_TRACE("vkEndCommandBuffer");
- VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkEndCommandBuffer_VkResult_return = resources->on_vkEndCommandBuffer(
- vkEnc, VK_SUCCESS, gfxstream_commandBuffer->internal_object);
- }
- return vkEndCommandBuffer_VkResult_return;
-}
-VkResult gfxstream_vk_ResetCommandBuffer(VkCommandBuffer commandBuffer,
- VkCommandBufferResetFlags flags) {
- AEMU_SCOPED_TRACE("vkResetCommandBuffer");
- VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkResetCommandBuffer_VkResult_return = resources->on_vkResetCommandBuffer(
- vkEnc, VK_SUCCESS, gfxstream_commandBuffer->internal_object, flags);
- }
- return vkResetCommandBuffer_VkResult_return;
-}
-void gfxstream_vk_CmdBindPipeline(VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
- AEMU_SCOPED_TRACE("vkCmdBindPipeline");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline, pipeline);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdBindPipeline(gfxstream_commandBuffer->internal_object, pipelineBindPoint,
- gfxstream_pipeline->internal_object, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
- uint32_t viewportCount, const VkViewport* pViewports) {
- AEMU_SCOPED_TRACE("vkCmdSetViewport");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetViewport(gfxstream_commandBuffer->internal_object, firstViewport,
- viewportCount, pViewports, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
- uint32_t scissorCount, const VkRect2D* pScissors) {
- AEMU_SCOPED_TRACE("vkCmdSetScissor");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetScissor(gfxstream_commandBuffer->internal_object, firstScissor, scissorCount,
- pScissors, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
- AEMU_SCOPED_TRACE("vkCmdSetLineWidth");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetLineWidth(gfxstream_commandBuffer->internal_object, lineWidth,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
- float depthBiasClamp, float depthBiasSlopeFactor) {
- AEMU_SCOPED_TRACE("vkCmdSetDepthBias");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetDepthBias(gfxstream_commandBuffer->internal_object, depthBiasConstantFactor,
- depthBiasClamp, depthBiasSlopeFactor, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetBlendConstants(VkCommandBuffer commandBuffer,
- const float blendConstants[4]) {
- AEMU_SCOPED_TRACE("vkCmdSetBlendConstants");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetBlendConstants(gfxstream_commandBuffer->internal_object, blendConstants,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
- float maxDepthBounds) {
- AEMU_SCOPED_TRACE("vkCmdSetDepthBounds");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetDepthBounds(gfxstream_commandBuffer->internal_object, minDepthBounds,
- maxDepthBounds, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask, uint32_t compareMask) {
- AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetStencilCompareMask(gfxstream_commandBuffer->internal_object, faceMask,
- compareMask, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
- uint32_t writeMask) {
- AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetStencilWriteMask(gfxstream_commandBuffer->internal_object, faceMask,
- writeMask, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
- uint32_t reference) {
- AEMU_SCOPED_TRACE("vkCmdSetStencilReference");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetStencilReference(gfxstream_commandBuffer->internal_object, faceMask,
- reference, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdBindDescriptorSets(
- VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
- uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets,
- uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
- AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_layout, layout);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkCmdBindDescriptorSets(vkEnc, gfxstream_commandBuffer->internal_object,
- pipelineBindPoint, gfxstream_layout->internal_object,
- firstSet, descriptorSetCount, pDescriptorSets,
- dynamicOffsetCount, pDynamicOffsets);
- }
-}
-void gfxstream_vk_CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, VkIndexType indexType) {
- AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdBindIndexBuffer(gfxstream_commandBuffer->internal_object,
- gfxstream_buffer->internal_object, offset, indexType,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
- uint32_t bindingCount, const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets) {
- AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkBuffer> internal_pBuffers(bindingCount);
- for (uint32_t i = 0; i < bindingCount; ++i) {
- if (pBuffers) {
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pBuffers, pBuffers[i]);
- internal_pBuffers[i] = gfxstream_pBuffers->internal_object;
- }
- }
- vkEnc->vkCmdBindVertexBuffers(gfxstream_commandBuffer->internal_object, firstBinding,
- bindingCount, internal_pBuffers.data(), pOffsets,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
- uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
- AEMU_SCOPED_TRACE("vkCmdDraw");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdDraw(gfxstream_commandBuffer->internal_object, vertexCount, instanceCount,
- firstVertex, firstInstance, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
- uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset,
- uint32_t firstInstance) {
- AEMU_SCOPED_TRACE("vkCmdDrawIndexed");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdDrawIndexed(gfxstream_commandBuffer->internal_object, indexCount, instanceCount,
- firstIndex, vertexOffset, firstInstance, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
- AEMU_SCOPED_TRACE("vkCmdDrawIndirect");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdDrawIndirect(gfxstream_commandBuffer->internal_object,
- gfxstream_buffer->internal_object, offset, drawCount, stride,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
- AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdDrawIndexedIndirect(gfxstream_commandBuffer->internal_object,
- gfxstream_buffer->internal_object, offset, drawCount,
- stride, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX,
- uint32_t groupCountY, uint32_t groupCountZ) {
- AEMU_SCOPED_TRACE("vkCmdDispatch");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdDispatch(gfxstream_commandBuffer->internal_object, groupCountX, groupCountY,
- groupCountZ, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset) {
- AEMU_SCOPED_TRACE("vkCmdDispatchIndirect");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdDispatchIndirect(gfxstream_commandBuffer->internal_object,
- gfxstream_buffer->internal_object, offset, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
- VkBuffer dstBuffer, uint32_t regionCount,
- const VkBufferCopy* pRegions) {
- AEMU_SCOPED_TRACE("vkCmdCopyBuffer");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer, srcBuffer);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdCopyBuffer(
- gfxstream_commandBuffer->internal_object, gfxstream_srcBuffer->internal_object,
- gfxstream_dstBuffer->internal_object, regionCount, pRegions, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
- VkImageLayout srcImageLayout, VkImage dstImage,
- VkImageLayout dstImageLayout, uint32_t regionCount,
- const VkImageCopy* pRegions) {
- AEMU_SCOPED_TRACE("vkCmdCopyImage");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage, srcImage);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage, dstImage);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdCopyImage(gfxstream_commandBuffer->internal_object,
- gfxstream_srcImage->internal_object, srcImageLayout,
- gfxstream_dstImage->internal_object, dstImageLayout, regionCount,
- pRegions, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
- VkImageLayout srcImageLayout, VkImage dstImage,
- VkImageLayout dstImageLayout, uint32_t regionCount,
- const VkImageBlit* pRegions, VkFilter filter) {
- AEMU_SCOPED_TRACE("vkCmdBlitImage");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage, srcImage);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage, dstImage);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdBlitImage(gfxstream_commandBuffer->internal_object,
- gfxstream_srcImage->internal_object, srcImageLayout,
- gfxstream_dstImage->internal_object, dstImageLayout, regionCount,
- pRegions, filter, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
- VkImage dstImage, VkImageLayout dstImageLayout,
- uint32_t regionCount, const VkBufferImageCopy* pRegions) {
- AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer, srcBuffer);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage, dstImage);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdCopyBufferToImage(gfxstream_commandBuffer->internal_object,
- gfxstream_srcBuffer->internal_object,
- gfxstream_dstImage->internal_object, dstImageLayout,
- regionCount, pRegions, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
- VkImageLayout srcImageLayout, VkBuffer dstBuffer,
- uint32_t regionCount, const VkBufferImageCopy* pRegions) {
- AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage, srcImage);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdCopyImageToBuffer(gfxstream_commandBuffer->internal_object,
- gfxstream_srcImage->internal_object, srcImageLayout,
- gfxstream_dstBuffer->internal_object, regionCount, pRegions,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
- VkDeviceSize dstOffset, VkDeviceSize dataSize,
- const void* pData) {
- AEMU_SCOPED_TRACE("vkCmdUpdateBuffer");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdUpdateBuffer(gfxstream_commandBuffer->internal_object,
- gfxstream_dstBuffer->internal_object, dstOffset, dataSize, pData,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
- VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
- AEMU_SCOPED_TRACE("vkCmdFillBuffer");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdFillBuffer(gfxstream_commandBuffer->internal_object,
- gfxstream_dstBuffer->internal_object, dstOffset, size, data,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
- VkImageLayout imageLayout, const VkClearColorValue* pColor,
- uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
- AEMU_SCOPED_TRACE("vkCmdClearColorImage");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdClearColorImage(gfxstream_commandBuffer->internal_object,
- gfxstream_image->internal_object, imageLayout, pColor,
- rangeCount, pRanges, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
- VkImageLayout imageLayout,
- const VkClearDepthStencilValue* pDepthStencil,
- uint32_t rangeCount,
- const VkImageSubresourceRange* pRanges) {
- AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdClearDepthStencilImage(gfxstream_commandBuffer->internal_object,
- gfxstream_image->internal_object, imageLayout,
- pDepthStencil, rangeCount, pRanges, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
- const VkClearAttachment* pAttachments, uint32_t rectCount,
- const VkClearRect* pRects) {
- AEMU_SCOPED_TRACE("vkCmdClearAttachments");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdClearAttachments(gfxstream_commandBuffer->internal_object, attachmentCount,
- pAttachments, rectCount, pRects, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
- VkImageLayout srcImageLayout, VkImage dstImage,
- VkImageLayout dstImageLayout, uint32_t regionCount,
- const VkImageResolve* pRegions) {
- AEMU_SCOPED_TRACE("vkCmdResolveImage");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage, srcImage);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage, dstImage);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdResolveImage(gfxstream_commandBuffer->internal_object,
- gfxstream_srcImage->internal_object, srcImageLayout,
- gfxstream_dstImage->internal_object, dstImageLayout, regionCount,
- pRegions, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
- VkPipelineStageFlags stageMask) {
- AEMU_SCOPED_TRACE("vkCmdSetEvent");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetEvent(gfxstream_commandBuffer->internal_object,
- gfxstream_event->internal_object, stageMask, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
- VkPipelineStageFlags stageMask) {
- AEMU_SCOPED_TRACE("vkCmdResetEvent");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdResetEvent(gfxstream_commandBuffer->internal_object,
- gfxstream_event->internal_object, stageMask, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount,
- const VkEvent* pEvents, VkPipelineStageFlags srcStageMask,
- VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount,
- const VkMemoryBarrier* pMemoryBarriers,
- uint32_t bufferMemoryBarrierCount,
- const VkBufferMemoryBarrier* pBufferMemoryBarriers,
- uint32_t imageMemoryBarrierCount,
- const VkImageMemoryBarrier* pImageMemoryBarriers) {
- AEMU_SCOPED_TRACE("vkCmdWaitEvents");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkEvent> internal_pEvents(eventCount);
- for (uint32_t i = 0; i < eventCount; ++i) {
- VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_pEvents, pEvents[i]);
- internal_pEvents[i] = gfxstream_pEvents->internal_object;
- }
- std::vector<VkBufferMemoryBarrier> internal_pBufferMemoryBarriers(bufferMemoryBarrierCount);
- for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
- internal_pBufferMemoryBarriers[i] = pBufferMemoryBarriers[i];
- /* VkBufferMemoryBarrier::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
- internal_pBufferMemoryBarriers[i].buffer);
- internal_pBufferMemoryBarriers[i].buffer = gfxstream_buffer->internal_object;
- }
- std::vector<VkImageMemoryBarrier> internal_pImageMemoryBarriers(imageMemoryBarrierCount);
- for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
- internal_pImageMemoryBarriers[i] = pImageMemoryBarriers[i];
- /* VkImageMemoryBarrier::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
- internal_pImageMemoryBarriers[i].image);
- internal_pImageMemoryBarriers[i].image = gfxstream_image->internal_object;
- }
- vkEnc->vkCmdWaitEvents(gfxstream_commandBuffer->internal_object, eventCount,
- internal_pEvents.data(), srcStageMask, dstStageMask,
- memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
- internal_pBufferMemoryBarriers.data(), imageMemoryBarrierCount,
- internal_pImageMemoryBarriers.data(), true /* do lock */);
- }
-}
-void gfxstream_vk_CmdPipelineBarrier(
- VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
- VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
- uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
- uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers,
- uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
- AEMU_SCOPED_TRACE("vkCmdPipelineBarrier");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkBufferMemoryBarrier> internal_pBufferMemoryBarriers(bufferMemoryBarrierCount);
- for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
- internal_pBufferMemoryBarriers[i] = pBufferMemoryBarriers[i];
- /* VkBufferMemoryBarrier::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
- internal_pBufferMemoryBarriers[i].buffer);
- internal_pBufferMemoryBarriers[i].buffer = gfxstream_buffer->internal_object;
- }
- std::vector<VkImageMemoryBarrier> internal_pImageMemoryBarriers(imageMemoryBarrierCount);
- for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
- internal_pImageMemoryBarriers[i] = pImageMemoryBarriers[i];
- /* VkImageMemoryBarrier::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
- internal_pImageMemoryBarriers[i].image);
- internal_pImageMemoryBarriers[i].image = gfxstream_image->internal_object;
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkCmdPipelineBarrier(
- vkEnc, gfxstream_commandBuffer->internal_object, srcStageMask, dstStageMask,
- dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
- internal_pBufferMemoryBarriers.data(), imageMemoryBarrierCount,
- internal_pImageMemoryBarriers.data());
- }
-}
-void gfxstream_vk_CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
- uint32_t query, VkQueryControlFlags flags) {
- AEMU_SCOPED_TRACE("vkCmdBeginQuery");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdBeginQuery(gfxstream_commandBuffer->internal_object,
- gfxstream_queryPool->internal_object, query, flags,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
- uint32_t query) {
- AEMU_SCOPED_TRACE("vkCmdEndQuery");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdEndQuery(gfxstream_commandBuffer->internal_object,
- gfxstream_queryPool->internal_object, query, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
- uint32_t firstQuery, uint32_t queryCount) {
- AEMU_SCOPED_TRACE("vkCmdResetQueryPool");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdResetQueryPool(gfxstream_commandBuffer->internal_object,
- gfxstream_queryPool->internal_object, firstQuery, queryCount,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdWriteTimestamp(VkCommandBuffer commandBuffer,
- VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool,
- uint32_t query) {
- AEMU_SCOPED_TRACE("vkCmdWriteTimestamp");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdWriteTimestamp(gfxstream_commandBuffer->internal_object, pipelineStage,
- gfxstream_queryPool->internal_object, query, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
- uint32_t firstQuery, uint32_t queryCount,
- VkBuffer dstBuffer, VkDeviceSize dstOffset,
- VkDeviceSize stride, VkQueryResultFlags flags) {
- AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdCopyQueryPoolResults(gfxstream_commandBuffer->internal_object,
- gfxstream_queryPool->internal_object, firstQuery,
- queryCount, gfxstream_dstBuffer->internal_object,
- dstOffset, stride, flags, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
- VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
- const void* pValues) {
- AEMU_SCOPED_TRACE("vkCmdPushConstants");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_layout, layout);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdPushConstants(gfxstream_commandBuffer->internal_object,
- gfxstream_layout->internal_object, stageFlags, offset, size,
- pValues, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
- AEMU_SCOPED_TRACE("vkCmdNextSubpass");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdNextSubpass(gfxstream_commandBuffer->internal_object, contents,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdEndRenderPass(VkCommandBuffer commandBuffer) {
- AEMU_SCOPED_TRACE("vkCmdEndRenderPass");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdEndRenderPass(gfxstream_commandBuffer->internal_object, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
- const VkCommandBuffer* pCommandBuffers) {
- AEMU_SCOPED_TRACE("vkCmdExecuteCommands");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkCommandBuffer> internal_pCommandBuffers(commandBufferCount);
- for (uint32_t i = 0; i < commandBufferCount; ++i) {
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_pCommandBuffers,
- pCommandBuffers[i]);
- internal_pCommandBuffers[i] = gfxstream_pCommandBuffers->internal_object;
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkCmdExecuteCommands(vkEnc, gfxstream_commandBuffer->internal_object,
- commandBufferCount, internal_pCommandBuffers.data());
- }
-}
-#endif
-#ifdef VK_VERSION_1_1
-VkResult gfxstream_vk_BindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
- const VkBindBufferMemoryInfo* pBindInfos) {
- AEMU_SCOPED_TRACE("vkBindBufferMemory2");
- VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkBindBufferMemoryInfo> internal_pBindInfos(bindInfoCount);
- for (uint32_t i = 0; i < bindInfoCount; ++i) {
- internal_pBindInfos[i] = pBindInfos[i];
- /* VkBindBufferMemoryInfo::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pBindInfos[i].buffer);
- internal_pBindInfos[i].buffer = gfxstream_buffer->internal_object;
- /* VkBindBufferMemoryInfo::memory */
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
- internal_pBindInfos[i].memory);
- internal_pBindInfos[i].memory = gfxstream_memory->internal_object;
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkBindBufferMemory2_VkResult_return =
- resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
- bindInfoCount, internal_pBindInfos.data());
- }
- return vkBindBufferMemory2_VkResult_return;
-}
-VkResult gfxstream_vk_BindImageMemory2(VkDevice device, uint32_t bindInfoCount,
- const VkBindImageMemoryInfo* pBindInfos) {
- AEMU_SCOPED_TRACE("vkBindImageMemory2");
- VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkBindImageMemoryInfo> internal_pBindInfos(bindInfoCount);
- for (uint32_t i = 0; i < bindInfoCount; ++i) {
- internal_pBindInfos[i] = pBindInfos[i];
- /* VkBindImageMemoryInfo::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pBindInfos[i].image);
- internal_pBindInfos[i].image = gfxstream_image->internal_object;
- /* VkBindImageMemoryInfo::memory */
- if (internal_pBindInfos[i].memory) {
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
- internal_pBindInfos[i].memory);
- internal_pBindInfos[i].memory = gfxstream_memory->internal_object;
- }
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkBindImageMemory2_VkResult_return =
- resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
- bindInfoCount, internal_pBindInfos.data());
- }
- return vkBindImageMemory2_VkResult_return;
-}
-void gfxstream_vk_GetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex,
- uint32_t localDeviceIndex,
- uint32_t remoteDeviceIndex,
- VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
- AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceGroupPeerMemoryFeatures(gfxstream_device->internal_object, heapIndex,
- localDeviceIndex, remoteDeviceIndex,
- pPeerMemoryFeatures, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) {
- AEMU_SCOPED_TRACE("vkCmdSetDeviceMask");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetDeviceMask(gfxstream_commandBuffer->internal_object, deviceMask,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX,
- uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX,
- uint32_t groupCountY, uint32_t groupCountZ) {
- AEMU_SCOPED_TRACE("vkCmdDispatchBase");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdDispatchBase(gfxstream_commandBuffer->internal_object, baseGroupX, baseGroupY,
- baseGroupZ, groupCountX, groupCountY, groupCountZ,
- true /* do lock */);
- }
-}
-void gfxstream_vk_GetImageMemoryRequirements2(VkDevice device,
- const VkImageMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkImageMemoryRequirementsInfo2> internal_pInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pInfo[i] = pInfo[i];
- /* VkImageMemoryRequirementsInfo2::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pInfo[i].image);
- internal_pInfo[i].image = gfxstream_image->internal_object;
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkGetImageMemoryRequirements2(vkEnc, gfxstream_device->internal_object,
- internal_pInfo.data(), pMemoryRequirements);
- }
-}
-void gfxstream_vk_GetBufferMemoryRequirements2(VkDevice device,
- const VkBufferMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkBufferMemoryRequirementsInfo2> internal_pInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pInfo[i] = pInfo[i];
- /* VkBufferMemoryRequirementsInfo2::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
- internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkGetBufferMemoryRequirements2(vkEnc, gfxstream_device->internal_object,
- internal_pInfo.data(), pMemoryRequirements);
- }
-}
-void gfxstream_vk_GetImageSparseMemoryRequirements2(
- VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
- uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkImageSparseMemoryRequirementsInfo2> internal_pInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pInfo[i] = pInfo[i];
- /* VkImageSparseMemoryRequirementsInfo2::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pInfo[i].image);
- internal_pInfo[i].image = gfxstream_image->internal_object;
- }
- vkEnc->vkGetImageSparseMemoryRequirements2(
- gfxstream_device->internal_object, internal_pInfo.data(), pSparseMemoryRequirementCount,
- pSparseMemoryRequirements, true /* do lock */);
- }
-}
-void gfxstream_vk_GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures2* pFeatures) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFeatures2(gfxstream_physicalDevice->internal_object, pFeatures,
- true /* do lock */);
- }
-}
-void gfxstream_vk_GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties2* pProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceProperties2(gfxstream_physicalDevice->internal_object,
- pProperties, true /* do lock */);
- }
-}
-void gfxstream_vk_GetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties2* pFormatProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFormatProperties2(gfxstream_physicalDevice->internal_object,
- format, pFormatProperties, true /* do lock */);
- }
-}
-VkResult gfxstream_vk_GetPhysicalDeviceImageFormatProperties2(
- VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
- VkImageFormatProperties2* pImageFormatProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2");
- VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkGetPhysicalDeviceImageFormatProperties2_VkResult_return =
- resources->on_vkGetPhysicalDeviceImageFormatProperties2(
- vkEnc, VK_SUCCESS, gfxstream_physicalDevice->internal_object, pImageFormatInfo,
- pImageFormatProperties);
- }
- return vkGetPhysicalDeviceImageFormatProperties2_VkResult_return;
-}
-void gfxstream_vk_GetPhysicalDeviceQueueFamilyProperties2(
- VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
- VkQueueFamilyProperties2* pQueueFamilyProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2(
- gfxstream_physicalDevice->internal_object, pQueueFamilyPropertyCount,
- pQueueFamilyProperties, true /* do lock */);
- }
-}
-void gfxstream_vk_GetPhysicalDeviceMemoryProperties2(
- VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceMemoryProperties2(gfxstream_physicalDevice->internal_object,
- pMemoryProperties, true /* do lock */);
- }
-}
-void gfxstream_vk_GetPhysicalDeviceSparseImageFormatProperties2(
- VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
- uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2(
- gfxstream_physicalDevice->internal_object, pFormatInfo, pPropertyCount, pProperties,
- true /* do lock */);
- }
-}
-void gfxstream_vk_TrimCommandPool(VkDevice device, VkCommandPool commandPool,
- VkCommandPoolTrimFlags flags) {
- AEMU_SCOPED_TRACE("vkTrimCommandPool");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_command_pool, gfxstream_commandPool, commandPool);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkTrimCommandPool(gfxstream_device->internal_object,
- gfxstream_commandPool->internal_object, flags, true /* do lock */);
- }
-}
-VkResult gfxstream_vk_CreateSamplerYcbcrConversion(
- VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
- AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion");
- VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkCreateSamplerYcbcrConversion_VkResult_return =
- resources->on_vkCreateSamplerYcbcrConversion(vkEnc, VK_SUCCESS,
- gfxstream_device->internal_object,
- pCreateInfo, pAllocator, pYcbcrConversion);
- }
- return vkCreateSamplerYcbcrConversion_VkResult_return;
-}
-void gfxstream_vk_DestroySamplerYcbcrConversion(VkDevice device,
- VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion");
- if (VK_NULL_HANDLE == ycbcrConversion) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkDestroySamplerYcbcrConversion(vkEnc, gfxstream_device->internal_object,
- ycbcrConversion, pAllocator);
- }
-}
-VkResult gfxstream_vk_CreateDescriptorUpdateTemplate(
- VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
- AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate");
- VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_descriptor_update_template* gfxstream_pDescriptorUpdateTemplate =
- (gfxstream_vk_descriptor_update_template*)vk_object_zalloc(
- &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_descriptor_update_template),
- VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE);
- vkCreateDescriptorUpdateTemplate_VkResult_return =
- gfxstream_pDescriptorUpdateTemplate ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateDescriptorUpdateTemplate_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkDescriptorUpdateTemplateCreateInfo> internal_pCreateInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pCreateInfo[i] = pCreateInfo[i];
- /* VkDescriptorUpdateTemplateCreateInfo::descriptorSetLayout */
- if (internal_pCreateInfo[i].descriptorSetLayout) {
- VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_descriptorSetLayout,
- internal_pCreateInfo[i].descriptorSetLayout);
- internal_pCreateInfo[i].descriptorSetLayout =
- gfxstream_descriptorSetLayout->internal_object;
- }
- /* VkDescriptorUpdateTemplateCreateInfo::pipelineLayout */
- if (internal_pCreateInfo[i].pipelineLayout) {
- VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_pipelineLayout,
- internal_pCreateInfo[i].pipelineLayout);
- internal_pCreateInfo[i].pipelineLayout = gfxstream_pipelineLayout->internal_object;
- }
- }
- vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(
- gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
- &gfxstream_pDescriptorUpdateTemplate->internal_object, true /* do lock */);
- }
- *pDescriptorUpdateTemplate =
- gfxstream_vk_descriptor_update_template_to_handle(gfxstream_pDescriptorUpdateTemplate);
- return vkCreateDescriptorUpdateTemplate_VkResult_return;
-}
-void gfxstream_vk_DestroyDescriptorUpdateTemplate(
- VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate");
- if (VK_NULL_HANDLE == descriptorUpdateTemplate) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
- descriptorUpdateTemplate);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyDescriptorUpdateTemplate(
- gfxstream_device->internal_object,
- gfxstream_descriptorUpdateTemplate ? gfxstream_descriptorUpdateTemplate->internal_object
- : VK_NULL_HANDLE,
- pAllocator, true /* do lock */);
- }
- vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_descriptorUpdateTemplate);
-}
-void gfxstream_vk_UpdateDescriptorSetWithTemplate(
- VkDevice device, VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
- AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
- descriptorUpdateTemplate);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkUpdateDescriptorSetWithTemplate(
- vkEnc, gfxstream_device->internal_object, descriptorSet,
- gfxstream_descriptorUpdateTemplate->internal_object, pData);
- }
-}
-void gfxstream_vk_GetPhysicalDeviceExternalBufferProperties(
- VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
- VkExternalBufferProperties* pExternalBufferProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkGetPhysicalDeviceExternalBufferProperties(
- vkEnc, gfxstream_physicalDevice->internal_object, pExternalBufferInfo,
- pExternalBufferProperties);
- }
-}
-void gfxstream_vk_GetPhysicalDeviceExternalFenceProperties(
- VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
- VkExternalFenceProperties* pExternalFenceProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkGetPhysicalDeviceExternalFenceProperties(
- vkEnc, gfxstream_physicalDevice->internal_object, pExternalFenceInfo,
- pExternalFenceProperties);
- }
-}
-void gfxstream_vk_GetPhysicalDeviceExternalSemaphoreProperties(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
- VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceExternalSemaphoreProperties(
- gfxstream_physicalDevice->internal_object, pExternalSemaphoreInfo,
- pExternalSemaphoreProperties, true /* do lock */);
- }
-}
-void gfxstream_vk_GetDescriptorSetLayoutSupport(VkDevice device,
- const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- VkDescriptorSetLayoutSupport* pSupport) {
- AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDescriptorSetLayoutSupport(gfxstream_device->internal_object, pCreateInfo,
- pSupport, true /* do lock */);
- }
-}
-#endif
-#ifdef VK_VERSION_1_2
-void gfxstream_vk_CmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, VkBuffer countBuffer,
- VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
- uint32_t stride) {
- AEMU_SCOPED_TRACE("vkCmdDrawIndirectCount");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_countBuffer, countBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdDrawIndirectCount(gfxstream_commandBuffer->internal_object,
- gfxstream_buffer->internal_object, offset,
- gfxstream_countBuffer->internal_object, countBufferOffset,
- maxDrawCount, stride, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, VkBuffer countBuffer,
- VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
- uint32_t stride) {
- AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCount");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_countBuffer, countBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdDrawIndexedIndirectCount(
- gfxstream_commandBuffer->internal_object, gfxstream_buffer->internal_object, offset,
- gfxstream_countBuffer->internal_object, countBufferOffset, maxDrawCount, stride,
- true /* do lock */);
- }
-}
-VkResult gfxstream_vk_CreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass) {
- AEMU_SCOPED_TRACE("vkCreateRenderPass2");
- VkResult vkCreateRenderPass2_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_render_pass* gfxstream_pRenderPass =
- (gfxstream_vk_render_pass*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
- sizeof(gfxstream_vk_render_pass),
- VK_OBJECT_TYPE_RENDER_PASS);
- vkCreateRenderPass2_VkResult_return =
- gfxstream_pRenderPass ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateRenderPass2_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkCreateRenderPass2_VkResult_return =
- vkEnc->vkCreateRenderPass2(gfxstream_device->internal_object, pCreateInfo, pAllocator,
- &gfxstream_pRenderPass->internal_object, true /* do lock */);
- }
- *pRenderPass = gfxstream_vk_render_pass_to_handle(gfxstream_pRenderPass);
- return vkCreateRenderPass2_VkResult_return;
-}
-void gfxstream_vk_CmdBeginRenderPass2(VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- const VkSubpassBeginInfo* pSubpassBeginInfo) {
- AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkRenderPassBeginInfo> internal_pRenderPassBegin(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pRenderPassBegin[i] = pRenderPassBegin[i];
- /* VkRenderPassBeginInfo::renderPass */
- VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass,
- internal_pRenderPassBegin[i].renderPass);
- internal_pRenderPassBegin[i].renderPass = gfxstream_renderPass->internal_object;
- /* VkRenderPassBeginInfo::framebuffer */
- VK_FROM_HANDLE(gfxstream_vk_framebuffer, gfxstream_framebuffer,
- internal_pRenderPassBegin[i].framebuffer);
- internal_pRenderPassBegin[i].framebuffer = gfxstream_framebuffer->internal_object;
- }
- vkEnc->vkCmdBeginRenderPass2(gfxstream_commandBuffer->internal_object,
- internal_pRenderPassBegin.data(), pSubpassBeginInfo,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdNextSubpass2(VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
- const VkSubpassEndInfo* pSubpassEndInfo) {
- AEMU_SCOPED_TRACE("vkCmdNextSubpass2");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdNextSubpass2(gfxstream_commandBuffer->internal_object, pSubpassBeginInfo,
- pSubpassEndInfo, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdEndRenderPass2(VkCommandBuffer commandBuffer,
- const VkSubpassEndInfo* pSubpassEndInfo) {
- AEMU_SCOPED_TRACE("vkCmdEndRenderPass2");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdEndRenderPass2(gfxstream_commandBuffer->internal_object, pSubpassEndInfo,
- true /* do lock */);
- }
-}
-void gfxstream_vk_ResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
- uint32_t queryCount) {
- AEMU_SCOPED_TRACE("vkResetQueryPool");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkResetQueryPool(gfxstream_device->internal_object,
- gfxstream_queryPool->internal_object, firstQuery, queryCount,
- true /* do lock */);
- }
-}
-VkResult gfxstream_vk_GetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
- uint64_t* pValue) {
- AEMU_SCOPED_TRACE("vkGetSemaphoreCounterValue");
- VkResult vkGetSemaphoreCounterValue_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore, semaphore);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkGetSemaphoreCounterValue_VkResult_return = vkEnc->vkGetSemaphoreCounterValue(
- gfxstream_device->internal_object, gfxstream_semaphore->internal_object, pValue,
- true /* do lock */);
- }
- return vkGetSemaphoreCounterValue_VkResult_return;
-}
-VkResult gfxstream_vk_WaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo,
- uint64_t timeout) {
- AEMU_SCOPED_TRACE("vkWaitSemaphores");
- VkResult vkWaitSemaphores_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkSemaphoreWaitInfo> internal_pWaitInfo(1);
- std::vector<std::vector<VkSemaphore>> internal_VkSemaphoreWaitInfo_pSemaphores;
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pWaitInfo[i] = pWaitInfo[i];
- /* VkSemaphoreWaitInfo::pSemaphores */
- internal_VkSemaphoreWaitInfo_pSemaphores.push_back(std::vector<VkSemaphore>());
- internal_VkSemaphoreWaitInfo_pSemaphores[i] = transformVkSemaphoreList(
- internal_pWaitInfo[i].pSemaphores, internal_pWaitInfo[i].semaphoreCount);
- internal_pWaitInfo[i].pSemaphores = internal_VkSemaphoreWaitInfo_pSemaphores[i].data();
- internal_pWaitInfo[i].semaphoreCount =
- internal_VkSemaphoreWaitInfo_pSemaphores[i].size();
- }
- vkWaitSemaphores_VkResult_return =
- vkEnc->vkWaitSemaphores(gfxstream_device->internal_object, internal_pWaitInfo.data(),
- timeout, true /* do lock */);
- }
- return vkWaitSemaphores_VkResult_return;
-}
-VkResult gfxstream_vk_SignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) {
- AEMU_SCOPED_TRACE("vkSignalSemaphore");
- VkResult vkSignalSemaphore_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkSemaphoreSignalInfo> internal_pSignalInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pSignalInfo[i] = pSignalInfo[i];
- /* VkSemaphoreSignalInfo::semaphore */
- VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore,
- internal_pSignalInfo[i].semaphore);
- internal_pSignalInfo[i].semaphore = gfxstream_semaphore->internal_object;
- }
- vkSignalSemaphore_VkResult_return = vkEnc->vkSignalSemaphore(
- gfxstream_device->internal_object, internal_pSignalInfo.data(), true /* do lock */);
- }
- return vkSignalSemaphore_VkResult_return;
-}
-VkDeviceAddress gfxstream_vk_GetBufferDeviceAddress(VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo) {
- AEMU_SCOPED_TRACE("vkGetBufferDeviceAddress");
- VkDeviceAddress vkGetBufferDeviceAddress_VkDeviceAddress_return = (VkDeviceAddress)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkBufferDeviceAddressInfo> internal_pInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pInfo[i] = pInfo[i];
- /* VkBufferDeviceAddressInfo::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
- internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
- }
- vkGetBufferDeviceAddress_VkDeviceAddress_return = vkEnc->vkGetBufferDeviceAddress(
- gfxstream_device->internal_object, internal_pInfo.data(), true /* do lock */);
- }
- return vkGetBufferDeviceAddress_VkDeviceAddress_return;
-}
-uint64_t gfxstream_vk_GetBufferOpaqueCaptureAddress(VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo) {
- AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddress");
- uint64_t vkGetBufferOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkBufferDeviceAddressInfo> internal_pInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pInfo[i] = pInfo[i];
- /* VkBufferDeviceAddressInfo::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
- internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
- }
- vkGetBufferOpaqueCaptureAddress_uint64_t_return = vkEnc->vkGetBufferOpaqueCaptureAddress(
- gfxstream_device->internal_object, internal_pInfo.data(), true /* do lock */);
- }
- return vkGetBufferOpaqueCaptureAddress_uint64_t_return;
-}
-uint64_t gfxstream_vk_GetDeviceMemoryOpaqueCaptureAddress(
- VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
- AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddress");
- uint64_t vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkDeviceMemoryOpaqueCaptureAddressInfo> internal_pInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pInfo[i] = pInfo[i];
- /* VkDeviceMemoryOpaqueCaptureAddressInfo::memory */
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, internal_pInfo[i].memory);
- internal_pInfo[i].memory = gfxstream_memory->internal_object;
- }
- vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return =
- vkEnc->vkGetDeviceMemoryOpaqueCaptureAddress(gfxstream_device->internal_object,
- internal_pInfo.data(), true /* do lock */);
- }
- return vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return;
-}
-#endif
-#ifdef VK_VERSION_1_3
-VkResult gfxstream_vk_GetPhysicalDeviceToolProperties(
- VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
- VkPhysicalDeviceToolProperties* pToolProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceToolProperties");
- VkResult vkGetPhysicalDeviceToolProperties_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkGetPhysicalDeviceToolProperties_VkResult_return =
- vkEnc->vkGetPhysicalDeviceToolProperties(gfxstream_physicalDevice->internal_object,
- pToolCount, pToolProperties,
- true /* do lock */);
- }
- return vkGetPhysicalDeviceToolProperties_VkResult_return;
-}
-VkResult gfxstream_vk_CreatePrivateDataSlot(VkDevice device,
- const VkPrivateDataSlotCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPrivateDataSlot* pPrivateDataSlot) {
- AEMU_SCOPED_TRACE("vkCreatePrivateDataSlot");
- VkResult vkCreatePrivateDataSlot_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkCreatePrivateDataSlot_VkResult_return =
- vkEnc->vkCreatePrivateDataSlot(gfxstream_device->internal_object, pCreateInfo,
- pAllocator, pPrivateDataSlot, true /* do lock */);
- }
- return vkCreatePrivateDataSlot_VkResult_return;
-}
-void gfxstream_vk_DestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlot");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPrivateDataSlot(gfxstream_device->internal_object, privateDataSlot,
- pAllocator, true /* do lock */);
- }
-}
-VkResult gfxstream_vk_SetPrivateData(VkDevice device, VkObjectType objectType,
- uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
- uint64_t data) {
- AEMU_SCOPED_TRACE("vkSetPrivateData");
- VkResult vkSetPrivateData_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkSetPrivateData_VkResult_return =
- vkEnc->vkSetPrivateData(gfxstream_device->internal_object, objectType, objectHandle,
- privateDataSlot, data, true /* do lock */);
- }
- return vkSetPrivateData_VkResult_return;
-}
-void gfxstream_vk_GetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
- VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
- AEMU_SCOPED_TRACE("vkGetPrivateData");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPrivateData(gfxstream_device->internal_object, objectType, objectHandle,
- privateDataSlot, pData, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
- const VkDependencyInfo* pDependencyInfo) {
- AEMU_SCOPED_TRACE("vkCmdSetEvent2");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkDependencyInfo> internal_pDependencyInfo(1);
- std::vector<std::vector<VkBufferMemoryBarrier2>>
- internal_VkDependencyInfo_pBufferMemoryBarriers;
- std::vector<std::vector<VkImageMemoryBarrier2>>
- internal_VkDependencyInfo_pImageMemoryBarriers;
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pDependencyInfo[i] = pDependencyInfo[i];
- /* VkDependencyInfo::pBufferMemoryBarriers */
- internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
- std::vector<VkBufferMemoryBarrier2>());
- internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
- internal_pDependencyInfo[i].bufferMemoryBarrierCount);
- memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
- sizeof(VkBufferMemoryBarrier2) *
- internal_pDependencyInfo[i].bufferMemoryBarrierCount);
- for (uint32_t j = 0; j < internal_pDependencyInfo[i].bufferMemoryBarrierCount; ++j) {
- internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
- internal_pDependencyInfo[i].pBufferMemoryBarriers[j];
- /* VkBufferMemoryBarrier2::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
- internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
- internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
- gfxstream_buffer->internal_object;
- }
- internal_pDependencyInfo[i].pBufferMemoryBarriers =
- internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
- /* VkDependencyInfo::pImageMemoryBarriers */
- internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
- std::vector<VkImageMemoryBarrier2>());
- internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
- internal_pDependencyInfo[i].imageMemoryBarrierCount);
- memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
- sizeof(VkImageMemoryBarrier2) *
- internal_pDependencyInfo[i].imageMemoryBarrierCount);
- for (uint32_t j = 0; j < internal_pDependencyInfo[i].imageMemoryBarrierCount; ++j) {
- internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
- internal_pDependencyInfo[i].pImageMemoryBarriers[j];
- /* VkImageMemoryBarrier2::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
- internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
- internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
- gfxstream_image->internal_object;
- }
- internal_pDependencyInfo[i].pImageMemoryBarriers =
- internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
- }
- vkEnc->vkCmdSetEvent2(gfxstream_commandBuffer->internal_object,
- gfxstream_event->internal_object, internal_pDependencyInfo.data(),
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
- VkPipelineStageFlags2 stageMask) {
- AEMU_SCOPED_TRACE("vkCmdResetEvent2");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdResetEvent2(gfxstream_commandBuffer->internal_object,
- gfxstream_event->internal_object, stageMask, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount,
- const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) {
- AEMU_SCOPED_TRACE("vkCmdWaitEvents2");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkEvent> internal_pEvents(eventCount);
- for (uint32_t i = 0; i < eventCount; ++i) {
- VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_pEvents, pEvents[i]);
- internal_pEvents[i] = gfxstream_pEvents->internal_object;
- }
- std::vector<VkDependencyInfo> internal_pDependencyInfos(eventCount);
- std::vector<std::vector<VkBufferMemoryBarrier2>>
- internal_VkDependencyInfo_pBufferMemoryBarriers;
- std::vector<std::vector<VkImageMemoryBarrier2>>
- internal_VkDependencyInfo_pImageMemoryBarriers;
- for (uint32_t i = 0; i < eventCount; ++i) {
- internal_pDependencyInfos[i] = pDependencyInfos[i];
- /* VkDependencyInfo::pBufferMemoryBarriers */
- internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
- std::vector<VkBufferMemoryBarrier2>());
- internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
- internal_pDependencyInfos[i].bufferMemoryBarrierCount);
- memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
- sizeof(VkBufferMemoryBarrier2) *
- internal_pDependencyInfos[i].bufferMemoryBarrierCount);
- for (uint32_t j = 0; j < internal_pDependencyInfos[i].bufferMemoryBarrierCount; ++j) {
- internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
- internal_pDependencyInfos[i].pBufferMemoryBarriers[j];
- /* VkBufferMemoryBarrier2::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
- internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
- internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
- gfxstream_buffer->internal_object;
- }
- internal_pDependencyInfos[i].pBufferMemoryBarriers =
- internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
- /* VkDependencyInfo::pImageMemoryBarriers */
- internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
- std::vector<VkImageMemoryBarrier2>());
- internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
- internal_pDependencyInfos[i].imageMemoryBarrierCount);
- memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
- sizeof(VkImageMemoryBarrier2) *
- internal_pDependencyInfos[i].imageMemoryBarrierCount);
- for (uint32_t j = 0; j < internal_pDependencyInfos[i].imageMemoryBarrierCount; ++j) {
- internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
- internal_pDependencyInfos[i].pImageMemoryBarriers[j];
- /* VkImageMemoryBarrier2::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
- internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
- internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
- gfxstream_image->internal_object;
- }
- internal_pDependencyInfos[i].pImageMemoryBarriers =
- internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
- }
- vkEnc->vkCmdWaitEvents2(gfxstream_commandBuffer->internal_object, eventCount,
- internal_pEvents.data(), internal_pDependencyInfos.data(),
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdPipelineBarrier2(VkCommandBuffer commandBuffer,
- const VkDependencyInfo* pDependencyInfo) {
- AEMU_SCOPED_TRACE("vkCmdPipelineBarrier2");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkDependencyInfo> internal_pDependencyInfo(1);
- std::vector<std::vector<VkBufferMemoryBarrier2>>
- internal_VkDependencyInfo_pBufferMemoryBarriers;
- std::vector<std::vector<VkImageMemoryBarrier2>>
- internal_VkDependencyInfo_pImageMemoryBarriers;
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pDependencyInfo[i] = pDependencyInfo[i];
- /* VkDependencyInfo::pBufferMemoryBarriers */
- internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
- std::vector<VkBufferMemoryBarrier2>());
- internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
- internal_pDependencyInfo[i].bufferMemoryBarrierCount);
- memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
- sizeof(VkBufferMemoryBarrier2) *
- internal_pDependencyInfo[i].bufferMemoryBarrierCount);
- for (uint32_t j = 0; j < internal_pDependencyInfo[i].bufferMemoryBarrierCount; ++j) {
- internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
- internal_pDependencyInfo[i].pBufferMemoryBarriers[j];
- /* VkBufferMemoryBarrier2::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
- internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
- internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
- gfxstream_buffer->internal_object;
- }
- internal_pDependencyInfo[i].pBufferMemoryBarriers =
- internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
- /* VkDependencyInfo::pImageMemoryBarriers */
- internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
- std::vector<VkImageMemoryBarrier2>());
- internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
- internal_pDependencyInfo[i].imageMemoryBarrierCount);
- memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
- sizeof(VkImageMemoryBarrier2) *
- internal_pDependencyInfo[i].imageMemoryBarrierCount);
- for (uint32_t j = 0; j < internal_pDependencyInfo[i].imageMemoryBarrierCount; ++j) {
- internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
- internal_pDependencyInfo[i].pImageMemoryBarriers[j];
- /* VkImageMemoryBarrier2::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
- internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
- internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
- gfxstream_image->internal_object;
- }
- internal_pDependencyInfo[i].pImageMemoryBarriers =
- internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
- }
- vkEnc->vkCmdPipelineBarrier2(gfxstream_commandBuffer->internal_object,
- internal_pDependencyInfo.data(), true /* do lock */);
- }
-}
-void gfxstream_vk_CmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
- VkQueryPool queryPool, uint32_t query) {
- AEMU_SCOPED_TRACE("vkCmdWriteTimestamp2");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdWriteTimestamp2(gfxstream_commandBuffer->internal_object, stage,
- gfxstream_queryPool->internal_object, query,
- true /* do lock */);
- }
-}
-VkResult gfxstream_vk_QueueSubmit2(VkQueue queue, uint32_t submitCount,
- const VkSubmitInfo2* pSubmits, VkFence fence) {
- AEMU_SCOPED_TRACE("vkQueueSubmit2");
- VkResult vkQueueSubmit2_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
- VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
- {
- auto vkEnc =
- gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
- std::vector<VkSubmitInfo2> internal_pSubmits(submitCount);
- std::vector<std::vector<VkSemaphoreSubmitInfo>> internal_VkSubmitInfo2_pWaitSemaphoreInfos;
- std::vector<std::vector<VkCommandBufferSubmitInfo>>
- internal_VkSubmitInfo2_pCommandBufferInfos;
- std::vector<std::vector<VkSemaphoreSubmitInfo>>
- internal_VkSubmitInfo2_pSignalSemaphoreInfos;
- for (uint32_t i = 0; i < submitCount; ++i) {
- internal_pSubmits[i] = pSubmits[i];
- /* VkSubmitInfo2::pWaitSemaphoreInfos */
- internal_VkSubmitInfo2_pWaitSemaphoreInfos.push_back(
- std::vector<VkSemaphoreSubmitInfo>());
- internal_VkSubmitInfo2_pWaitSemaphoreInfos[i] =
- transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pWaitSemaphoreInfos,
- internal_pSubmits[i].waitSemaphoreInfoCount);
- internal_pSubmits[i].pWaitSemaphoreInfos =
- internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].data();
- internal_pSubmits[i].waitSemaphoreInfoCount =
- internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].size();
- /* VkSubmitInfo2::pCommandBufferInfos */
- internal_VkSubmitInfo2_pCommandBufferInfos.push_back(
- std::vector<VkCommandBufferSubmitInfo>());
- internal_VkSubmitInfo2_pCommandBufferInfos[i].reserve(
- internal_pSubmits[i].commandBufferInfoCount);
- memset(&internal_VkSubmitInfo2_pCommandBufferInfos[i][0], 0,
- sizeof(VkCommandBufferSubmitInfo) * internal_pSubmits[i].commandBufferInfoCount);
- for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferInfoCount; ++j) {
- internal_VkSubmitInfo2_pCommandBufferInfos[i][j] =
- internal_pSubmits[i].pCommandBufferInfos[j];
- /* VkCommandBufferSubmitInfo::commandBuffer */
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer,
- internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer);
- internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer =
- gfxstream_commandBuffer->internal_object;
- }
- internal_pSubmits[i].pCommandBufferInfos =
- internal_VkSubmitInfo2_pCommandBufferInfos[i].data();
- /* VkSubmitInfo2::pSignalSemaphoreInfos */
- internal_VkSubmitInfo2_pSignalSemaphoreInfos.push_back(
- std::vector<VkSemaphoreSubmitInfo>());
- internal_VkSubmitInfo2_pSignalSemaphoreInfos[i] =
- transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pSignalSemaphoreInfos,
- internal_pSubmits[i].signalSemaphoreInfoCount);
- internal_pSubmits[i].pSignalSemaphoreInfos =
- internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].data();
- internal_pSubmits[i].signalSemaphoreInfoCount =
- internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].size();
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkQueueSubmit2_VkResult_return = resources->on_vkQueueSubmit2(
- vkEnc, VK_SUCCESS, gfxstream_queue->internal_object, submitCount,
- internal_pSubmits.data(),
- gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE);
- }
- return vkQueueSubmit2_VkResult_return;
-}
-void gfxstream_vk_CmdCopyBuffer2(VkCommandBuffer commandBuffer,
- const VkCopyBufferInfo2* pCopyBufferInfo) {
- AEMU_SCOPED_TRACE("vkCmdCopyBuffer2");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkCopyBufferInfo2> internal_pCopyBufferInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pCopyBufferInfo[i] = pCopyBufferInfo[i];
- /* VkCopyBufferInfo2::srcBuffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer,
- internal_pCopyBufferInfo[i].srcBuffer);
- internal_pCopyBufferInfo[i].srcBuffer = gfxstream_srcBuffer->internal_object;
- /* VkCopyBufferInfo2::dstBuffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer,
- internal_pCopyBufferInfo[i].dstBuffer);
- internal_pCopyBufferInfo[i].dstBuffer = gfxstream_dstBuffer->internal_object;
- }
- vkEnc->vkCmdCopyBuffer2(gfxstream_commandBuffer->internal_object,
- internal_pCopyBufferInfo.data(), true /* do lock */);
- }
-}
-void gfxstream_vk_CmdCopyImage2(VkCommandBuffer commandBuffer,
- const VkCopyImageInfo2* pCopyImageInfo) {
- AEMU_SCOPED_TRACE("vkCmdCopyImage2");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkCopyImageInfo2> internal_pCopyImageInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pCopyImageInfo[i] = pCopyImageInfo[i];
- /* VkCopyImageInfo2::srcImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
- internal_pCopyImageInfo[i].srcImage);
- internal_pCopyImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
- /* VkCopyImageInfo2::dstImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
- internal_pCopyImageInfo[i].dstImage);
- internal_pCopyImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
- }
- vkEnc->vkCmdCopyImage2(gfxstream_commandBuffer->internal_object,
- internal_pCopyImageInfo.data(), true /* do lock */);
- }
-}
-void gfxstream_vk_CmdCopyBufferToImage2(VkCommandBuffer commandBuffer,
- const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
- AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage2");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkCopyBufferToImageInfo2> internal_pCopyBufferToImageInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pCopyBufferToImageInfo[i] = pCopyBufferToImageInfo[i];
- /* VkCopyBufferToImageInfo2::srcBuffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer,
- internal_pCopyBufferToImageInfo[i].srcBuffer);
- internal_pCopyBufferToImageInfo[i].srcBuffer = gfxstream_srcBuffer->internal_object;
- /* VkCopyBufferToImageInfo2::dstImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
- internal_pCopyBufferToImageInfo[i].dstImage);
- internal_pCopyBufferToImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
- }
- vkEnc->vkCmdCopyBufferToImage2(gfxstream_commandBuffer->internal_object,
- internal_pCopyBufferToImageInfo.data(), true /* do lock */);
- }
-}
-void gfxstream_vk_CmdCopyImageToBuffer2(VkCommandBuffer commandBuffer,
- const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
- AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer2");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkCopyImageToBufferInfo2> internal_pCopyImageToBufferInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pCopyImageToBufferInfo[i] = pCopyImageToBufferInfo[i];
- /* VkCopyImageToBufferInfo2::srcImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
- internal_pCopyImageToBufferInfo[i].srcImage);
- internal_pCopyImageToBufferInfo[i].srcImage = gfxstream_srcImage->internal_object;
- /* VkCopyImageToBufferInfo2::dstBuffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer,
- internal_pCopyImageToBufferInfo[i].dstBuffer);
- internal_pCopyImageToBufferInfo[i].dstBuffer = gfxstream_dstBuffer->internal_object;
- }
- vkEnc->vkCmdCopyImageToBuffer2(gfxstream_commandBuffer->internal_object,
- internal_pCopyImageToBufferInfo.data(), true /* do lock */);
- }
-}
-void gfxstream_vk_CmdBlitImage2(VkCommandBuffer commandBuffer,
- const VkBlitImageInfo2* pBlitImageInfo) {
- AEMU_SCOPED_TRACE("vkCmdBlitImage2");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkBlitImageInfo2> internal_pBlitImageInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pBlitImageInfo[i] = pBlitImageInfo[i];
- /* VkBlitImageInfo2::srcImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
- internal_pBlitImageInfo[i].srcImage);
- internal_pBlitImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
- /* VkBlitImageInfo2::dstImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
- internal_pBlitImageInfo[i].dstImage);
- internal_pBlitImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
- }
- vkEnc->vkCmdBlitImage2(gfxstream_commandBuffer->internal_object,
- internal_pBlitImageInfo.data(), true /* do lock */);
- }
-}
-void gfxstream_vk_CmdResolveImage2(VkCommandBuffer commandBuffer,
- const VkResolveImageInfo2* pResolveImageInfo) {
- AEMU_SCOPED_TRACE("vkCmdResolveImage2");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkResolveImageInfo2> internal_pResolveImageInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pResolveImageInfo[i] = pResolveImageInfo[i];
- /* VkResolveImageInfo2::srcImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
- internal_pResolveImageInfo[i].srcImage);
- internal_pResolveImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
- /* VkResolveImageInfo2::dstImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
- internal_pResolveImageInfo[i].dstImage);
- internal_pResolveImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
- }
- vkEnc->vkCmdResolveImage2(gfxstream_commandBuffer->internal_object,
- internal_pResolveImageInfo.data(), true /* do lock */);
- }
-}
-void gfxstream_vk_CmdBeginRendering(VkCommandBuffer commandBuffer,
- const VkRenderingInfo* pRenderingInfo) {
- AEMU_SCOPED_TRACE("vkCmdBeginRendering");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkRenderingInfo> internal_pRenderingInfo(1);
- std::vector<std::vector<VkRenderingAttachmentInfo>>
- internal_VkRenderingInfo_pColorAttachments;
- std::vector<VkRenderingAttachmentInfo> internal_VkRenderingInfo_pDepthAttachment;
- std::vector<VkRenderingAttachmentInfo> internal_VkRenderingInfo_pStencilAttachment;
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pRenderingInfo[i] = pRenderingInfo[i];
- /* VkRenderingInfo::pColorAttachments */
- internal_VkRenderingInfo_pColorAttachments.push_back(
- std::vector<VkRenderingAttachmentInfo>());
- internal_VkRenderingInfo_pColorAttachments[i].reserve(
- internal_pRenderingInfo[i].colorAttachmentCount);
- memset(&internal_VkRenderingInfo_pColorAttachments[i][0], 0,
- sizeof(VkRenderingAttachmentInfo) *
- internal_pRenderingInfo[i].colorAttachmentCount);
- for (uint32_t j = 0; j < internal_pRenderingInfo[i].colorAttachmentCount; ++j) {
- internal_VkRenderingInfo_pColorAttachments[i][j] =
- internal_pRenderingInfo[i].pColorAttachments[j];
- /* VkRenderingAttachmentInfo::imageView */
- if (internal_VkRenderingInfo_pColorAttachments[i][j].imageView) {
- VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
- internal_VkRenderingInfo_pColorAttachments[i][j].imageView);
- internal_VkRenderingInfo_pColorAttachments[i][j].imageView =
- gfxstream_imageView->internal_object;
- }
- /* VkRenderingAttachmentInfo::resolveImageView */
- if (internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView) {
- VK_FROM_HANDLE(
- gfxstream_vk_image_view, gfxstream_resolveImageView,
- internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView);
- internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView =
- gfxstream_resolveImageView->internal_object;
- }
- }
- internal_pRenderingInfo[i].pColorAttachments =
- internal_VkRenderingInfo_pColorAttachments[i].data();
- /* VkRenderingInfo::pDepthAttachment */
- if (internal_pRenderingInfo[i].pDepthAttachment) {
- internal_VkRenderingInfo_pDepthAttachment[i] =
- internal_pRenderingInfo[i].pDepthAttachment[0];
- /* VkRenderingAttachmentInfo::imageView */
- if (internal_VkRenderingInfo_pDepthAttachment[i].imageView) {
- VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
- internal_VkRenderingInfo_pDepthAttachment[i].imageView);
- internal_VkRenderingInfo_pDepthAttachment[i].imageView =
- gfxstream_imageView->internal_object;
- }
- /* VkRenderingAttachmentInfo::resolveImageView */
- if (internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView) {
- VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_resolveImageView,
- internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView);
- internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView =
- gfxstream_resolveImageView->internal_object;
- }
- internal_pRenderingInfo[i].pDepthAttachment =
- &internal_VkRenderingInfo_pDepthAttachment[i];
- }
- /* VkRenderingInfo::pStencilAttachment */
- if (internal_pRenderingInfo[i].pStencilAttachment) {
- internal_VkRenderingInfo_pStencilAttachment[i] =
- internal_pRenderingInfo[i].pStencilAttachment[0];
- /* VkRenderingAttachmentInfo::imageView */
- if (internal_VkRenderingInfo_pStencilAttachment[i].imageView) {
- VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
- internal_VkRenderingInfo_pStencilAttachment[i].imageView);
- internal_VkRenderingInfo_pStencilAttachment[i].imageView =
- gfxstream_imageView->internal_object;
- }
- /* VkRenderingAttachmentInfo::resolveImageView */
- if (internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView) {
- VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_resolveImageView,
- internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView);
- internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView =
- gfxstream_resolveImageView->internal_object;
- }
- internal_pRenderingInfo[i].pStencilAttachment =
- &internal_VkRenderingInfo_pStencilAttachment[i];
- }
- }
- vkEnc->vkCmdBeginRendering(gfxstream_commandBuffer->internal_object,
- internal_pRenderingInfo.data(), true /* do lock */);
- }
-}
-void gfxstream_vk_CmdEndRendering(VkCommandBuffer commandBuffer) {
- AEMU_SCOPED_TRACE("vkCmdEndRendering");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdEndRendering(gfxstream_commandBuffer->internal_object, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
- AEMU_SCOPED_TRACE("vkCmdSetCullMode");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetCullMode(gfxstream_commandBuffer->internal_object, cullMode,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
- AEMU_SCOPED_TRACE("vkCmdSetFrontFace");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetFrontFace(gfxstream_commandBuffer->internal_object, frontFace,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetPrimitiveTopology(VkCommandBuffer commandBuffer,
- VkPrimitiveTopology primitiveTopology) {
- AEMU_SCOPED_TRACE("vkCmdSetPrimitiveTopology");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetPrimitiveTopology(gfxstream_commandBuffer->internal_object,
- primitiveTopology, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount,
- const VkViewport* pViewports) {
- AEMU_SCOPED_TRACE("vkCmdSetViewportWithCount");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetViewportWithCount(gfxstream_commandBuffer->internal_object, viewportCount,
- pViewports, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount,
- const VkRect2D* pScissors) {
- AEMU_SCOPED_TRACE("vkCmdSetScissorWithCount");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetScissorWithCount(gfxstream_commandBuffer->internal_object, scissorCount,
- pScissors, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding,
- uint32_t bindingCount, const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
- const VkDeviceSize* pStrides) {
- AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers2");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkBuffer> internal_pBuffers(bindingCount);
- for (uint32_t i = 0; i < bindingCount; ++i) {
- if (pBuffers) {
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pBuffers, pBuffers[i]);
- internal_pBuffers[i] = gfxstream_pBuffers->internal_object;
- }
- }
- vkEnc->vkCmdBindVertexBuffers2(gfxstream_commandBuffer->internal_object, firstBinding,
- bindingCount, internal_pBuffers.data(), pOffsets, pSizes,
- pStrides, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {
- AEMU_SCOPED_TRACE("vkCmdSetDepthTestEnable");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetDepthTestEnable(gfxstream_commandBuffer->internal_object, depthTestEnable,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) {
- AEMU_SCOPED_TRACE("vkCmdSetDepthWriteEnable");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetDepthWriteEnable(gfxstream_commandBuffer->internal_object, depthWriteEnable,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) {
- AEMU_SCOPED_TRACE("vkCmdSetDepthCompareOp");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetDepthCompareOp(gfxstream_commandBuffer->internal_object, depthCompareOp,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer,
- VkBool32 depthBoundsTestEnable) {
- AEMU_SCOPED_TRACE("vkCmdSetDepthBoundsTestEnable");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetDepthBoundsTestEnable(gfxstream_commandBuffer->internal_object,
- depthBoundsTestEnable, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetStencilTestEnable(VkCommandBuffer commandBuffer,
- VkBool32 stencilTestEnable) {
- AEMU_SCOPED_TRACE("vkCmdSetStencilTestEnable");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetStencilTestEnable(gfxstream_commandBuffer->internal_object,
- stencilTestEnable, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
- VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp,
- VkCompareOp compareOp) {
- AEMU_SCOPED_TRACE("vkCmdSetStencilOp");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetStencilOp(gfxstream_commandBuffer->internal_object, faceMask, failOp, passOp,
- depthFailOp, compareOp, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer,
- VkBool32 rasterizerDiscardEnable) {
- AEMU_SCOPED_TRACE("vkCmdSetRasterizerDiscardEnable");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetRasterizerDiscardEnable(gfxstream_commandBuffer->internal_object,
- rasterizerDiscardEnable, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {
- AEMU_SCOPED_TRACE("vkCmdSetDepthBiasEnable");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetDepthBiasEnable(gfxstream_commandBuffer->internal_object, depthBiasEnable,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer,
- VkBool32 primitiveRestartEnable) {
- AEMU_SCOPED_TRACE("vkCmdSetPrimitiveRestartEnable");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetPrimitiveRestartEnable(gfxstream_commandBuffer->internal_object,
- primitiveRestartEnable, true /* do lock */);
- }
-}
-void gfxstream_vk_GetDeviceBufferMemoryRequirements(VkDevice device,
- const VkDeviceBufferMemoryRequirements* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirements");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceBufferMemoryRequirements(gfxstream_device->internal_object, pInfo,
- pMemoryRequirements, true /* do lock */);
- }
-}
-void gfxstream_vk_GetDeviceImageMemoryRequirements(VkDevice device,
- const VkDeviceImageMemoryRequirements* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirements");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageMemoryRequirements(gfxstream_device->internal_object, pInfo,
- pMemoryRequirements, true /* do lock */);
- }
-}
-void gfxstream_vk_GetDeviceImageSparseMemoryRequirements(
- VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
- uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirements");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageSparseMemoryRequirements(
- gfxstream_device->internal_object, pInfo, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements, true /* do lock */);
- }
-}
-#endif
-#ifdef VK_KHR_surface
-#endif
-#ifdef VK_KHR_swapchain
-#endif
-#ifdef VK_KHR_xcb_surface
-#endif
-#ifdef VK_KHR_android_surface
-#endif
-#ifdef VK_KHR_win32_surface
-#endif
-#ifdef VK_KHR_dynamic_rendering
-void gfxstream_vk_CmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
- const VkRenderingInfo* pRenderingInfo) {
- AEMU_SCOPED_TRACE("vkCmdBeginRenderingKHR");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkRenderingInfo> internal_pRenderingInfo(1);
- std::vector<std::vector<VkRenderingAttachmentInfo>>
- internal_VkRenderingInfo_pColorAttachments;
- std::vector<VkRenderingAttachmentInfo> internal_VkRenderingInfo_pDepthAttachment;
- std::vector<VkRenderingAttachmentInfo> internal_VkRenderingInfo_pStencilAttachment;
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pRenderingInfo[i] = pRenderingInfo[i];
- /* VkRenderingInfo::pColorAttachments */
- internal_VkRenderingInfo_pColorAttachments.push_back(
- std::vector<VkRenderingAttachmentInfo>());
- internal_VkRenderingInfo_pColorAttachments[i].reserve(
- internal_pRenderingInfo[i].colorAttachmentCount);
- memset(&internal_VkRenderingInfo_pColorAttachments[i][0], 0,
- sizeof(VkRenderingAttachmentInfo) *
- internal_pRenderingInfo[i].colorAttachmentCount);
- for (uint32_t j = 0; j < internal_pRenderingInfo[i].colorAttachmentCount; ++j) {
- internal_VkRenderingInfo_pColorAttachments[i][j] =
- internal_pRenderingInfo[i].pColorAttachments[j];
- /* VkRenderingAttachmentInfo::imageView */
- if (internal_VkRenderingInfo_pColorAttachments[i][j].imageView) {
- VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
- internal_VkRenderingInfo_pColorAttachments[i][j].imageView);
- internal_VkRenderingInfo_pColorAttachments[i][j].imageView =
- gfxstream_imageView->internal_object;
- }
- /* VkRenderingAttachmentInfo::resolveImageView */
- if (internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView) {
- VK_FROM_HANDLE(
- gfxstream_vk_image_view, gfxstream_resolveImageView,
- internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView);
- internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView =
- gfxstream_resolveImageView->internal_object;
- }
- }
- internal_pRenderingInfo[i].pColorAttachments =
- internal_VkRenderingInfo_pColorAttachments[i].data();
- /* VkRenderingInfo::pDepthAttachment */
- if (internal_pRenderingInfo[i].pDepthAttachment) {
- internal_VkRenderingInfo_pDepthAttachment[i] =
- internal_pRenderingInfo[i].pDepthAttachment[0];
- /* VkRenderingAttachmentInfo::imageView */
- if (internal_VkRenderingInfo_pDepthAttachment[i].imageView) {
- VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
- internal_VkRenderingInfo_pDepthAttachment[i].imageView);
- internal_VkRenderingInfo_pDepthAttachment[i].imageView =
- gfxstream_imageView->internal_object;
- }
- /* VkRenderingAttachmentInfo::resolveImageView */
- if (internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView) {
- VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_resolveImageView,
- internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView);
- internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView =
- gfxstream_resolveImageView->internal_object;
- }
- internal_pRenderingInfo[i].pDepthAttachment =
- &internal_VkRenderingInfo_pDepthAttachment[i];
- }
- /* VkRenderingInfo::pStencilAttachment */
- if (internal_pRenderingInfo[i].pStencilAttachment) {
- internal_VkRenderingInfo_pStencilAttachment[i] =
- internal_pRenderingInfo[i].pStencilAttachment[0];
- /* VkRenderingAttachmentInfo::imageView */
- if (internal_VkRenderingInfo_pStencilAttachment[i].imageView) {
- VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
- internal_VkRenderingInfo_pStencilAttachment[i].imageView);
- internal_VkRenderingInfo_pStencilAttachment[i].imageView =
- gfxstream_imageView->internal_object;
- }
- /* VkRenderingAttachmentInfo::resolveImageView */
- if (internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView) {
- VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_resolveImageView,
- internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView);
- internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView =
- gfxstream_resolveImageView->internal_object;
- }
- internal_pRenderingInfo[i].pStencilAttachment =
- &internal_VkRenderingInfo_pStencilAttachment[i];
- }
- }
- vkEnc->vkCmdBeginRenderingKHR(gfxstream_commandBuffer->internal_object,
- internal_pRenderingInfo.data(), true /* do lock */);
- }
-}
-void gfxstream_vk_CmdEndRenderingKHR(VkCommandBuffer commandBuffer) {
- AEMU_SCOPED_TRACE("vkCmdEndRenderingKHR");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdEndRenderingKHR(gfxstream_commandBuffer->internal_object, true /* do lock */);
- }
-}
-#endif
-#ifdef VK_KHR_get_physical_device_properties2
-void gfxstream_vk_GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures2* pFeatures) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2KHR");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFeatures2KHR(gfxstream_physicalDevice->internal_object, pFeatures,
- true /* do lock */);
- }
-}
-void gfxstream_vk_GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties2* pProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2KHR");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceProperties2KHR(gfxstream_physicalDevice->internal_object,
- pProperties, true /* do lock */);
- }
-}
-void gfxstream_vk_GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties2* pFormatProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2KHR");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFormatProperties2KHR(gfxstream_physicalDevice->internal_object,
- format, pFormatProperties,
- true /* do lock */);
- }
-}
-VkResult gfxstream_vk_GetPhysicalDeviceImageFormatProperties2KHR(
- VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
- VkImageFormatProperties2* pImageFormatProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2KHR");
- VkResult vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return =
- resources->on_vkGetPhysicalDeviceImageFormatProperties2KHR(
- vkEnc, VK_SUCCESS, gfxstream_physicalDevice->internal_object, pImageFormatInfo,
- pImageFormatProperties);
- }
- return vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return;
-}
-void gfxstream_vk_GetPhysicalDeviceQueueFamilyProperties2KHR(
- VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
- VkQueueFamilyProperties2* pQueueFamilyProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2KHR");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2KHR(
- gfxstream_physicalDevice->internal_object, pQueueFamilyPropertyCount,
- pQueueFamilyProperties, true /* do lock */);
- }
-}
-void gfxstream_vk_GetPhysicalDeviceMemoryProperties2KHR(
- VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2KHR");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceMemoryProperties2KHR(gfxstream_physicalDevice->internal_object,
- pMemoryProperties, true /* do lock */);
- }
-}
-void gfxstream_vk_GetPhysicalDeviceSparseImageFormatProperties2KHR(
- VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
- uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
- gfxstream_physicalDevice->internal_object, pFormatInfo, pPropertyCount, pProperties,
- true /* do lock */);
- }
-}
-#endif
-#ifdef VK_KHR_maintenance1
-void gfxstream_vk_TrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
- VkCommandPoolTrimFlags flags) {
- AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_command_pool, gfxstream_commandPool, commandPool);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkTrimCommandPoolKHR(gfxstream_device->internal_object,
- gfxstream_commandPool->internal_object, flags,
- true /* do lock */);
- }
-}
-#endif
-#ifdef VK_KHR_external_memory_capabilities
-void gfxstream_vk_GetPhysicalDeviceExternalBufferPropertiesKHR(
- VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
- VkExternalBufferProperties* pExternalBufferProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferPropertiesKHR");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
- vkEnc, gfxstream_physicalDevice->internal_object, pExternalBufferInfo,
- pExternalBufferProperties);
- }
-}
-#endif
-#ifdef VK_KHR_external_memory
-#endif
-#ifdef VK_KHR_external_memory_win32
-#endif
-#ifdef VK_KHR_external_memory_fd
-#endif
-#ifdef VK_KHR_external_semaphore_capabilities
-void gfxstream_vk_GetPhysicalDeviceExternalSemaphorePropertiesKHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
- VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
- gfxstream_physicalDevice->internal_object, pExternalSemaphoreInfo,
- pExternalSemaphoreProperties, true /* do lock */);
- }
-}
-#endif
-#ifdef VK_KHR_external_semaphore
-#endif
-#ifdef VK_KHR_external_semaphore_win32
-#endif
-#ifdef VK_KHR_external_semaphore_fd
-VkResult gfxstream_vk_ImportSemaphoreFdKHR(
- VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
- AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR");
- VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkImportSemaphoreFdInfoKHR> internal_pImportSemaphoreFdInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pImportSemaphoreFdInfo[i] = pImportSemaphoreFdInfo[i];
- /* VkImportSemaphoreFdInfoKHR::semaphore */
- VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore,
- internal_pImportSemaphoreFdInfo[i].semaphore);
- internal_pImportSemaphoreFdInfo[i].semaphore = gfxstream_semaphore->internal_object;
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkImportSemaphoreFdKHR_VkResult_return = resources->on_vkImportSemaphoreFdKHR(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
- internal_pImportSemaphoreFdInfo.data());
- }
- return vkImportSemaphoreFdKHR_VkResult_return;
-}
-VkResult gfxstream_vk_GetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
- int* pFd) {
- AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR");
- VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkSemaphoreGetFdInfoKHR> internal_pGetFdInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pGetFdInfo[i] = pGetFdInfo[i];
- /* VkSemaphoreGetFdInfoKHR::semaphore */
- VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore,
- internal_pGetFdInfo[i].semaphore);
- internal_pGetFdInfo[i].semaphore = gfxstream_semaphore->internal_object;
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkGetSemaphoreFdKHR_VkResult_return = resources->on_vkGetSemaphoreFdKHR(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object, internal_pGetFdInfo.data(), pFd);
- }
- return vkGetSemaphoreFdKHR_VkResult_return;
-}
-#endif
-#ifdef VK_KHR_shader_float16_int8
-#endif
-#ifdef VK_KHR_incremental_present
-#endif
-#ifdef VK_KHR_descriptor_update_template
-VkResult gfxstream_vk_CreateDescriptorUpdateTemplateKHR(
- VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
- AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR");
- VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_descriptor_update_template* gfxstream_pDescriptorUpdateTemplate =
- (gfxstream_vk_descriptor_update_template*)vk_object_zalloc(
- &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_descriptor_update_template),
- VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE);
- vkCreateDescriptorUpdateTemplateKHR_VkResult_return =
- gfxstream_pDescriptorUpdateTemplate ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateDescriptorUpdateTemplateKHR_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkDescriptorUpdateTemplateCreateInfo> internal_pCreateInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pCreateInfo[i] = pCreateInfo[i];
- /* VkDescriptorUpdateTemplateCreateInfo::descriptorSetLayout */
- if (internal_pCreateInfo[i].descriptorSetLayout) {
- VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_descriptorSetLayout,
- internal_pCreateInfo[i].descriptorSetLayout);
- internal_pCreateInfo[i].descriptorSetLayout =
- gfxstream_descriptorSetLayout->internal_object;
- }
- /* VkDescriptorUpdateTemplateCreateInfo::pipelineLayout */
- if (internal_pCreateInfo[i].pipelineLayout) {
- VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_pipelineLayout,
- internal_pCreateInfo[i].pipelineLayout);
- internal_pCreateInfo[i].pipelineLayout = gfxstream_pipelineLayout->internal_object;
- }
- }
- vkCreateDescriptorUpdateTemplateKHR_VkResult_return =
- vkEnc->vkCreateDescriptorUpdateTemplateKHR(
- gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
- &gfxstream_pDescriptorUpdateTemplate->internal_object, true /* do lock */);
- }
- *pDescriptorUpdateTemplate =
- gfxstream_vk_descriptor_update_template_to_handle(gfxstream_pDescriptorUpdateTemplate);
- return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
-}
-void gfxstream_vk_DestroyDescriptorUpdateTemplateKHR(
- VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR");
- if (VK_NULL_HANDLE == descriptorUpdateTemplate) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
- descriptorUpdateTemplate);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyDescriptorUpdateTemplateKHR(
- gfxstream_device->internal_object,
- gfxstream_descriptorUpdateTemplate ? gfxstream_descriptorUpdateTemplate->internal_object
- : VK_NULL_HANDLE,
- pAllocator, true /* do lock */);
- }
- vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_descriptorUpdateTemplate);
-}
-void gfxstream_vk_UpdateDescriptorSetWithTemplateKHR(
- VkDevice device, VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
- AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
- descriptorUpdateTemplate);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkUpdateDescriptorSetWithTemplateKHR(
- vkEnc, gfxstream_device->internal_object, descriptorSet,
- gfxstream_descriptorUpdateTemplate->internal_object, pData);
- }
-}
-#endif
-#ifdef VK_KHR_imageless_framebuffer
-#endif
-#ifdef VK_KHR_create_renderpass2
-VkResult gfxstream_vk_CreateRenderPass2KHR(VkDevice device,
- const VkRenderPassCreateInfo2* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass) {
- AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR");
- VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_render_pass* gfxstream_pRenderPass =
- (gfxstream_vk_render_pass*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
- sizeof(gfxstream_vk_render_pass),
- VK_OBJECT_TYPE_RENDER_PASS);
- vkCreateRenderPass2KHR_VkResult_return =
- gfxstream_pRenderPass ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateRenderPass2KHR_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(
- gfxstream_device->internal_object, pCreateInfo, pAllocator,
- &gfxstream_pRenderPass->internal_object, true /* do lock */);
- }
- *pRenderPass = gfxstream_vk_render_pass_to_handle(gfxstream_pRenderPass);
- return vkCreateRenderPass2KHR_VkResult_return;
-}
-void gfxstream_vk_CmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
- const VkSubpassEndInfo* pSubpassEndInfo) {
- AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdNextSubpass2KHR(gfxstream_commandBuffer->internal_object, pSubpassBeginInfo,
- pSubpassEndInfo, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
- const VkSubpassEndInfo* pSubpassEndInfo) {
- AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdEndRenderPass2KHR(gfxstream_commandBuffer->internal_object, pSubpassEndInfo,
- true /* do lock */);
- }
-}
-#endif
-#ifdef VK_KHR_external_fence_capabilities
-void gfxstream_vk_GetPhysicalDeviceExternalFencePropertiesKHR(
- VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
- VkExternalFenceProperties* pExternalFenceProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFencePropertiesKHR");
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkGetPhysicalDeviceExternalFencePropertiesKHR(
- vkEnc, gfxstream_physicalDevice->internal_object, pExternalFenceInfo,
- pExternalFenceProperties);
- }
-}
-#endif
-#ifdef VK_KHR_external_fence
-#endif
-#ifdef VK_KHR_external_fence_fd
-VkResult gfxstream_vk_ImportFenceFdKHR(VkDevice device,
- const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
- AEMU_SCOPED_TRACE("vkImportFenceFdKHR");
- VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkImportFenceFdInfoKHR> internal_pImportFenceFdInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pImportFenceFdInfo[i] = pImportFenceFdInfo[i];
- /* VkImportFenceFdInfoKHR::fence */
- VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence,
- internal_pImportFenceFdInfo[i].fence);
- internal_pImportFenceFdInfo[i].fence = gfxstream_fence->internal_object;
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkImportFenceFdKHR_VkResult_return =
- resources->on_vkImportFenceFdKHR(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
- internal_pImportFenceFdInfo.data());
- }
- return vkImportFenceFdKHR_VkResult_return;
-}
-VkResult gfxstream_vk_GetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo,
- int* pFd) {
- AEMU_SCOPED_TRACE("vkGetFenceFdKHR");
- VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkFenceGetFdInfoKHR> internal_pGetFdInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pGetFdInfo[i] = pGetFdInfo[i];
- /* VkFenceGetFdInfoKHR::fence */
- VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, internal_pGetFdInfo[i].fence);
- internal_pGetFdInfo[i].fence = gfxstream_fence->internal_object;
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkGetFenceFdKHR_VkResult_return = resources->on_vkGetFenceFdKHR(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object, internal_pGetFdInfo.data(), pFd);
- }
- return vkGetFenceFdKHR_VkResult_return;
-}
-#endif
-#ifdef VK_KHR_maintenance2
-#endif
-#ifdef VK_KHR_dedicated_allocation
-#endif
-#ifdef VK_KHR_storage_buffer_storage_class
-#endif
-#ifdef VK_KHR_get_memory_requirements2
-void gfxstream_vk_GetImageMemoryRequirements2KHR(VkDevice device,
- const VkImageMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkImageMemoryRequirementsInfo2> internal_pInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pInfo[i] = pInfo[i];
- /* VkImageMemoryRequirementsInfo2::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pInfo[i].image);
- internal_pInfo[i].image = gfxstream_image->internal_object;
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkGetImageMemoryRequirements2KHR(vkEnc, gfxstream_device->internal_object,
- internal_pInfo.data(), pMemoryRequirements);
- }
-}
-void gfxstream_vk_GetBufferMemoryRequirements2KHR(VkDevice device,
- const VkBufferMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkBufferMemoryRequirementsInfo2> internal_pInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pInfo[i] = pInfo[i];
- /* VkBufferMemoryRequirementsInfo2::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
- internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkGetBufferMemoryRequirements2KHR(vkEnc, gfxstream_device->internal_object,
- internal_pInfo.data(), pMemoryRequirements);
- }
-}
-void gfxstream_vk_GetImageSparseMemoryRequirements2KHR(
- VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
- uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkImageSparseMemoryRequirementsInfo2> internal_pInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pInfo[i] = pInfo[i];
- /* VkImageSparseMemoryRequirementsInfo2::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pInfo[i].image);
- internal_pInfo[i].image = gfxstream_image->internal_object;
- }
- vkEnc->vkGetImageSparseMemoryRequirements2KHR(
- gfxstream_device->internal_object, internal_pInfo.data(), pSparseMemoryRequirementCount,
- pSparseMemoryRequirements, true /* do lock */);
- }
-}
-#endif
-#ifdef VK_KHR_image_format_list
-#endif
-#ifdef VK_KHR_sampler_ycbcr_conversion
-VkResult gfxstream_vk_CreateSamplerYcbcrConversionKHR(
- VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
- AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR");
- VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkCreateSamplerYcbcrConversionKHR_VkResult_return =
- resources->on_vkCreateSamplerYcbcrConversionKHR(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
- pYcbcrConversion);
- }
- return vkCreateSamplerYcbcrConversionKHR_VkResult_return;
-}
-void gfxstream_vk_DestroySamplerYcbcrConversionKHR(VkDevice device,
- VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR");
- if (VK_NULL_HANDLE == ycbcrConversion) {
- return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- auto resources = gfxstream::vk::ResourceTracker::get();
- resources->on_vkDestroySamplerYcbcrConversionKHR(vkEnc, gfxstream_device->internal_object,
- ycbcrConversion, pAllocator);
- }
-}
-#endif
-#ifdef VK_KHR_bind_memory2
-VkResult gfxstream_vk_BindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
- const VkBindBufferMemoryInfo* pBindInfos) {
- AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR");
- VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkBindBufferMemoryInfo> internal_pBindInfos(bindInfoCount);
- for (uint32_t i = 0; i < bindInfoCount; ++i) {
- internal_pBindInfos[i] = pBindInfos[i];
- /* VkBindBufferMemoryInfo::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pBindInfos[i].buffer);
- internal_pBindInfos[i].buffer = gfxstream_buffer->internal_object;
- /* VkBindBufferMemoryInfo::memory */
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
- internal_pBindInfos[i].memory);
- internal_pBindInfos[i].memory = gfxstream_memory->internal_object;
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkBindBufferMemory2KHR_VkResult_return = resources->on_vkBindBufferMemory2KHR(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object, bindInfoCount,
- internal_pBindInfos.data());
- }
- return vkBindBufferMemory2KHR_VkResult_return;
-}
-VkResult gfxstream_vk_BindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
- const VkBindImageMemoryInfo* pBindInfos) {
- AEMU_SCOPED_TRACE("vkBindImageMemory2KHR");
- VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkBindImageMemoryInfo> internal_pBindInfos(bindInfoCount);
- for (uint32_t i = 0; i < bindInfoCount; ++i) {
- internal_pBindInfos[i] = pBindInfos[i];
- /* VkBindImageMemoryInfo::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pBindInfos[i].image);
- internal_pBindInfos[i].image = gfxstream_image->internal_object;
- /* VkBindImageMemoryInfo::memory */
- if (internal_pBindInfos[i].memory) {
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
- internal_pBindInfos[i].memory);
- internal_pBindInfos[i].memory = gfxstream_memory->internal_object;
- }
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkBindImageMemory2KHR_VkResult_return = resources->on_vkBindImageMemory2KHR(
- vkEnc, VK_SUCCESS, gfxstream_device->internal_object, bindInfoCount,
- internal_pBindInfos.data());
- }
- return vkBindImageMemory2KHR_VkResult_return;
-}
-#endif
-#ifdef VK_KHR_maintenance3
-void gfxstream_vk_GetDescriptorSetLayoutSupportKHR(
- VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- VkDescriptorSetLayoutSupport* pSupport) {
- AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDescriptorSetLayoutSupportKHR(gfxstream_device->internal_object, pCreateInfo,
- pSupport, true /* do lock */);
- }
-}
-#endif
-#ifdef VK_KHR_shader_subgroup_extended_types
-#endif
-#ifdef VK_KHR_vulkan_memory_model
-#endif
-#ifdef VK_KHR_shader_terminate_invocation
-#endif
-#ifdef VK_KHR_buffer_device_address
-VkDeviceAddress gfxstream_vk_GetBufferDeviceAddressKHR(VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo) {
- AEMU_SCOPED_TRACE("vkGetBufferDeviceAddressKHR");
- VkDeviceAddress vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = (VkDeviceAddress)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkBufferDeviceAddressInfo> internal_pInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pInfo[i] = pInfo[i];
- /* VkBufferDeviceAddressInfo::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
- internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
- }
- vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = vkEnc->vkGetBufferDeviceAddressKHR(
- gfxstream_device->internal_object, internal_pInfo.data(), true /* do lock */);
- }
- return vkGetBufferDeviceAddressKHR_VkDeviceAddress_return;
-}
-uint64_t gfxstream_vk_GetBufferOpaqueCaptureAddressKHR(VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo) {
- AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddressKHR");
- uint64_t vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkBufferDeviceAddressInfo> internal_pInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pInfo[i] = pInfo[i];
- /* VkBufferDeviceAddressInfo::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
- internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
- }
- vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return =
- vkEnc->vkGetBufferOpaqueCaptureAddressKHR(gfxstream_device->internal_object,
- internal_pInfo.data(), true /* do lock */);
- }
- return vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return;
-}
-uint64_t gfxstream_vk_GetDeviceMemoryOpaqueCaptureAddressKHR(
- VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
- AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddressKHR");
- uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkDeviceMemoryOpaqueCaptureAddressInfo> internal_pInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pInfo[i] = pInfo[i];
- /* VkDeviceMemoryOpaqueCaptureAddressInfo::memory */
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, internal_pInfo[i].memory);
- internal_pInfo[i].memory = gfxstream_memory->internal_object;
- }
- vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return =
- vkEnc->vkGetDeviceMemoryOpaqueCaptureAddressKHR(
- gfxstream_device->internal_object, internal_pInfo.data(), true /* do lock */);
- }
- return vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return;
-}
-#endif
-#ifdef VK_KHR_pipeline_executable_properties
-VkResult gfxstream_vk_GetPipelineExecutablePropertiesKHR(
- VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount,
- VkPipelineExecutablePropertiesKHR* pProperties) {
- AEMU_SCOPED_TRACE("vkGetPipelineExecutablePropertiesKHR");
- VkResult vkGetPipelineExecutablePropertiesKHR_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkPipelineInfoKHR> internal_pPipelineInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pPipelineInfo[i] = pPipelineInfo[i];
- /* VkPipelineInfoKHR::pipeline */
- VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline,
- internal_pPipelineInfo[i].pipeline);
- internal_pPipelineInfo[i].pipeline = gfxstream_pipeline->internal_object;
- }
- vkGetPipelineExecutablePropertiesKHR_VkResult_return =
- vkEnc->vkGetPipelineExecutablePropertiesKHR(
- gfxstream_device->internal_object, internal_pPipelineInfo.data(), pExecutableCount,
- pProperties, true /* do lock */);
- }
- return vkGetPipelineExecutablePropertiesKHR_VkResult_return;
-}
-VkResult gfxstream_vk_GetPipelineExecutableStatisticsKHR(
- VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount,
- VkPipelineExecutableStatisticKHR* pStatistics) {
- AEMU_SCOPED_TRACE("vkGetPipelineExecutableStatisticsKHR");
- VkResult vkGetPipelineExecutableStatisticsKHR_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkPipelineExecutableInfoKHR> internal_pExecutableInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pExecutableInfo[i] = pExecutableInfo[i];
- /* VkPipelineExecutableInfoKHR::pipeline */
- VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline,
- internal_pExecutableInfo[i].pipeline);
- internal_pExecutableInfo[i].pipeline = gfxstream_pipeline->internal_object;
- }
- vkGetPipelineExecutableStatisticsKHR_VkResult_return =
- vkEnc->vkGetPipelineExecutableStatisticsKHR(
- gfxstream_device->internal_object, internal_pExecutableInfo.data(), pStatisticCount,
- pStatistics, true /* do lock */);
- }
- return vkGetPipelineExecutableStatisticsKHR_VkResult_return;
-}
-VkResult gfxstream_vk_GetPipelineExecutableInternalRepresentationsKHR(
- VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo,
- uint32_t* pInternalRepresentationCount,
- VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
- AEMU_SCOPED_TRACE("vkGetPipelineExecutableInternalRepresentationsKHR");
- VkResult vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkPipelineExecutableInfoKHR> internal_pExecutableInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pExecutableInfo[i] = pExecutableInfo[i];
- /* VkPipelineExecutableInfoKHR::pipeline */
- VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline,
- internal_pExecutableInfo[i].pipeline);
- internal_pExecutableInfo[i].pipeline = gfxstream_pipeline->internal_object;
- }
- vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return =
- vkEnc->vkGetPipelineExecutableInternalRepresentationsKHR(
- gfxstream_device->internal_object, internal_pExecutableInfo.data(),
- pInternalRepresentationCount, pInternalRepresentations, true /* do lock */);
- }
- return vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return;
-}
-#endif
-#ifdef VK_KHR_shader_integer_dot_product
-#endif
-#ifdef VK_KHR_shader_non_semantic_info
-#endif
-#ifdef VK_KHR_synchronization2
-void gfxstream_vk_CmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
- const VkDependencyInfo* pDependencyInfo) {
- AEMU_SCOPED_TRACE("vkCmdSetEvent2KHR");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkDependencyInfo> internal_pDependencyInfo(1);
- std::vector<std::vector<VkBufferMemoryBarrier2>>
- internal_VkDependencyInfo_pBufferMemoryBarriers;
- std::vector<std::vector<VkImageMemoryBarrier2>>
- internal_VkDependencyInfo_pImageMemoryBarriers;
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pDependencyInfo[i] = pDependencyInfo[i];
- /* VkDependencyInfo::pBufferMemoryBarriers */
- internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
- std::vector<VkBufferMemoryBarrier2>());
- internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
- internal_pDependencyInfo[i].bufferMemoryBarrierCount);
- memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
- sizeof(VkBufferMemoryBarrier2) *
- internal_pDependencyInfo[i].bufferMemoryBarrierCount);
- for (uint32_t j = 0; j < internal_pDependencyInfo[i].bufferMemoryBarrierCount; ++j) {
- internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
- internal_pDependencyInfo[i].pBufferMemoryBarriers[j];
- /* VkBufferMemoryBarrier2::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
- internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
- internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
- gfxstream_buffer->internal_object;
- }
- internal_pDependencyInfo[i].pBufferMemoryBarriers =
- internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
- /* VkDependencyInfo::pImageMemoryBarriers */
- internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
- std::vector<VkImageMemoryBarrier2>());
- internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
- internal_pDependencyInfo[i].imageMemoryBarrierCount);
- memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
- sizeof(VkImageMemoryBarrier2) *
- internal_pDependencyInfo[i].imageMemoryBarrierCount);
- for (uint32_t j = 0; j < internal_pDependencyInfo[i].imageMemoryBarrierCount; ++j) {
- internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
- internal_pDependencyInfo[i].pImageMemoryBarriers[j];
- /* VkImageMemoryBarrier2::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
- internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
- internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
- gfxstream_image->internal_object;
- }
- internal_pDependencyInfo[i].pImageMemoryBarriers =
- internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
- }
- vkEnc->vkCmdSetEvent2KHR(gfxstream_commandBuffer->internal_object,
- gfxstream_event->internal_object, internal_pDependencyInfo.data(),
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
- VkPipelineStageFlags2 stageMask) {
- AEMU_SCOPED_TRACE("vkCmdResetEvent2KHR");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdResetEvent2KHR(gfxstream_commandBuffer->internal_object,
- gfxstream_event->internal_object, stageMask, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
- const VkEvent* pEvents,
- const VkDependencyInfo* pDependencyInfos) {
- AEMU_SCOPED_TRACE("vkCmdWaitEvents2KHR");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkEvent> internal_pEvents(eventCount);
- for (uint32_t i = 0; i < eventCount; ++i) {
- VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_pEvents, pEvents[i]);
- internal_pEvents[i] = gfxstream_pEvents->internal_object;
- }
- std::vector<VkDependencyInfo> internal_pDependencyInfos(eventCount);
- std::vector<std::vector<VkBufferMemoryBarrier2>>
- internal_VkDependencyInfo_pBufferMemoryBarriers;
- std::vector<std::vector<VkImageMemoryBarrier2>>
- internal_VkDependencyInfo_pImageMemoryBarriers;
- for (uint32_t i = 0; i < eventCount; ++i) {
- internal_pDependencyInfos[i] = pDependencyInfos[i];
- /* VkDependencyInfo::pBufferMemoryBarriers */
- internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
- std::vector<VkBufferMemoryBarrier2>());
- internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
- internal_pDependencyInfos[i].bufferMemoryBarrierCount);
- memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
- sizeof(VkBufferMemoryBarrier2) *
- internal_pDependencyInfos[i].bufferMemoryBarrierCount);
- for (uint32_t j = 0; j < internal_pDependencyInfos[i].bufferMemoryBarrierCount; ++j) {
- internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
- internal_pDependencyInfos[i].pBufferMemoryBarriers[j];
- /* VkBufferMemoryBarrier2::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
- internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
- internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
- gfxstream_buffer->internal_object;
- }
- internal_pDependencyInfos[i].pBufferMemoryBarriers =
- internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
- /* VkDependencyInfo::pImageMemoryBarriers */
- internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
- std::vector<VkImageMemoryBarrier2>());
- internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
- internal_pDependencyInfos[i].imageMemoryBarrierCount);
- memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
- sizeof(VkImageMemoryBarrier2) *
- internal_pDependencyInfos[i].imageMemoryBarrierCount);
- for (uint32_t j = 0; j < internal_pDependencyInfos[i].imageMemoryBarrierCount; ++j) {
- internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
- internal_pDependencyInfos[i].pImageMemoryBarriers[j];
- /* VkImageMemoryBarrier2::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
- internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
- internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
- gfxstream_image->internal_object;
- }
- internal_pDependencyInfos[i].pImageMemoryBarriers =
- internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
- }
- vkEnc->vkCmdWaitEvents2KHR(gfxstream_commandBuffer->internal_object, eventCount,
- internal_pEvents.data(), internal_pDependencyInfos.data(),
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
- const VkDependencyInfo* pDependencyInfo) {
- AEMU_SCOPED_TRACE("vkCmdPipelineBarrier2KHR");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkDependencyInfo> internal_pDependencyInfo(1);
- std::vector<std::vector<VkBufferMemoryBarrier2>>
- internal_VkDependencyInfo_pBufferMemoryBarriers;
- std::vector<std::vector<VkImageMemoryBarrier2>>
- internal_VkDependencyInfo_pImageMemoryBarriers;
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pDependencyInfo[i] = pDependencyInfo[i];
- /* VkDependencyInfo::pBufferMemoryBarriers */
- internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
- std::vector<VkBufferMemoryBarrier2>());
- internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
- internal_pDependencyInfo[i].bufferMemoryBarrierCount);
- memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
- sizeof(VkBufferMemoryBarrier2) *
- internal_pDependencyInfo[i].bufferMemoryBarrierCount);
- for (uint32_t j = 0; j < internal_pDependencyInfo[i].bufferMemoryBarrierCount; ++j) {
- internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
- internal_pDependencyInfo[i].pBufferMemoryBarriers[j];
- /* VkBufferMemoryBarrier2::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
- internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
- internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
- gfxstream_buffer->internal_object;
- }
- internal_pDependencyInfo[i].pBufferMemoryBarriers =
- internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
- /* VkDependencyInfo::pImageMemoryBarriers */
- internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
- std::vector<VkImageMemoryBarrier2>());
- internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
- internal_pDependencyInfo[i].imageMemoryBarrierCount);
- memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
- sizeof(VkImageMemoryBarrier2) *
- internal_pDependencyInfo[i].imageMemoryBarrierCount);
- for (uint32_t j = 0; j < internal_pDependencyInfo[i].imageMemoryBarrierCount; ++j) {
- internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
- internal_pDependencyInfo[i].pImageMemoryBarriers[j];
- /* VkImageMemoryBarrier2::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
- internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
- internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
- gfxstream_image->internal_object;
- }
- internal_pDependencyInfo[i].pImageMemoryBarriers =
- internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
- }
- vkEnc->vkCmdPipelineBarrier2KHR(gfxstream_commandBuffer->internal_object,
- internal_pDependencyInfo.data(), true /* do lock */);
- }
-}
-void gfxstream_vk_CmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
- VkQueryPool queryPool, uint32_t query) {
- AEMU_SCOPED_TRACE("vkCmdWriteTimestamp2KHR");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdWriteTimestamp2KHR(gfxstream_commandBuffer->internal_object, stage,
- gfxstream_queryPool->internal_object, query,
- true /* do lock */);
- }
-}
-VkResult gfxstream_vk_QueueSubmit2KHR(VkQueue queue, uint32_t submitCount,
- const VkSubmitInfo2* pSubmits, VkFence fence) {
- AEMU_SCOPED_TRACE("vkQueueSubmit2KHR");
- VkResult vkQueueSubmit2KHR_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
- VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
- {
- auto vkEnc =
- gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
- std::vector<VkSubmitInfo2> internal_pSubmits(submitCount);
- std::vector<std::vector<VkSemaphoreSubmitInfo>> internal_VkSubmitInfo2_pWaitSemaphoreInfos;
- std::vector<std::vector<VkCommandBufferSubmitInfo>>
- internal_VkSubmitInfo2_pCommandBufferInfos;
- std::vector<std::vector<VkSemaphoreSubmitInfo>>
- internal_VkSubmitInfo2_pSignalSemaphoreInfos;
- for (uint32_t i = 0; i < submitCount; ++i) {
- internal_pSubmits[i] = pSubmits[i];
- /* VkSubmitInfo2::pWaitSemaphoreInfos */
- internal_VkSubmitInfo2_pWaitSemaphoreInfos.push_back(
- std::vector<VkSemaphoreSubmitInfo>());
- internal_VkSubmitInfo2_pWaitSemaphoreInfos[i] =
- transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pWaitSemaphoreInfos,
- internal_pSubmits[i].waitSemaphoreInfoCount);
- internal_pSubmits[i].pWaitSemaphoreInfos =
- internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].data();
- internal_pSubmits[i].waitSemaphoreInfoCount =
- internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].size();
- /* VkSubmitInfo2::pCommandBufferInfos */
- internal_VkSubmitInfo2_pCommandBufferInfos.push_back(
- std::vector<VkCommandBufferSubmitInfo>());
- internal_VkSubmitInfo2_pCommandBufferInfos[i].reserve(
- internal_pSubmits[i].commandBufferInfoCount);
- memset(&internal_VkSubmitInfo2_pCommandBufferInfos[i][0], 0,
- sizeof(VkCommandBufferSubmitInfo) * internal_pSubmits[i].commandBufferInfoCount);
- for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferInfoCount; ++j) {
- internal_VkSubmitInfo2_pCommandBufferInfos[i][j] =
- internal_pSubmits[i].pCommandBufferInfos[j];
- /* VkCommandBufferSubmitInfo::commandBuffer */
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer,
- internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer);
- internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer =
- gfxstream_commandBuffer->internal_object;
- }
- internal_pSubmits[i].pCommandBufferInfos =
- internal_VkSubmitInfo2_pCommandBufferInfos[i].data();
- /* VkSubmitInfo2::pSignalSemaphoreInfos */
- internal_VkSubmitInfo2_pSignalSemaphoreInfos.push_back(
- std::vector<VkSemaphoreSubmitInfo>());
- internal_VkSubmitInfo2_pSignalSemaphoreInfos[i] =
- transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pSignalSemaphoreInfos,
- internal_pSubmits[i].signalSemaphoreInfoCount);
- internal_pSubmits[i].pSignalSemaphoreInfos =
- internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].data();
- internal_pSubmits[i].signalSemaphoreInfoCount =
- internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].size();
- }
- vkQueueSubmit2KHR_VkResult_return = vkEnc->vkQueueSubmit2KHR(
- gfxstream_queue->internal_object, submitCount, internal_pSubmits.data(),
- gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
- true /* do lock */);
- }
- return vkQueueSubmit2KHR_VkResult_return;
-}
-void gfxstream_vk_CmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2 stage, VkBuffer dstBuffer,
- VkDeviceSize dstOffset, uint32_t marker) {
- AEMU_SCOPED_TRACE("vkCmdWriteBufferMarker2AMD");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdWriteBufferMarker2AMD(gfxstream_commandBuffer->internal_object, stage,
- gfxstream_dstBuffer->internal_object, dstOffset, marker,
- true /* do lock */);
- }
-}
-void gfxstream_vk_GetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount,
- VkCheckpointData2NV* pCheckpointData) {
- AEMU_SCOPED_TRACE("vkGetQueueCheckpointData2NV");
- VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
- {
- auto vkEnc =
- gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
- vkEnc->vkGetQueueCheckpointData2NV(gfxstream_queue->internal_object, pCheckpointDataCount,
- pCheckpointData, true /* do lock */);
- }
-}
-#endif
-#ifdef VK_KHR_zero_initialize_workgroup_memory
-#endif
-#ifdef VK_KHR_copy_commands2
-void gfxstream_vk_CmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
- const VkCopyBufferInfo2* pCopyBufferInfo) {
- AEMU_SCOPED_TRACE("vkCmdCopyBuffer2KHR");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkCopyBufferInfo2> internal_pCopyBufferInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pCopyBufferInfo[i] = pCopyBufferInfo[i];
- /* VkCopyBufferInfo2::srcBuffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer,
- internal_pCopyBufferInfo[i].srcBuffer);
- internal_pCopyBufferInfo[i].srcBuffer = gfxstream_srcBuffer->internal_object;
- /* VkCopyBufferInfo2::dstBuffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer,
- internal_pCopyBufferInfo[i].dstBuffer);
- internal_pCopyBufferInfo[i].dstBuffer = gfxstream_dstBuffer->internal_object;
- }
- vkEnc->vkCmdCopyBuffer2KHR(gfxstream_commandBuffer->internal_object,
- internal_pCopyBufferInfo.data(), true /* do lock */);
- }
-}
-void gfxstream_vk_CmdCopyImage2KHR(VkCommandBuffer commandBuffer,
- const VkCopyImageInfo2* pCopyImageInfo) {
- AEMU_SCOPED_TRACE("vkCmdCopyImage2KHR");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkCopyImageInfo2> internal_pCopyImageInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pCopyImageInfo[i] = pCopyImageInfo[i];
- /* VkCopyImageInfo2::srcImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
- internal_pCopyImageInfo[i].srcImage);
- internal_pCopyImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
- /* VkCopyImageInfo2::dstImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
- internal_pCopyImageInfo[i].dstImage);
- internal_pCopyImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
- }
- vkEnc->vkCmdCopyImage2KHR(gfxstream_commandBuffer->internal_object,
- internal_pCopyImageInfo.data(), true /* do lock */);
- }
-}
-void gfxstream_vk_CmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,
- const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
- AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage2KHR");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkCopyBufferToImageInfo2> internal_pCopyBufferToImageInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pCopyBufferToImageInfo[i] = pCopyBufferToImageInfo[i];
- /* VkCopyBufferToImageInfo2::srcBuffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer,
- internal_pCopyBufferToImageInfo[i].srcBuffer);
- internal_pCopyBufferToImageInfo[i].srcBuffer = gfxstream_srcBuffer->internal_object;
- /* VkCopyBufferToImageInfo2::dstImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
- internal_pCopyBufferToImageInfo[i].dstImage);
- internal_pCopyBufferToImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
- }
- vkEnc->vkCmdCopyBufferToImage2KHR(gfxstream_commandBuffer->internal_object,
- internal_pCopyBufferToImageInfo.data(),
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,
- const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
- AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer2KHR");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkCopyImageToBufferInfo2> internal_pCopyImageToBufferInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pCopyImageToBufferInfo[i] = pCopyImageToBufferInfo[i];
- /* VkCopyImageToBufferInfo2::srcImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
- internal_pCopyImageToBufferInfo[i].srcImage);
- internal_pCopyImageToBufferInfo[i].srcImage = gfxstream_srcImage->internal_object;
- /* VkCopyImageToBufferInfo2::dstBuffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer,
- internal_pCopyImageToBufferInfo[i].dstBuffer);
- internal_pCopyImageToBufferInfo[i].dstBuffer = gfxstream_dstBuffer->internal_object;
- }
- vkEnc->vkCmdCopyImageToBuffer2KHR(gfxstream_commandBuffer->internal_object,
- internal_pCopyImageToBufferInfo.data(),
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdBlitImage2KHR(VkCommandBuffer commandBuffer,
- const VkBlitImageInfo2* pBlitImageInfo) {
- AEMU_SCOPED_TRACE("vkCmdBlitImage2KHR");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkBlitImageInfo2> internal_pBlitImageInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pBlitImageInfo[i] = pBlitImageInfo[i];
- /* VkBlitImageInfo2::srcImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
- internal_pBlitImageInfo[i].srcImage);
- internal_pBlitImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
- /* VkBlitImageInfo2::dstImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
- internal_pBlitImageInfo[i].dstImage);
- internal_pBlitImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
- }
- vkEnc->vkCmdBlitImage2KHR(gfxstream_commandBuffer->internal_object,
- internal_pBlitImageInfo.data(), true /* do lock */);
- }
-}
-void gfxstream_vk_CmdResolveImage2KHR(VkCommandBuffer commandBuffer,
- const VkResolveImageInfo2* pResolveImageInfo) {
- AEMU_SCOPED_TRACE("vkCmdResolveImage2KHR");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkResolveImageInfo2> internal_pResolveImageInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pResolveImageInfo[i] = pResolveImageInfo[i];
- /* VkResolveImageInfo2::srcImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
- internal_pResolveImageInfo[i].srcImage);
- internal_pResolveImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
- /* VkResolveImageInfo2::dstImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
- internal_pResolveImageInfo[i].dstImage);
- internal_pResolveImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
- }
- vkEnc->vkCmdResolveImage2KHR(gfxstream_commandBuffer->internal_object,
- internal_pResolveImageInfo.data(), true /* do lock */);
- }
-}
-#endif
-#ifdef VK_KHR_format_feature_flags2
-#endif
-#ifdef VK_KHR_maintenance4
-void gfxstream_vk_GetDeviceBufferMemoryRequirementsKHR(
- VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirementsKHR");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceBufferMemoryRequirementsKHR(gfxstream_device->internal_object, pInfo,
- pMemoryRequirements, true /* do lock */);
- }
-}
-void gfxstream_vk_GetDeviceImageMemoryRequirementsKHR(VkDevice device,
- const VkDeviceImageMemoryRequirements* pInfo,
- VkMemoryRequirements2* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirementsKHR");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageMemoryRequirementsKHR(gfxstream_device->internal_object, pInfo,
- pMemoryRequirements, true /* do lock */);
- }
-}
-void gfxstream_vk_GetDeviceImageSparseMemoryRequirementsKHR(
- VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
- uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirementsKHR");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageSparseMemoryRequirementsKHR(
- gfxstream_device->internal_object, pInfo, pSparseMemoryRequirementCount,
- pSparseMemoryRequirements, true /* do lock */);
- }
-}
-#endif
-#ifdef VK_KHR_maintenance5
-void gfxstream_vk_CmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
- VkDeviceSize offset, VkDeviceSize size,
- VkIndexType indexType) {
- AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer2KHR");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdBindIndexBuffer2KHR(gfxstream_commandBuffer->internal_object,
- gfxstream_buffer->internal_object, offset, size, indexType,
- true /* do lock */);
- }
-}
-void gfxstream_vk_GetRenderingAreaGranularityKHR(VkDevice device,
- const VkRenderingAreaInfoKHR* pRenderingAreaInfo,
- VkExtent2D* pGranularity) {
- AEMU_SCOPED_TRACE("vkGetRenderingAreaGranularityKHR");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetRenderingAreaGranularityKHR(gfxstream_device->internal_object,
- pRenderingAreaInfo, pGranularity,
- true /* do lock */);
- }
-}
-void gfxstream_vk_GetDeviceImageSubresourceLayoutKHR(VkDevice device,
- const VkDeviceImageSubresourceInfoKHR* pInfo,
- VkSubresourceLayout2KHR* pLayout) {
- AEMU_SCOPED_TRACE("vkGetDeviceImageSubresourceLayoutKHR");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageSubresourceLayoutKHR(gfxstream_device->internal_object, pInfo,
- pLayout, true /* do lock */);
- }
-}
-void gfxstream_vk_GetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
- const VkImageSubresource2KHR* pSubresource,
- VkSubresourceLayout2KHR* pLayout) {
- AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout2KHR");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSubresourceLayout2KHR(gfxstream_device->internal_object,
- gfxstream_image->internal_object, pSubresource,
- pLayout, true /* do lock */);
- }
-}
-#endif
-#ifdef VK_ANDROID_native_buffer
-VkResult gfxstream_vk_GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
- VkImageUsageFlags imageUsage,
- int* grallocUsage) {
- AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID");
- VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkGetSwapchainGrallocUsageANDROID_VkResult_return =
- vkEnc->vkGetSwapchainGrallocUsageANDROID(gfxstream_device->internal_object, format,
- imageUsage, grallocUsage, true /* do lock */);
- }
- return vkGetSwapchainGrallocUsageANDROID_VkResult_return;
-}
-VkResult gfxstream_vk_AcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd,
- VkSemaphore semaphore, VkFence fence) {
- AEMU_SCOPED_TRACE("vkAcquireImageANDROID");
- VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
- VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore, semaphore);
- VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(
- gfxstream_device->internal_object, gfxstream_image->internal_object, nativeFenceFd,
- gfxstream_semaphore ? gfxstream_semaphore->internal_object : VK_NULL_HANDLE,
- gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
- true /* do lock */);
- }
- return vkAcquireImageANDROID_VkResult_return;
-}
-VkResult gfxstream_vk_QueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount,
- const VkSemaphore* pWaitSemaphores,
- VkImage image, int* pNativeFenceFd) {
- AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROID");
- VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
- {
- auto vkEnc =
- gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
- std::vector<VkSemaphore> internal_pWaitSemaphores(waitSemaphoreCount);
- for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
- if (pWaitSemaphores) {
- VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_pWaitSemaphores,
- pWaitSemaphores[i]);
- internal_pWaitSemaphores[i] = gfxstream_pWaitSemaphores->internal_object;
- }
- }
- auto resources = gfxstream::vk::ResourceTracker::get();
- vkQueueSignalReleaseImageANDROID_VkResult_return =
- resources->on_vkQueueSignalReleaseImageANDROID(
- vkEnc, VK_SUCCESS, gfxstream_queue->internal_object, waitSemaphoreCount,
- internal_pWaitSemaphores.data(), gfxstream_image->internal_object, pNativeFenceFd);
- }
- return vkQueueSignalReleaseImageANDROID_VkResult_return;
-}
-VkResult gfxstream_vk_GetSwapchainGrallocUsage2ANDROID(
- VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
- VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage,
- uint64_t* grallocProducerUsage) {
- AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsage2ANDROID");
- VkResult vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkGetSwapchainGrallocUsage2ANDROID_VkResult_return =
- vkEnc->vkGetSwapchainGrallocUsage2ANDROID(
- gfxstream_device->internal_object, format, imageUsage, swapchainImageUsage,
- grallocConsumerUsage, grallocProducerUsage, true /* do lock */);
- }
- return vkGetSwapchainGrallocUsage2ANDROID_VkResult_return;
-}
-#endif
-#ifdef VK_EXT_transform_feedback
-void gfxstream_vk_CmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer,
- uint32_t firstBinding, uint32_t bindingCount,
- const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets,
- const VkDeviceSize* pSizes) {
- AEMU_SCOPED_TRACE("vkCmdBindTransformFeedbackBuffersEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkBuffer> internal_pBuffers(bindingCount);
- for (uint32_t i = 0; i < bindingCount; ++i) {
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pBuffers, pBuffers[i]);
- internal_pBuffers[i] = gfxstream_pBuffers->internal_object;
- }
- vkEnc->vkCmdBindTransformFeedbackBuffersEXT(
- gfxstream_commandBuffer->internal_object, firstBinding, bindingCount,
- internal_pBuffers.data(), pOffsets, pSizes, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer,
- uint32_t firstCounterBuffer,
- uint32_t counterBufferCount,
- const VkBuffer* pCounterBuffers,
- const VkDeviceSize* pCounterBufferOffsets) {
- AEMU_SCOPED_TRACE("vkCmdBeginTransformFeedbackEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkBuffer> internal_pCounterBuffers(counterBufferCount);
- for (uint32_t i = 0; i < counterBufferCount; ++i) {
- if (pCounterBuffers) {
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pCounterBuffers, pCounterBuffers[i]);
- internal_pCounterBuffers[i] = gfxstream_pCounterBuffers->internal_object;
- }
- }
- vkEnc->vkCmdBeginTransformFeedbackEXT(
- gfxstream_commandBuffer->internal_object, firstCounterBuffer, counterBufferCount,
- internal_pCounterBuffers.data(), pCounterBufferOffsets, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
- uint32_t firstCounterBuffer,
- uint32_t counterBufferCount,
- const VkBuffer* pCounterBuffers,
- const VkDeviceSize* pCounterBufferOffsets) {
- AEMU_SCOPED_TRACE("vkCmdEndTransformFeedbackEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkBuffer> internal_pCounterBuffers(counterBufferCount);
- for (uint32_t i = 0; i < counterBufferCount; ++i) {
- if (pCounterBuffers) {
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pCounterBuffers, pCounterBuffers[i]);
- internal_pCounterBuffers[i] = gfxstream_pCounterBuffers->internal_object;
- }
- }
- vkEnc->vkCmdEndTransformFeedbackEXT(
- gfxstream_commandBuffer->internal_object, firstCounterBuffer, counterBufferCount,
- internal_pCounterBuffers.data(), pCounterBufferOffsets, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
- uint32_t query, VkQueryControlFlags flags,
- uint32_t index) {
- AEMU_SCOPED_TRACE("vkCmdBeginQueryIndexedEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdBeginQueryIndexedEXT(gfxstream_commandBuffer->internal_object,
- gfxstream_queryPool->internal_object, query, flags, index,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
- uint32_t query, uint32_t index) {
- AEMU_SCOPED_TRACE("vkCmdEndQueryIndexedEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdEndQueryIndexedEXT(gfxstream_commandBuffer->internal_object,
- gfxstream_queryPool->internal_object, query, index,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount,
- uint32_t firstInstance, VkBuffer counterBuffer,
- VkDeviceSize counterBufferOffset,
- uint32_t counterOffset, uint32_t vertexStride) {
- AEMU_SCOPED_TRACE("vkCmdDrawIndirectByteCountEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_counterBuffer, counterBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdDrawIndirectByteCountEXT(
- gfxstream_commandBuffer->internal_object, instanceCount, firstInstance,
- gfxstream_counterBuffer->internal_object, counterBufferOffset, counterOffset,
- vertexStride, true /* do lock */);
- }
-}
-#endif
-#ifdef VK_AMD_gpu_shader_half_float
-#endif
-#ifdef VK_EXT_texture_compression_astc_hdr
-#endif
-#ifdef VK_EXT_depth_clip_enable
-#endif
-#ifdef VK_EXT_swapchain_colorspace
-#endif
-#ifdef VK_EXT_queue_family_foreign
-#endif
-#ifdef VK_EXT_debug_utils
-#endif
-#ifdef VK_ANDROID_external_memory_android_hardware_buffer
-#endif
-#ifdef VK_EXT_inline_uniform_block
-#endif
-#ifdef VK_EXT_shader_stencil_export
-#endif
-#ifdef VK_EXT_vertex_attribute_divisor
-#endif
-#ifdef VK_EXT_pipeline_creation_feedback
-#endif
-#ifdef VK_NV_shader_subgroup_partitioned
-#endif
-#ifdef VK_EXT_metal_surface
-#endif
-#ifdef VK_EXT_fragment_density_map
-#endif
-#ifdef VK_EXT_scalar_block_layout
-#endif
-#ifdef VK_EXT_subgroup_size_control
-#endif
-#ifdef VK_EXT_tooling_info
-VkResult gfxstream_vk_GetPhysicalDeviceToolPropertiesEXT(
- VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
- VkPhysicalDeviceToolProperties* pToolProperties) {
- AEMU_SCOPED_TRACE("vkGetPhysicalDeviceToolPropertiesEXT");
- VkResult vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return =
- vkEnc->vkGetPhysicalDeviceToolPropertiesEXT(gfxstream_physicalDevice->internal_object,
- pToolCount, pToolProperties,
- true /* do lock */);
- }
- return vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return;
-}
-#endif
-#ifdef VK_EXT_validation_features
-#endif
-#ifdef VK_EXT_provoking_vertex
-#endif
-#ifdef VK_EXT_line_rasterization
-void gfxstream_vk_CmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
- uint16_t lineStipplePattern) {
- AEMU_SCOPED_TRACE("vkCmdSetLineStippleEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetLineStippleEXT(gfxstream_commandBuffer->internal_object, lineStippleFactor,
- lineStipplePattern, true /* do lock */);
- }
-}
-#endif
-#ifdef VK_EXT_index_type_uint8
-#endif
-#ifdef VK_EXT_extended_dynamic_state
-void gfxstream_vk_CmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
- AEMU_SCOPED_TRACE("vkCmdSetCullModeEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetCullModeEXT(gfxstream_commandBuffer->internal_object, cullMode,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
- AEMU_SCOPED_TRACE("vkCmdSetFrontFaceEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetFrontFaceEXT(gfxstream_commandBuffer->internal_object, frontFace,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
- VkPrimitiveTopology primitiveTopology) {
- AEMU_SCOPED_TRACE("vkCmdSetPrimitiveTopologyEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetPrimitiveTopologyEXT(gfxstream_commandBuffer->internal_object,
- primitiveTopology, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount,
- const VkViewport* pViewports) {
- AEMU_SCOPED_TRACE("vkCmdSetViewportWithCountEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetViewportWithCountEXT(gfxstream_commandBuffer->internal_object, viewportCount,
- pViewports, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount,
- const VkRect2D* pScissors) {
- AEMU_SCOPED_TRACE("vkCmdSetScissorWithCountEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetScissorWithCountEXT(gfxstream_commandBuffer->internal_object, scissorCount,
- pScissors, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
- uint32_t bindingCount, const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
- const VkDeviceSize* pStrides) {
- AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers2EXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkBuffer> internal_pBuffers(bindingCount);
- for (uint32_t i = 0; i < bindingCount; ++i) {
- if (pBuffers) {
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pBuffers, pBuffers[i]);
- internal_pBuffers[i] = gfxstream_pBuffers->internal_object;
- }
- }
- vkEnc->vkCmdBindVertexBuffers2EXT(gfxstream_commandBuffer->internal_object, firstBinding,
- bindingCount, internal_pBuffers.data(), pOffsets, pSizes,
- pStrides, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthTestEnable) {
- AEMU_SCOPED_TRACE("vkCmdSetDepthTestEnableEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetDepthTestEnableEXT(gfxstream_commandBuffer->internal_object, depthTestEnable,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthWriteEnable) {
- AEMU_SCOPED_TRACE("vkCmdSetDepthWriteEnableEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetDepthWriteEnableEXT(gfxstream_commandBuffer->internal_object,
- depthWriteEnable, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,
- VkCompareOp depthCompareOp) {
- AEMU_SCOPED_TRACE("vkCmdSetDepthCompareOpEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetDepthCompareOpEXT(gfxstream_commandBuffer->internal_object, depthCompareOp,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthBoundsTestEnable) {
- AEMU_SCOPED_TRACE("vkCmdSetDepthBoundsTestEnableEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetDepthBoundsTestEnableEXT(gfxstream_commandBuffer->internal_object,
- depthBoundsTestEnable, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 stencilTestEnable) {
- AEMU_SCOPED_TRACE("vkCmdSetStencilTestEnableEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetStencilTestEnableEXT(gfxstream_commandBuffer->internal_object,
- stencilTestEnable, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
- VkStencilOp failOp, VkStencilOp passOp,
- VkStencilOp depthFailOp, VkCompareOp compareOp) {
- AEMU_SCOPED_TRACE("vkCmdSetStencilOpEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetStencilOpEXT(gfxstream_commandBuffer->internal_object, faceMask, failOp,
- passOp, depthFailOp, compareOp, true /* do lock */);
- }
-}
-#endif
-#ifdef VK_EXT_host_image_copy
-VkResult gfxstream_vk_CopyMemoryToImageEXT(
- VkDevice device, const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo) {
- AEMU_SCOPED_TRACE("vkCopyMemoryToImageEXT");
- VkResult vkCopyMemoryToImageEXT_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkCopyMemoryToImageInfoEXT> internal_pCopyMemoryToImageInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pCopyMemoryToImageInfo[i] = pCopyMemoryToImageInfo[i];
- /* VkCopyMemoryToImageInfoEXT::dstImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
- internal_pCopyMemoryToImageInfo[i].dstImage);
- internal_pCopyMemoryToImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
- }
- vkCopyMemoryToImageEXT_VkResult_return = vkEnc->vkCopyMemoryToImageEXT(
- gfxstream_device->internal_object, internal_pCopyMemoryToImageInfo.data(),
- true /* do lock */);
- }
- return vkCopyMemoryToImageEXT_VkResult_return;
-}
-VkResult gfxstream_vk_CopyImageToMemoryEXT(
- VkDevice device, const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo) {
- AEMU_SCOPED_TRACE("vkCopyImageToMemoryEXT");
- VkResult vkCopyImageToMemoryEXT_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkCopyImageToMemoryInfoEXT> internal_pCopyImageToMemoryInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pCopyImageToMemoryInfo[i] = pCopyImageToMemoryInfo[i];
- /* VkCopyImageToMemoryInfoEXT::srcImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
- internal_pCopyImageToMemoryInfo[i].srcImage);
- internal_pCopyImageToMemoryInfo[i].srcImage = gfxstream_srcImage->internal_object;
- }
- vkCopyImageToMemoryEXT_VkResult_return = vkEnc->vkCopyImageToMemoryEXT(
- gfxstream_device->internal_object, internal_pCopyImageToMemoryInfo.data(),
- true /* do lock */);
- }
- return vkCopyImageToMemoryEXT_VkResult_return;
-}
-VkResult gfxstream_vk_CopyImageToImageEXT(VkDevice device,
- const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) {
- AEMU_SCOPED_TRACE("vkCopyImageToImageEXT");
- VkResult vkCopyImageToImageEXT_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkCopyImageToImageInfoEXT> internal_pCopyImageToImageInfo(1);
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pCopyImageToImageInfo[i] = pCopyImageToImageInfo[i];
- /* VkCopyImageToImageInfoEXT::srcImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
- internal_pCopyImageToImageInfo[i].srcImage);
- internal_pCopyImageToImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
- /* VkCopyImageToImageInfoEXT::dstImage */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
- internal_pCopyImageToImageInfo[i].dstImage);
- internal_pCopyImageToImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
- }
- vkCopyImageToImageEXT_VkResult_return =
- vkEnc->vkCopyImageToImageEXT(gfxstream_device->internal_object,
- internal_pCopyImageToImageInfo.data(), true /* do lock */);
- }
- return vkCopyImageToImageEXT_VkResult_return;
-}
-VkResult gfxstream_vk_TransitionImageLayoutEXT(
- VkDevice device, uint32_t transitionCount,
- const VkHostImageLayoutTransitionInfoEXT* pTransitions) {
- AEMU_SCOPED_TRACE("vkTransitionImageLayoutEXT");
- VkResult vkTransitionImageLayoutEXT_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkHostImageLayoutTransitionInfoEXT> internal_pTransitions(transitionCount);
- for (uint32_t i = 0; i < transitionCount; ++i) {
- internal_pTransitions[i] = pTransitions[i];
- /* VkHostImageLayoutTransitionInfoEXT::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pTransitions[i].image);
- internal_pTransitions[i].image = gfxstream_image->internal_object;
- }
- vkTransitionImageLayoutEXT_VkResult_return =
- vkEnc->vkTransitionImageLayoutEXT(gfxstream_device->internal_object, transitionCount,
- internal_pTransitions.data(), true /* do lock */);
- }
- return vkTransitionImageLayoutEXT_VkResult_return;
-}
-void gfxstream_vk_GetImageSubresourceLayout2EXT(VkDevice device, VkImage image,
- const VkImageSubresource2KHR* pSubresource,
- VkSubresourceLayout2KHR* pLayout) {
- AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout2EXT");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSubresourceLayout2EXT(gfxstream_device->internal_object,
- gfxstream_image->internal_object, pSubresource,
- pLayout, true /* do lock */);
- }
-}
-#endif
-#ifdef VK_EXT_swapchain_maintenance1
-#endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-#endif
-#ifdef VK_EXT_texel_buffer_alignment
-#endif
-#ifdef VK_EXT_device_memory_report
-#endif
-#ifdef VK_EXT_robustness2
-#endif
-#ifdef VK_EXT_custom_border_color
-#endif
-#ifdef VK_EXT_private_data
-VkResult gfxstream_vk_CreatePrivateDataSlotEXT(VkDevice device,
- const VkPrivateDataSlotCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPrivateDataSlot* pPrivateDataSlot) {
- AEMU_SCOPED_TRACE("vkCreatePrivateDataSlotEXT");
- VkResult vkCreatePrivateDataSlotEXT_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkCreatePrivateDataSlotEXT_VkResult_return =
- vkEnc->vkCreatePrivateDataSlotEXT(gfxstream_device->internal_object, pCreateInfo,
- pAllocator, pPrivateDataSlot, true /* do lock */);
- }
- return vkCreatePrivateDataSlotEXT_VkResult_return;
-}
-void gfxstream_vk_DestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlotEXT");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyPrivateDataSlotEXT(gfxstream_device->internal_object, privateDataSlot,
- pAllocator, true /* do lock */);
- }
-}
-VkResult gfxstream_vk_SetPrivateDataEXT(VkDevice device, VkObjectType objectType,
- uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
- uint64_t data) {
- AEMU_SCOPED_TRACE("vkSetPrivateDataEXT");
- VkResult vkSetPrivateDataEXT_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkSetPrivateDataEXT_VkResult_return =
- vkEnc->vkSetPrivateDataEXT(gfxstream_device->internal_object, objectType, objectHandle,
- privateDataSlot, data, true /* do lock */);
- }
- return vkSetPrivateDataEXT_VkResult_return;
-}
-void gfxstream_vk_GetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
- VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
- AEMU_SCOPED_TRACE("vkGetPrivateDataEXT");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPrivateDataEXT(gfxstream_device->internal_object, objectType, objectHandle,
- privateDataSlot, pData, true /* do lock */);
- }
-}
-#endif
-#ifdef VK_EXT_pipeline_creation_cache_control
-#endif
-#ifdef VK_EXT_graphics_pipeline_library
-#endif
-#ifdef VK_EXT_ycbcr_2plane_444_formats
-#endif
-#ifdef VK_EXT_image_robustness
-#endif
-#ifdef VK_EXT_image_compression_control
-#endif
-#ifdef VK_EXT_4444_formats
-#endif
-#ifdef VK_EXT_primitive_topology_list_restart
-#endif
-#ifdef VK_EXT_extended_dynamic_state2
-void gfxstream_vk_CmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer,
- uint32_t patchControlPoints) {
- AEMU_SCOPED_TRACE("vkCmdSetPatchControlPointsEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetPatchControlPointsEXT(gfxstream_commandBuffer->internal_object,
- patchControlPoints, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 rasterizerDiscardEnable) {
- AEMU_SCOPED_TRACE("vkCmdSetRasterizerDiscardEnableEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetRasterizerDiscardEnableEXT(gfxstream_commandBuffer->internal_object,
- rasterizerDiscardEnable, true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 depthBiasEnable) {
- AEMU_SCOPED_TRACE("vkCmdSetDepthBiasEnableEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetDepthBiasEnableEXT(gfxstream_commandBuffer->internal_object, depthBiasEnable,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
- AEMU_SCOPED_TRACE("vkCmdSetLogicOpEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetLogicOpEXT(gfxstream_commandBuffer->internal_object, logicOp,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
- VkBool32 primitiveRestartEnable) {
- AEMU_SCOPED_TRACE("vkCmdSetPrimitiveRestartEnableEXT");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCmdSetPrimitiveRestartEnableEXT(gfxstream_commandBuffer->internal_object,
- primitiveRestartEnable, true /* do lock */);
- }
-}
-#endif
-#ifdef VK_GOOGLE_gfxstream
-VkResult gfxstream_vk_MapMemoryIntoAddressSpaceGOOGLE(VkDevice device, VkDeviceMemory memory,
- uint64_t* pAddress) {
- AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE");
- VkResult vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return =
- vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(gfxstream_device->internal_object,
- gfxstream_memory->internal_object, pAddress,
- true /* do lock */);
- }
- return vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return;
-}
-void gfxstream_vk_UpdateDescriptorSetWithTemplateSizedGOOGLE(
- VkDevice device, VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
- uint32_t bufferInfoCount, uint32_t bufferViewCount, const uint32_t* pImageInfoEntryIndices,
- const uint32_t* pBufferInfoEntryIndices, const uint32_t* pBufferViewEntryIndices,
- const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos,
- const VkBufferView* pBufferViews) {
- AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
- descriptorUpdateTemplate);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkDescriptorImageInfo> internal_pImageInfos(imageInfoCount);
- for (uint32_t i = 0; i < imageInfoCount; ++i) {
- if (pImageInfos) {
- internal_pImageInfos[i] = pImageInfos[i];
- /* VkDescriptorImageInfo::imageView */
- if (internal_pImageInfos[i].imageView) {
- VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
- internal_pImageInfos[i].imageView);
- internal_pImageInfos[i].imageView = gfxstream_imageView->internal_object;
- }
- }
- }
- std::vector<VkDescriptorBufferInfo> internal_pBufferInfos(bufferInfoCount);
- for (uint32_t i = 0; i < bufferInfoCount; ++i) {
- if (pBufferInfos) {
- internal_pBufferInfos[i] = pBufferInfos[i];
- /* VkDescriptorBufferInfo::buffer */
- if (internal_pBufferInfos[i].buffer) {
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
- internal_pBufferInfos[i].buffer);
- internal_pBufferInfos[i].buffer = gfxstream_buffer->internal_object;
- }
- }
- }
- std::vector<VkBufferView> internal_pBufferViews(bufferViewCount);
- for (uint32_t i = 0; i < bufferViewCount; ++i) {
- if (pBufferViews) {
- VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_pBufferViews, pBufferViews[i]);
- internal_pBufferViews[i] = gfxstream_pBufferViews->internal_object;
- }
- }
- vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
- gfxstream_device->internal_object, descriptorSet,
- gfxstream_descriptorUpdateTemplate->internal_object, imageInfoCount, bufferInfoCount,
- bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices,
- pBufferViewEntryIndices, internal_pImageInfos.data(), internal_pBufferInfos.data(),
- internal_pBufferViews.data(), true /* do lock */);
- }
-}
-void gfxstream_vk_BeginCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
- const VkCommandBufferBeginInfo* pBeginInfo) {
- AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- std::vector<VkCommandBufferBeginInfo> internal_pBeginInfo(1);
- std::vector<VkCommandBufferInheritanceInfo>
- internal_VkCommandBufferBeginInfo_pInheritanceInfo;
- for (uint32_t i = 0; i < 1; ++i) {
- internal_pBeginInfo[i] = pBeginInfo[i];
- /* VkCommandBufferBeginInfo::pInheritanceInfo */
- if (internal_pBeginInfo[i].pInheritanceInfo) {
- internal_VkCommandBufferBeginInfo_pInheritanceInfo[i] =
- internal_pBeginInfo[i].pInheritanceInfo[0];
- /* VkCommandBufferInheritanceInfo::renderPass */
- if (internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass) {
- VK_FROM_HANDLE(
- gfxstream_vk_render_pass, gfxstream_renderPass,
- internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass);
- internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass =
- gfxstream_renderPass->internal_object;
- }
- /* VkCommandBufferInheritanceInfo::framebuffer */
- if (internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer) {
- VK_FROM_HANDLE(
- gfxstream_vk_framebuffer, gfxstream_framebuffer,
- internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer);
- internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer =
- gfxstream_framebuffer->internal_object;
- }
- internal_pBeginInfo[i].pInheritanceInfo =
- &internal_VkCommandBufferBeginInfo_pInheritanceInfo[i];
- }
- }
- vkEnc->vkBeginCommandBufferAsyncGOOGLE(gfxstream_commandBuffer->internal_object,
- internal_pBeginInfo.data(), true /* do lock */);
- }
-}
-void gfxstream_vk_EndCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer) {
- AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkEndCommandBufferAsyncGOOGLE(gfxstream_commandBuffer->internal_object,
- true /* do lock */);
- }
-}
-void gfxstream_vk_ResetCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
- VkCommandBufferResetFlags flags) {
- AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkResetCommandBufferAsyncGOOGLE(gfxstream_commandBuffer->internal_object, flags,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CommandBufferHostSyncGOOGLE(VkCommandBuffer commandBuffer, uint32_t needHostSync,
- uint32_t sequenceNumber) {
- AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE");
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
- gfxstream_commandBuffer->internal_object);
- vkEnc->vkCommandBufferHostSyncGOOGLE(gfxstream_commandBuffer->internal_object, needHostSync,
- sequenceNumber, true /* do lock */);
- }
-}
-VkResult gfxstream_vk_CreateImageWithRequirementsGOOGLE(VkDevice device,
- const VkImageCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkImage* pImage,
- VkMemoryRequirements* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE");
- VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_image* gfxstream_pImage = (struct gfxstream_vk_image*)vk_image_create(
- (vk_device*)gfxstream_device, pCreateInfo, pAllocator, sizeof(struct gfxstream_vk_image));
- vkCreateImageWithRequirementsGOOGLE_VkResult_return =
- gfxstream_pImage ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateImageWithRequirementsGOOGLE_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkCreateImageWithRequirementsGOOGLE_VkResult_return =
- vkEnc->vkCreateImageWithRequirementsGOOGLE(
- gfxstream_device->internal_object, pCreateInfo, pAllocator,
- &gfxstream_pImage->internal_object, pMemoryRequirements, true /* do lock */);
- }
- *pImage = gfxstream_vk_image_to_handle(gfxstream_pImage);
- return vkCreateImageWithRequirementsGOOGLE_VkResult_return;
-}
-VkResult gfxstream_vk_CreateBufferWithRequirementsGOOGLE(
- VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
- VkBuffer* pBuffer, VkMemoryRequirements* pMemoryRequirements) {
- AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE");
- VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- struct gfxstream_vk_buffer* gfxstream_pBuffer = (struct gfxstream_vk_buffer*)vk_buffer_create(
- (vk_device*)gfxstream_device, pCreateInfo, pAllocator, sizeof(struct gfxstream_vk_buffer));
- vkCreateBufferWithRequirementsGOOGLE_VkResult_return =
- gfxstream_pBuffer ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
- if (VK_SUCCESS == vkCreateBufferWithRequirementsGOOGLE_VkResult_return) {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkCreateBufferWithRequirementsGOOGLE_VkResult_return =
- vkEnc->vkCreateBufferWithRequirementsGOOGLE(
- gfxstream_device->internal_object, pCreateInfo, pAllocator,
- &gfxstream_pBuffer->internal_object, pMemoryRequirements, true /* do lock */);
- }
- *pBuffer = gfxstream_vk_buffer_to_handle(gfxstream_pBuffer);
- return vkCreateBufferWithRequirementsGOOGLE_VkResult_return;
-}
-VkResult gfxstream_vk_GetMemoryHostAddressInfoGOOGLE(VkDevice device, VkDeviceMemory memory,
- uint64_t* pAddress, uint64_t* pSize,
- uint64_t* pHostmemId) {
- AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE");
- VkResult vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = vkEnc->vkGetMemoryHostAddressInfoGOOGLE(
- gfxstream_device->internal_object, gfxstream_memory->internal_object, pAddress, pSize,
- pHostmemId, true /* do lock */);
- }
- return vkGetMemoryHostAddressInfoGOOGLE_VkResult_return;
-}
-VkResult gfxstream_vk_FreeMemorySyncGOOGLE(VkDevice device, VkDeviceMemory memory,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE");
- VkResult vkFreeMemorySyncGOOGLE_VkResult_return = (VkResult)0;
- if (VK_NULL_HANDLE == memory) {
- return vkFreeMemorySyncGOOGLE_VkResult_return;
- }
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkFreeMemorySyncGOOGLE_VkResult_return = vkEnc->vkFreeMemorySyncGOOGLE(
- gfxstream_device->internal_object,
- gfxstream_memory ? gfxstream_memory->internal_object : VK_NULL_HANDLE, pAllocator,
- true /* do lock */);
- }
- vk_device_memory_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_memory->vk);
- return vkFreeMemorySyncGOOGLE_VkResult_return;
-}
-void gfxstream_vk_QueueHostSyncGOOGLE(VkQueue queue, uint32_t needHostSync,
- uint32_t sequenceNumber) {
- AEMU_SCOPED_TRACE("vkQueueHostSyncGOOGLE");
- VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
- {
- auto vkEnc =
- gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
- vkEnc->vkQueueHostSyncGOOGLE(gfxstream_queue->internal_object, needHostSync, sequenceNumber,
- true /* do lock */);
- }
-}
-void gfxstream_vk_QueueSubmitAsyncGOOGLE(VkQueue queue, uint32_t submitCount,
- const VkSubmitInfo* pSubmits, VkFence fence) {
- AEMU_SCOPED_TRACE("vkQueueSubmitAsyncGOOGLE");
- VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
- VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
- {
- auto vkEnc =
- gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
- std::vector<VkSubmitInfo> internal_pSubmits(submitCount);
- std::vector<std::vector<VkSemaphore>> internal_VkSubmitInfo_pWaitSemaphores;
- std::vector<std::vector<VkCommandBuffer>> internal_VkSubmitInfo_pCommandBuffers;
- std::vector<std::vector<VkSemaphore>> internal_VkSubmitInfo_pSignalSemaphores;
- for (uint32_t i = 0; i < submitCount; ++i) {
- internal_pSubmits[i] = pSubmits[i];
- /* VkSubmitInfo::pWaitSemaphores */
- internal_VkSubmitInfo_pWaitSemaphores.push_back(std::vector<VkSemaphore>());
- internal_VkSubmitInfo_pWaitSemaphores[i] = transformVkSemaphoreList(
- internal_pSubmits[i].pWaitSemaphores, internal_pSubmits[i].waitSemaphoreCount);
- internal_pSubmits[i].pWaitSemaphores = internal_VkSubmitInfo_pWaitSemaphores[i].data();
- internal_pSubmits[i].waitSemaphoreCount =
- internal_VkSubmitInfo_pWaitSemaphores[i].size();
- /* VkSubmitInfo::pCommandBuffers */
- internal_VkSubmitInfo_pCommandBuffers.push_back(std::vector<VkCommandBuffer>());
- internal_VkSubmitInfo_pCommandBuffers[i].reserve(
- internal_pSubmits[i].commandBufferCount);
- memset(&internal_VkSubmitInfo_pCommandBuffers[i][0], 0,
- sizeof(VkCommandBuffer) * internal_pSubmits[i].commandBufferCount);
- for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferCount; ++j) {
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_pCommandBuffers,
- internal_pSubmits[i].pCommandBuffers[j]);
- internal_VkSubmitInfo_pCommandBuffers[i][j] =
- gfxstream_pCommandBuffers->internal_object;
- }
- internal_pSubmits[i].pCommandBuffers = internal_VkSubmitInfo_pCommandBuffers[i].data();
- /* VkSubmitInfo::pSignalSemaphores */
- internal_VkSubmitInfo_pSignalSemaphores.push_back(std::vector<VkSemaphore>());
- internal_VkSubmitInfo_pSignalSemaphores[i] = transformVkSemaphoreList(
- internal_pSubmits[i].pSignalSemaphores, internal_pSubmits[i].signalSemaphoreCount);
- internal_pSubmits[i].pSignalSemaphores =
- internal_VkSubmitInfo_pSignalSemaphores[i].data();
- internal_pSubmits[i].signalSemaphoreCount =
- internal_VkSubmitInfo_pSignalSemaphores[i].size();
- }
- vkEnc->vkQueueSubmitAsyncGOOGLE(
- gfxstream_queue->internal_object, submitCount, internal_pSubmits.data(),
- gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
- true /* do lock */);
- }
-}
-void gfxstream_vk_QueueWaitIdleAsyncGOOGLE(VkQueue queue) {
- AEMU_SCOPED_TRACE("vkQueueWaitIdleAsyncGOOGLE");
- VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
- {
- auto vkEnc =
- gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
- vkEnc->vkQueueWaitIdleAsyncGOOGLE(gfxstream_queue->internal_object, true /* do lock */);
- }
-}
-void gfxstream_vk_QueueBindSparseAsyncGOOGLE(VkQueue queue, uint32_t bindInfoCount,
- const VkBindSparseInfo* pBindInfo, VkFence fence) {
- AEMU_SCOPED_TRACE("vkQueueBindSparseAsyncGOOGLE");
- VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
- VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
- {
- auto vkEnc =
- gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
- std::vector<VkBindSparseInfo> internal_pBindInfo(bindInfoCount);
- std::vector<std::vector<VkSemaphore>> internal_VkBindSparseInfo_pWaitSemaphores;
- std::vector<std::vector<VkSparseBufferMemoryBindInfo>>
- internal_VkBindSparseInfo_pBufferBinds;
- std::vector<std::vector<VkSparseMemoryBind>> internal_VkSparseBufferMemoryBindInfo_pBinds;
- std::vector<std::vector<VkSparseImageOpaqueMemoryBindInfo>>
- internal_VkBindSparseInfo_pImageOpaqueBinds;
- std::vector<std::vector<VkSparseMemoryBind>>
- internal_VkSparseImageOpaqueMemoryBindInfo_pBinds;
- std::vector<std::vector<VkSparseImageMemoryBindInfo>> internal_VkBindSparseInfo_pImageBinds;
- std::vector<std::vector<VkSparseImageMemoryBind>>
- internal_VkSparseImageMemoryBindInfo_pBinds;
- std::vector<std::vector<VkSemaphore>> internal_VkBindSparseInfo_pSignalSemaphores;
- for (uint32_t i = 0; i < bindInfoCount; ++i) {
- internal_pBindInfo[i] = pBindInfo[i];
- /* VkBindSparseInfo::pWaitSemaphores */
- internal_VkBindSparseInfo_pWaitSemaphores.push_back(std::vector<VkSemaphore>());
- internal_VkBindSparseInfo_pWaitSemaphores[i] = transformVkSemaphoreList(
- internal_pBindInfo[i].pWaitSemaphores, internal_pBindInfo[i].waitSemaphoreCount);
- internal_pBindInfo[i].pWaitSemaphores =
- internal_VkBindSparseInfo_pWaitSemaphores[i].data();
- internal_pBindInfo[i].waitSemaphoreCount =
- internal_VkBindSparseInfo_pWaitSemaphores[i].size();
- /* VkBindSparseInfo::pBufferBinds */
- internal_VkBindSparseInfo_pBufferBinds.push_back(
- std::vector<VkSparseBufferMemoryBindInfo>());
- internal_VkBindSparseInfo_pBufferBinds[i].reserve(
- internal_pBindInfo[i].bufferBindCount);
- memset(&internal_VkBindSparseInfo_pBufferBinds[i][0], 0,
- sizeof(VkSparseBufferMemoryBindInfo) * internal_pBindInfo[i].bufferBindCount);
- for (uint32_t j = 0; j < internal_pBindInfo[i].bufferBindCount; ++j) {
- internal_VkBindSparseInfo_pBufferBinds[i][j] =
- internal_pBindInfo[i].pBufferBinds[j];
- /* VkSparseBufferMemoryBindInfo::buffer */
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
- internal_VkBindSparseInfo_pBufferBinds[i][j].buffer);
- internal_VkBindSparseInfo_pBufferBinds[i][j].buffer =
- gfxstream_buffer->internal_object;
- /* VkSparseBufferMemoryBindInfo::pBinds */
- internal_VkSparseBufferMemoryBindInfo_pBinds.push_back(
- std::vector<VkSparseMemoryBind>());
- internal_VkSparseBufferMemoryBindInfo_pBinds[j].reserve(
- internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount);
- memset(&internal_VkSparseBufferMemoryBindInfo_pBinds[j][0], 0,
- sizeof(VkSparseMemoryBind) *
- internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount);
- for (uint32_t k = 0; k < internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount;
- ++k) {
- internal_VkSparseBufferMemoryBindInfo_pBinds[j][k] =
- internal_VkBindSparseInfo_pBufferBinds[i][j].pBinds[k];
- /* VkSparseMemoryBind::memory */
- if (internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory) {
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
- internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory);
- internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory =
- gfxstream_memory->internal_object;
- }
- }
- internal_VkBindSparseInfo_pBufferBinds[i][j].pBinds =
- internal_VkSparseBufferMemoryBindInfo_pBinds[j].data();
- }
- internal_pBindInfo[i].pBufferBinds = internal_VkBindSparseInfo_pBufferBinds[i].data();
- /* VkBindSparseInfo::pImageOpaqueBinds */
- internal_VkBindSparseInfo_pImageOpaqueBinds.push_back(
- std::vector<VkSparseImageOpaqueMemoryBindInfo>());
- internal_VkBindSparseInfo_pImageOpaqueBinds[i].reserve(
- internal_pBindInfo[i].imageOpaqueBindCount);
- memset(&internal_VkBindSparseInfo_pImageOpaqueBinds[i][0], 0,
- sizeof(VkSparseImageOpaqueMemoryBindInfo) *
- internal_pBindInfo[i].imageOpaqueBindCount);
- for (uint32_t j = 0; j < internal_pBindInfo[i].imageOpaqueBindCount; ++j) {
- internal_VkBindSparseInfo_pImageOpaqueBinds[i][j] =
- internal_pBindInfo[i].pImageOpaqueBinds[j];
- /* VkSparseImageOpaqueMemoryBindInfo::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
- internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].image);
- internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].image =
- gfxstream_image->internal_object;
- /* VkSparseImageOpaqueMemoryBindInfo::pBinds */
- internal_VkSparseImageOpaqueMemoryBindInfo_pBinds.push_back(
- std::vector<VkSparseMemoryBind>());
- internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j].reserve(
- internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount);
- memset(&internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][0], 0,
- sizeof(VkSparseMemoryBind) *
- internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount);
- for (uint32_t l = 0;
- l < internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount; ++l) {
- internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l] =
- internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].pBinds[l];
- /* VkSparseMemoryBind::memory */
- if (internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory) {
- VK_FROM_HANDLE(
- gfxstream_vk_device_memory, gfxstream_memory,
- internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory);
- internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory =
- gfxstream_memory->internal_object;
- }
- }
- internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].pBinds =
- internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j].data();
- }
- internal_pBindInfo[i].pImageOpaqueBinds =
- internal_VkBindSparseInfo_pImageOpaqueBinds[i].data();
- /* VkBindSparseInfo::pImageBinds */
- internal_VkBindSparseInfo_pImageBinds.push_back(
- std::vector<VkSparseImageMemoryBindInfo>());
- internal_VkBindSparseInfo_pImageBinds[i].reserve(internal_pBindInfo[i].imageBindCount);
- memset(&internal_VkBindSparseInfo_pImageBinds[i][0], 0,
- sizeof(VkSparseImageMemoryBindInfo) * internal_pBindInfo[i].imageBindCount);
- for (uint32_t j = 0; j < internal_pBindInfo[i].imageBindCount; ++j) {
- internal_VkBindSparseInfo_pImageBinds[i][j] = internal_pBindInfo[i].pImageBinds[j];
- /* VkSparseImageMemoryBindInfo::image */
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
- internal_VkBindSparseInfo_pImageBinds[i][j].image);
- internal_VkBindSparseInfo_pImageBinds[i][j].image =
- gfxstream_image->internal_object;
- /* VkSparseImageMemoryBindInfo::pBinds */
- internal_VkSparseImageMemoryBindInfo_pBinds.push_back(
- std::vector<VkSparseImageMemoryBind>());
- internal_VkSparseImageMemoryBindInfo_pBinds[j].reserve(
- internal_VkBindSparseInfo_pImageBinds[i][j].bindCount);
- memset(&internal_VkSparseImageMemoryBindInfo_pBinds[j][0], 0,
- sizeof(VkSparseImageMemoryBind) *
- internal_VkBindSparseInfo_pImageBinds[i][j].bindCount);
- for (uint32_t m = 0; m < internal_VkBindSparseInfo_pImageBinds[i][j].bindCount;
- ++m) {
- internal_VkSparseImageMemoryBindInfo_pBinds[j][m] =
- internal_VkBindSparseInfo_pImageBinds[i][j].pBinds[m];
- /* VkSparseImageMemoryBind::memory */
- if (internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory) {
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
- internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory);
- internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory =
- gfxstream_memory->internal_object;
- }
- }
- internal_VkBindSparseInfo_pImageBinds[i][j].pBinds =
- internal_VkSparseImageMemoryBindInfo_pBinds[j].data();
- }
- internal_pBindInfo[i].pImageBinds = internal_VkBindSparseInfo_pImageBinds[i].data();
- /* VkBindSparseInfo::pSignalSemaphores */
- internal_VkBindSparseInfo_pSignalSemaphores.push_back(std::vector<VkSemaphore>());
- internal_VkBindSparseInfo_pSignalSemaphores[i] =
- transformVkSemaphoreList(internal_pBindInfo[i].pSignalSemaphores,
- internal_pBindInfo[i].signalSemaphoreCount);
- internal_pBindInfo[i].pSignalSemaphores =
- internal_VkBindSparseInfo_pSignalSemaphores[i].data();
- internal_pBindInfo[i].signalSemaphoreCount =
- internal_VkBindSparseInfo_pSignalSemaphores[i].size();
- }
- vkEnc->vkQueueBindSparseAsyncGOOGLE(
- gfxstream_queue->internal_object, bindInfoCount, internal_pBindInfo.data(),
- gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
- true /* do lock */);
- }
-}
-void gfxstream_vk_GetLinearImageLayoutGOOGLE(VkDevice device, VkFormat format,
- VkDeviceSize* pOffset,
- VkDeviceSize* pRowPitchAlignment) {
- AEMU_SCOPED_TRACE("vkGetLinearImageLayoutGOOGLE");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetLinearImageLayoutGOOGLE(gfxstream_device->internal_object, format, pOffset,
- pRowPitchAlignment, true /* do lock */);
- }
-}
-void gfxstream_vk_GetLinearImageLayout2GOOGLE(VkDevice device, const VkImageCreateInfo* pCreateInfo,
- VkDeviceSize* pOffset,
- VkDeviceSize* pRowPitchAlignment) {
- AEMU_SCOPED_TRACE("vkGetLinearImageLayout2GOOGLE");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetLinearImageLayout2GOOGLE(gfxstream_device->internal_object, pCreateInfo,
- pOffset, pRowPitchAlignment, true /* do lock */);
- }
-}
-void gfxstream_vk_QueueFlushCommandsGOOGLE(VkQueue queue, VkCommandBuffer commandBuffer,
- VkDeviceSize dataSize, const void* pData) {
- AEMU_SCOPED_TRACE("vkQueueFlushCommandsGOOGLE");
- VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- {
- auto vkEnc =
- gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
- vkEnc->vkQueueFlushCommandsGOOGLE(gfxstream_queue->internal_object,
- gfxstream_commandBuffer->internal_object, dataSize, pData,
- true /* do lock */);
- }
-}
-void gfxstream_vk_CollectDescriptorPoolIdsGOOGLE(VkDevice device, VkDescriptorPool descriptorPool,
- uint32_t* pPoolIdCount, uint64_t* pPoolIds) {
- AEMU_SCOPED_TRACE("vkCollectDescriptorPoolIdsGOOGLE");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool, descriptorPool);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkCollectDescriptorPoolIdsGOOGLE(gfxstream_device->internal_object,
- gfxstream_descriptorPool->internal_object,
- pPoolIdCount, pPoolIds, true /* do lock */);
- }
-}
-void gfxstream_vk_QueueSignalReleaseImageANDROIDAsyncGOOGLE(VkQueue queue,
- uint32_t waitSemaphoreCount,
- const VkSemaphore* pWaitSemaphores,
- VkImage image) {
- AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROIDAsyncGOOGLE");
- VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
- VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
- {
- auto vkEnc =
- gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
- std::vector<VkSemaphore> internal_pWaitSemaphores(waitSemaphoreCount);
- for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
- if (pWaitSemaphores) {
- VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_pWaitSemaphores,
- pWaitSemaphores[i]);
- internal_pWaitSemaphores[i] = gfxstream_pWaitSemaphores->internal_object;
- }
- }
- vkEnc->vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(
- gfxstream_queue->internal_object, waitSemaphoreCount, internal_pWaitSemaphores.data(),
- gfxstream_image->internal_object, true /* do lock */);
- }
-}
-void gfxstream_vk_QueueFlushCommandsFromAuxMemoryGOOGLE(VkQueue queue,
- VkCommandBuffer commandBuffer,
- VkDeviceMemory deviceMemory,
- VkDeviceSize dataOffset,
- VkDeviceSize dataSize) {
- AEMU_SCOPED_TRACE("vkQueueFlushCommandsFromAuxMemoryGOOGLE");
- VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_deviceMemory, deviceMemory);
- {
- auto vkEnc =
- gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
- vkEnc->vkQueueFlushCommandsFromAuxMemoryGOOGLE(
- gfxstream_queue->internal_object, gfxstream_commandBuffer->internal_object,
- gfxstream_deviceMemory->internal_object, dataOffset, dataSize, true /* do lock */);
- }
-}
-VkResult gfxstream_vk_GetBlobGOOGLE(VkDevice device, VkDeviceMemory memory) {
- AEMU_SCOPED_TRACE("vkGetBlobGOOGLE");
- VkResult vkGetBlobGOOGLE_VkResult_return = (VkResult)0;
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- vkGetBlobGOOGLE_VkResult_return =
- vkEnc->vkGetBlobGOOGLE(gfxstream_device->internal_object,
- gfxstream_memory->internal_object, true /* do lock */);
- }
- return vkGetBlobGOOGLE_VkResult_return;
-}
-void gfxstream_vk_UpdateDescriptorSetWithTemplateSized2GOOGLE(
- VkDevice device, VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
- uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount,
- const uint32_t* pImageInfoEntryIndices, const uint32_t* pBufferInfoEntryIndices,
- const uint32_t* pBufferViewEntryIndices, const VkDescriptorImageInfo* pImageInfos,
- const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews,
- const uint8_t* pInlineUniformBlockData) {
- AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSized2GOOGLE");
- VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
- VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
- descriptorUpdateTemplate);
- {
- auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
- std::vector<VkDescriptorImageInfo> internal_pImageInfos(imageInfoCount);
- for (uint32_t i = 0; i < imageInfoCount; ++i) {
- if (pImageInfos) {
- internal_pImageInfos[i] = pImageInfos[i];
- /* VkDescriptorImageInfo::imageView */
- if (internal_pImageInfos[i].imageView) {
- VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
- internal_pImageInfos[i].imageView);
- internal_pImageInfos[i].imageView = gfxstream_imageView->internal_object;
- }
- }
- }
- std::vector<VkDescriptorBufferInfo> internal_pBufferInfos(bufferInfoCount);
- for (uint32_t i = 0; i < bufferInfoCount; ++i) {
- if (pBufferInfos) {
- internal_pBufferInfos[i] = pBufferInfos[i];
- /* VkDescriptorBufferInfo::buffer */
- if (internal_pBufferInfos[i].buffer) {
- VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
- internal_pBufferInfos[i].buffer);
- internal_pBufferInfos[i].buffer = gfxstream_buffer->internal_object;
- }
- }
- }
- std::vector<VkBufferView> internal_pBufferViews(bufferViewCount);
- for (uint32_t i = 0; i < bufferViewCount; ++i) {
- if (pBufferViews) {
- VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_pBufferViews, pBufferViews[i]);
- internal_pBufferViews[i] = gfxstream_pBufferViews->internal_object;
- }
- }
- vkEnc->vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
- gfxstream_device->internal_object, descriptorSet,
- gfxstream_descriptorUpdateTemplate->internal_object, imageInfoCount, bufferInfoCount,
- bufferViewCount, inlineUniformBlockCount, pImageInfoEntryIndices,
- pBufferInfoEntryIndices, pBufferViewEntryIndices, internal_pImageInfos.data(),
- internal_pBufferInfos.data(), internal_pBufferViews.data(), pInlineUniformBlockData,
- true /* do lock */);
- }
-}
-void gfxstream_vk_QueueSubmitAsync2GOOGLE(VkQueue queue, uint32_t submitCount,
- const VkSubmitInfo2* pSubmits, VkFence fence) {
- AEMU_SCOPED_TRACE("vkQueueSubmitAsync2GOOGLE");
- VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
- VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
- {
- auto vkEnc =
- gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
- std::vector<VkSubmitInfo2> internal_pSubmits(submitCount);
- std::vector<std::vector<VkSemaphoreSubmitInfo>> internal_VkSubmitInfo2_pWaitSemaphoreInfos;
- std::vector<std::vector<VkCommandBufferSubmitInfo>>
- internal_VkSubmitInfo2_pCommandBufferInfos;
- std::vector<std::vector<VkSemaphoreSubmitInfo>>
- internal_VkSubmitInfo2_pSignalSemaphoreInfos;
- for (uint32_t i = 0; i < submitCount; ++i) {
- internal_pSubmits[i] = pSubmits[i];
- /* VkSubmitInfo2::pWaitSemaphoreInfos */
- internal_VkSubmitInfo2_pWaitSemaphoreInfos.push_back(
- std::vector<VkSemaphoreSubmitInfo>());
- internal_VkSubmitInfo2_pWaitSemaphoreInfos[i] =
- transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pWaitSemaphoreInfos,
- internal_pSubmits[i].waitSemaphoreInfoCount);
- internal_pSubmits[i].pWaitSemaphoreInfos =
- internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].data();
- internal_pSubmits[i].waitSemaphoreInfoCount =
- internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].size();
- /* VkSubmitInfo2::pCommandBufferInfos */
- internal_VkSubmitInfo2_pCommandBufferInfos.push_back(
- std::vector<VkCommandBufferSubmitInfo>());
- internal_VkSubmitInfo2_pCommandBufferInfos[i].reserve(
- internal_pSubmits[i].commandBufferInfoCount);
- memset(&internal_VkSubmitInfo2_pCommandBufferInfos[i][0], 0,
- sizeof(VkCommandBufferSubmitInfo) * internal_pSubmits[i].commandBufferInfoCount);
- for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferInfoCount; ++j) {
- internal_VkSubmitInfo2_pCommandBufferInfos[i][j] =
- internal_pSubmits[i].pCommandBufferInfos[j];
- /* VkCommandBufferSubmitInfo::commandBuffer */
- VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer,
- internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer);
- internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer =
- gfxstream_commandBuffer->internal_object;
- }
- internal_pSubmits[i].pCommandBufferInfos =
- internal_VkSubmitInfo2_pCommandBufferInfos[i].data();
- /* VkSubmitInfo2::pSignalSemaphoreInfos */
- internal_VkSubmitInfo2_pSignalSemaphoreInfos.push_back(
- std::vector<VkSemaphoreSubmitInfo>());
- internal_VkSubmitInfo2_pSignalSemaphoreInfos[i] =
- transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pSignalSemaphoreInfos,
- internal_pSubmits[i].signalSemaphoreInfoCount);
- internal_pSubmits[i].pSignalSemaphoreInfos =
- internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].data();
- internal_pSubmits[i].signalSemaphoreInfoCount =
- internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].size();
- }
- vkEnc->vkQueueSubmitAsync2GOOGLE(
- gfxstream_queue->internal_object, submitCount, internal_pSubmits.data(),
- gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
- true /* do lock */);
- }
-}
-#endif
-#ifdef VK_EXT_load_store_op_none
-#endif
-#ifdef VK_EXT_image_compression_control_swapchain
-#endif
-#ifdef VK_QNX_external_memory_screen_buffer
-#endif
