diff --git a/cmake/XglOverrides.cmake b/cmake/XglOverrides.cmake index 1c5afdbc..c80e77f7 100644 --- a/cmake/XglOverrides.cmake +++ b/cmake/XglOverrides.cmake @@ -106,39 +106,9 @@ macro(xgl_overrides_pal) set(PAL_BUILD_GPUOPEN ${ICD_GPUOPEN_DEVMODE_BUILD} CACHE BOOL "${PROJECT_NAME} override." FORCE) - set(PAL_BUILD_NAVI12 ${XGL_BUILD_NAVI12} CACHE BOOL "${PROJECT_NAME} override." FORCE) - - set(PAL_BUILD_NAVI14 ON CACHE BOOL "${PROJECT_NAME} override." FORCE) - - set(PAL_BUILD_GFX103 ${XGL_BUILD_GFX103} CACHE BOOL "${PROJECT_NAME} override." FORCE) - - set(PAL_BUILD_NAVI21 ON CACHE BOOL "${PROJECT_NAME} override." FORCE) - - set(PAL_BUILD_NAVI22 ON CACHE BOOL "${PROJECT_NAME} override." FORCE) - - set(PAL_BUILD_NAVI23 ON CACHE BOOL "${PROJECT_NAME} override." FORCE) - - set(PAL_BUILD_NAVI24 ON CACHE BOOL "${PROJECT_NAME} override." FORCE) - - set(PAL_BUILD_REMBRANDT ${XGL_BUILD_REMBRANDT} CACHE BOOL "${PROJECT_NAME} override." FORCE) - - set(PAL_BUILD_RAPHAEL ${XGL_BUILD_RAPHAEL} CACHE BOOL "${PROJECT_NAME} override." FORCE) - - set(PAL_BUILD_MENDOCINO ${XGL_BUILD_MENDOCINO} CACHE BOOL "${PROJECT_NAME} override." FORCE) - -#if VKI_BUILD_NAVI31 - set(PAL_BUILD_NAVI31 ${XGL_BUILD_NAVI31} CACHE BOOL "${PROJECT_NAME} override." FORCE) -#endif - -#if VKI_BUILD_NAVI32 - set(PAL_BUILD_NAVI32 ${XGL_BUILD_NAVI32} CACHE BOOL "${PROJECT_NAME} override." FORCE) -#endif - -#if VKI_BUILD_NAVI33 - set(PAL_BUILD_NAVI33 ${XGL_BUILD_NAVI33} CACHE BOOL "${PROJECT_NAME} override." FORCE) -#endif - - set(PAL_BUILD_PHOENIX1 ${XGL_BUILD_PHOENIX1} CACHE BOOL "${PROJECT_NAME} override." FORCE) + if(XGL_BUILD_NAVI31 OR XGL_BUILD_NAVI32 OR XGL_BUILD_NAVI33 OR XGL_BUILD_PHOENIX1) + set(PAL_BUILD_GFX11 1 CACHE BOOL "${PROJECT_NAME} override." FORCE) + endif() # Wayland set(PAL_BUILD_WAYLAND ${BUILD_WAYLAND_SUPPORT} CACHE BOOL "Build PAL with Wayland support" FORCE) diff --git a/cmake/XglVersions.cmake b/cmake/XglVersions.cmake index d7a93d9e..a8fdc4c9 100644 --- a/cmake/XglVersions.cmake +++ b/cmake/XglVersions.cmake @@ -28,7 +28,7 @@ include_guard() # This will become the value of PAL_CLIENT_INTERFACE_MAJOR_VERSION. It describes the version of the PAL interface # that the ICD supports. PAL uses this value to enable backwards-compatibility for older interface versions. # It must be updated on each PAL promotion after handling all of the interface changes described in palLib.h. -set(ICD_PAL_CLIENT_MAJOR_VERSION "844") +set(ICD_PAL_CLIENT_MAJOR_VERSION "846") # This will become the value of GPUOPEN_CLIENT_INTERFACE_MAJOR_VERSION if ICD_GPUOPEN_DEVMODE_BUILD=1. # It describes the interface version of the gpuopen shared module (part of PAL) that the ICD supports. @@ -37,7 +37,7 @@ set(ICD_GPUOPEN_CLIENT_MAJOR_VERSION "42") #if VKI_RAY_TRACING # This will become the value of GPURT_CLIENT_INTERFACE_MAJOR_VERSION if VKI_RAY_TRACING=1. # It describes the interface version of the GpuRT shared module that the ICD supports. -set(ICD_GPURT_CLIENT_MAJOR_VERSION "41") +set(ICD_GPURT_CLIENT_MAJOR_VERSION "43") #endif # This will become the value of LLPC_CLIENT_INTERFACE_MAJOR_VERSION if ICD_BUILD_LLPC=1. diff --git a/icd/CMakeLists.txt b/icd/CMakeLists.txt index ebe60fb8..4688ec2f 100644 --- a/icd/CMakeLists.txt +++ b/icd/CMakeLists.txt @@ -68,6 +68,10 @@ endif() # PAL add_subdirectory(${XGL_PAL_PATH} ${PROJECT_BINARY_DIR}/pal) +# Add LLPC version before gpurt +include("${XGL_VKGC_PATH}/cmake/llpc_version.cmake") +add_llpc_version_projects() + #if VKI_RAY_TRACING # GPURT if (VKI_RAY_TRACING) diff --git a/icd/Loader/LunarG/Lnx/amd-icd.json b/icd/Loader/LunarG/Lnx/amd-icd.json index 0f7876f9..6fbdc182 100644 --- a/icd/Loader/LunarG/Lnx/amd-icd.json +++ b/icd/Loader/LunarG/Lnx/amd-icd.json @@ -2,13 +2,13 @@ "file_format_version": "1.0.0", "ICD": { "library_path": "@AMDVLK_INSTALL_PATH@/amdvlk@ISABITS@.so", - "api_version": "1.3.273" + "api_version": "1.3.277" }, "layer": { "name": "VK_LAYER_AMD_switchable_graphics_@ISABITS@", "type": "GLOBAL", "library_path": "@AMDVLK_INSTALL_PATH@/amdvlk@ISABITS@.so", - "api_version": "1.3.273", + "api_version": "1.3.277", "implementation_version": "1", "description": "AMD switchable graphics layer", "functions": { diff --git a/icd/api/app_profile.cpp b/icd/api/app_profile.cpp index 536f7b98..17df92c0 100644 --- a/icd/api/app_profile.cpp +++ b/icd/api/app_profile.cpp @@ -725,12 +725,24 @@ constexpr AppProfilePatternEntry AppNameDetroit = "detroitbecomehuman" }; -constexpr AppProfilePatternEntry AppEngineQuanticDream = +constexpr AppProfilePatternEntry AppEngineQuanticDream { PatternEngineNameLower, "quantic dream engine" }; +constexpr AppProfilePatternEntry AppNameEnshrouded = +{ + PatternAppNameLower, + "enshrouded" +}; + +constexpr AppProfilePatternEntry AppEngineHolistic = +{ + PatternEngineNameLower, + "holistic" +}; + constexpr AppProfilePatternEntry PatternEnd = {}; // This is a table of patterns. The first matching pattern in this table will be returned. @@ -1465,6 +1477,23 @@ AppProfilePattern AppPatternTable[] = } }, + { + AppProfile::Enshrouded, + { + AppNameEnshrouded, + AppEngineHolistic, + PatternEnd + } + }, + + { + AppProfile::HolisticEngine, + { + AppEngineHolistic, + PatternEnd + } + }, + { AppProfile::Zink, { diff --git a/icd/api/barrier_policy.cpp b/icd/api/barrier_policy.cpp index 552d3608..fc7f6d3a 100644 --- a/icd/api/barrier_policy.cpp +++ b/icd/api/barrier_policy.cpp @@ -112,6 +112,7 @@ class LayoutUsageHelper InitEntry(VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT, Pal::LayoutShaderRead | Pal::LayoutShaderWrite); + } // Return layout usage index corresponding to the specified layout. diff --git a/icd/api/color_space_helper.cpp b/icd/api/color_space_helper.cpp index 837c39bd..abb15d5b 100644 --- a/icd/api/color_space_helper.cpp +++ b/icd/api/color_space_helper.cpp @@ -51,12 +51,12 @@ struct LookupDefines const LookupDefines colorspaceLookup[] = { - { Pal::ScreenColorSpace::CsSrgb, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, FmtSupport::Fmt_KnownSRGB }, + { Pal::ScreenColorSpace::CsSrgb, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, FmtSupport::Fmt_8bpc }, { Pal::ScreenColorSpace::CsBt709, VK_COLOR_SPACE_BT709_NONLINEAR_EXT, FmtSupport::Fmt_All }, { Pal::ScreenColorSpace::TfHlg, VK_COLOR_SPACE_HDR10_HLG_EXT, FmtSupport::Fmt_KnownHDR }, - { Pal::ScreenColorSpace::TfPq2084, VK_COLOR_SPACE_HDR10_ST2084_EXT, FmtSupport::Fmt_10bpc_unorm }, + { Pal::ScreenColorSpace::TfPq2084, VK_COLOR_SPACE_HDR10_ST2084_EXT, FmtSupport::Fmt_10bpc }, { Pal::ScreenColorSpace::TfDolbyVision, VK_COLOR_SPACE_DOLBYVISION_EXT, FmtSupport::Fmt_8bpc_unorm }, - { Pal::ScreenColorSpace::CsBt2020, VK_COLOR_SPACE_BT2020_LINEAR_EXT, FmtSupport::Fmt_10bpc_unorm }, + { Pal::ScreenColorSpace::CsBt2020, VK_COLOR_SPACE_BT2020_LINEAR_EXT, FmtSupport::Fmt_10bpc }, { Pal::ScreenColorSpace::CsAdobe, VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT, FmtSupport::Fmt_All }, { Pal::ScreenColorSpace::CsDciP3, VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT, FmtSupport::Fmt_All }, { Pal::ScreenColorSpace::CsScrgb, VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT, FmtSupport::Fmt_16bpc_sfloat }, @@ -140,16 +140,10 @@ ColorSpaceHelper::FmtSupport ColorSpaceHelper::GetBitFormat(Pal::ChNumFormat pal fmt = Fmt_9bpc; break; case 10: + fmt = Fmt_10bpc; + break; case 11: - if (Pal::Formats::IsSrgb(palFormat)) - { - fmt = Fmt_10bpc_srgb; - } - else - { - VK_ASSERT(Pal::Formats::IsUnorm(palFormat)); - fmt = Fmt_10bpc_unorm; - } + fmt = Fmt_10bpc; break; case 12: fmt = Fmt_12bpc; diff --git a/icd/api/compiler_solution.cpp b/icd/api/compiler_solution.cpp index 611f1997..d20068c3 100644 --- a/icd/api/compiler_solution.cpp +++ b/icd/api/compiler_solution.cpp @@ -287,8 +287,9 @@ void CompilerSolution::SetRayTracingFunctionName( // ===================================================================================================================== // Parse and update RayTracingFunctionName of all funcTypes void CompilerSolution::UpdateRayTracingFunctionNames( - const Device* pDevice, - Vkgc::RtState* pRtState) + const Device* pDevice, + Pal::RayTracingIpLevel rayTracingIp, + Vkgc::RtState* pRtState) { VkResult result = VK_ERROR_UNKNOWN; GpuRt::IDevice* pGpurtDevice = pDevice->RayTrace()->GpuRt(DefaultDeviceIndex); @@ -298,28 +299,6 @@ void CompilerSolution::UpdateRayTracingFunctionNames( const RuntimeSettings& settings = pDevice->VkPhysicalDevice(DefaultDeviceIndex)->GetRuntimeSettings(); auto pTable = &pRtState->gpurtFuncTable; - Pal::RayTracingIpLevel rayTracingIp = - pDevice->VkPhysicalDevice(DefaultDeviceIndex)->PalProperties().gfxipProperties.rayTracingIp; - - // Optionally, override RTIP level based on software emulation setting - switch (settings.emulatedRtIpLevel) - { - case EmulatedRtIpLevelNone: - break; - case HardwareRtIpLevel1_1: - case EmulatedRtIpLevel1_1: - rayTracingIp = Pal::RayTracingIpLevel::RtIp1_1; - break; -#if VKI_BUILD_GFX11 - case EmulatedRtIpLevel2_0: - rayTracingIp = Pal::RayTracingIpLevel::RtIp2_0; - break; -#endif - default: - VK_ASSERT(false); - break; - } - GpuRt::EntryFunctionTable entryFuncTable = {}; result = PalToVkResult(pGpurtDevice->QueryRayTracingEntryFunctionTable(rayTracingIp, &entryFuncTable)); diff --git a/icd/api/compiler_solution_llpc.cpp b/icd/api/compiler_solution_llpc.cpp index b26c9a9b..0a6768a3 100644 --- a/icd/api/compiler_solution_llpc.cpp +++ b/icd/api/compiler_solution_llpc.cpp @@ -132,8 +132,6 @@ VkResult CompilerSolutionLlpc::BuildShaderModule( VkShaderModuleCreateFlags flags, VkShaderModuleCreateFlags internalShaderFlags, const Vkgc::BinaryData& shaderBinary, - const bool adaptForFastLink, - bool isInternal, ShaderModuleHandle* pShaderModule, const PipelineOptimizerKey& profileKey) { @@ -409,6 +407,7 @@ VkResult CompilerSolutionLlpc::CreateColorExportBinary( auto pPipelineBuildInfo = &pCreateInfo->pipelineInfo; pPipelineBuildInfo->pInstance = pInstance; pPipelineBuildInfo->pfnOutputAlloc = AllocateShaderOutput; + pPipelineBuildInfo->pipelineApiHash = pCreateInfo->libraryHash[GraphicsLibraryColorExport]; VK_ASSERT(pCreateInfo->pBinaryMetadata->pFsOutputMetaData != nullptr); Vkgc::Result llpcResult = m_pLlpc->BuildColorExportShader(pPipelineBuildInfo, @@ -439,15 +438,14 @@ VkResult CompilerSolutionLlpc::CreateColorExportBinary( VkResult CompilerSolutionLlpc::CreateGraphicsShaderBinary( const Device* pDevice, PipelineCache* pPipelineCache, - const ShaderStage stage, + GraphicsLibraryType gplType, GraphicsPipelineBinaryCreateInfo* pCreateInfo, void* pPipelineDumpHandle, - ShaderModuleHandle* pShaderModule) + GplModuleState* pModuleState) { VkResult result = VK_SUCCESS; Util::MetroHash::Hash cacheId = {}; Vkgc::BinaryData shaderLibraryBinary = {}; - GraphicsLibraryType gplType = GetGraphicsLibraryType(stage); bool hitCache = false; bool hitAppCache = false; @@ -484,7 +482,7 @@ VkResult CompilerSolutionLlpc::CreateGraphicsShaderBinary( if (pPipelineCache != nullptr) { // Update the shader feedback - PipelineCreationFeedback* pStageFeedBack = &pCreateInfo->stageFeedback[stage]; + PipelineCreationFeedback* pStageFeedBack = &pCreateInfo->stageFeedback[pModuleState->stage]; pStageFeedBack->feedbackValid = true; pStageFeedBack->hitApplicationCache = hitAppCache; } @@ -497,11 +495,11 @@ VkResult CompilerSolutionLlpc::CreateGraphicsShaderBinary( Vkgc::UnlinkedShaderStage unlinkedStage = UnlinkedStageCount; // Belong to vertexProcess stage before fragment - if (stage < ShaderStage::ShaderStageFragment) + if (gplType == GraphicsLibraryPreRaster) { unlinkedStage = UnlinkedShaderStage::UnlinkedStageVertexProcess; } - else if (stage == ShaderStage::ShaderStageFragment) + else if (gplType == GraphicsLibraryFragment) { unlinkedStage = UnlinkedShaderStage::UnlinkedStageFragment; } @@ -548,21 +546,41 @@ VkResult CompilerSolutionLlpc::CreateGraphicsShaderBinary( &shaderLibraryBinary); } - pShaderModule->elfPackage = shaderLibraryBinary; - pCreateInfo->earlyElfPackage[gplType] = pShaderModule->elfPackage; + pModuleState->elfPackage = shaderLibraryBinary; + pModuleState->pFsOutputMetaData = nullptr; + pCreateInfo->earlyElfPackage[gplType] = pModuleState->elfPackage; pCreateInfo->earlyElfPackageHash[gplType] = cacheId; - if (stage == ShaderStage::ShaderStageFragment) + if (gplType == GraphicsLibraryFragment) { if (shaderLibraryBinary.pCode != nullptr) { const auto* pShaderLibraryHeader = reinterpret_cast(shaderLibraryBinary.pCode); - pCreateInfo->pBinaryMetadata->fsOutputMetaDataSize = pShaderLibraryHeader->fragMetaLength; - pCreateInfo->pBinaryMetadata->pFsOutputMetaData = (pShaderLibraryHeader->fragMetaLength > 0) ? - const_cast(VoidPtrInc(pShaderLibraryHeader + 1, pShaderLibraryHeader->binaryLength)) : - nullptr; + pCreateInfo->pBinaryMetadata->fsOutputMetaDataSize = 0; + pCreateInfo->pBinaryMetadata->pFsOutputMetaData = nullptr; + if (pShaderLibraryHeader->fragMetaLength > 0) + { + void* pFsOutputMetaData = m_pPhysicalDevice->Manager()->VkInstance()->AllocMem( + pShaderLibraryHeader->fragMetaLength, + VK_DEFAULT_MEM_ALIGN, + VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); + + if (pFsOutputMetaData != nullptr) + { + memcpy(pFsOutputMetaData, + VoidPtrInc(pShaderLibraryHeader + 1, pShaderLibraryHeader->binaryLength), + pShaderLibraryHeader->fragMetaLength); + pCreateInfo->pBinaryMetadata->fsOutputMetaDataSize = pShaderLibraryHeader->fragMetaLength; + pCreateInfo->pBinaryMetadata->pFsOutputMetaData = pFsOutputMetaData; + pModuleState->pFsOutputMetaData = pFsOutputMetaData; + } + else + { + result = VK_ERROR_OUT_OF_HOST_MEMORY; + } + } } } @@ -1164,7 +1182,8 @@ void CompilerSolutionLlpc::UpdateStageCreationFeedback( bool CompilerSolutionLlpc::IsGplFastLinkCompatible( const Device* pDevice, uint32_t deviceIdx, - const GraphicsPipelineBinaryCreateInfo* pCreateInfo) + const GraphicsPipelineBinaryCreateInfo* pCreateInfo, + const GraphicsPipelineLibraryInfo& libInfo) { return (pCreateInfo->pipelineInfo.iaState.enableMultiView == false) && ((pCreateInfo->flags & VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR) == 0); diff --git a/icd/api/devmode/devmode_mgr.cpp b/icd/api/devmode/devmode_mgr.cpp index 924a2832..b4f04ed1 100644 --- a/icd/api/devmode/devmode_mgr.cpp +++ b/icd/api/devmode/devmode_mgr.cpp @@ -638,6 +638,11 @@ Pal::Result DevModeMgr::TraceEndingToIdleStep(TraceState* pState) if (settings.devModeEnableRgpTraceDump) { + // The min length of both win and linux is 260, so we use this number. + char pathBuffer[260]; + Util::SplitFilePath(settings.devModeRgpTraceDumpFile, pathBuffer, 260, nullptr, 0); + Util::MkDirRecursively(pathBuffer); + Util::File dumpFile; if (dumpFile.Open(settings.devModeRgpTraceDumpFile, Util::FileAccessMode::FileAccessWrite | Util::FileAccessMode::FileAccessBinary) == Util::Result::Success) { diff --git a/icd/api/entry.cpp b/icd/api/entry.cpp index 5cb2566d..661d01c2 100644 --- a/icd/api/entry.cpp +++ b/icd/api/entry.cpp @@ -121,6 +121,61 @@ VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer2KHR( indexType); } +// ===================================================================================================================== +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets2KHR( + VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo) +{ + ApiCmdBuffer::ObjectFromHandle(commandBuffer)->VkDevice()->GetEntryPoints().vkCmdBindDescriptorSets2KHR( + commandBuffer, + pBindDescriptorSetsInfo); +} + +// ===================================================================================================================== +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants2KHR( + VkCommandBuffer commandBuffer, + const VkPushConstantsInfoKHR* pPushConstantsInfo) +{ + ApiCmdBuffer::ObjectFromHandle(commandBuffer)->PushConstants2KHR(pPushConstantsInfo); +} + +// ===================================================================================================================== +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo) +{ + ApiCmdBuffer::ObjectFromHandle(commandBuffer)->VkDevice()->GetEntryPoints().vkCmdPushDescriptorSet2KHR( + commandBuffer, + pPushDescriptorSetInfo); +} + +// ===================================================================================================================== +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo) +{ + ApiCmdBuffer::ObjectFromHandle(commandBuffer)->VkDevice()->GetEntryPoints().vkCmdPushDescriptorSetWithTemplate2KHR( + commandBuffer, + pPushDescriptorSetWithTemplateInfo); +} + +// ===================================================================================================================== +VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsets2EXT( + VkCommandBuffer commandBuffer, + const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) +{ + ApiCmdBuffer::ObjectFromHandle(commandBuffer)->SetDescriptorBufferOffsets2EXT(pSetDescriptorBufferOffsetsInfo); +} + +// ===================================================================================================================== +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, + const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) +{ + ApiCmdBuffer::ObjectFromHandle(commandBuffer)->BindDescriptorBufferEmbeddedSamplers2EXT( + pBindDescriptorBufferEmbeddedSamplersInfo); +} + // ===================================================================================================================== VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( VkCommandBuffer cmdBuffer, diff --git a/icd/api/graphics_pipeline_common.cpp b/icd/api/graphics_pipeline_common.cpp index c9dbb7f6..715c3fc4 100644 --- a/icd/api/graphics_pipeline_common.cpp +++ b/icd/api/graphics_pipeline_common.cpp @@ -189,6 +189,7 @@ static bool IsDualSourceBlend(VkBlendFactor blend) // ===================================================================================================================== static void BuildPalColorBlendStateCreateInfo( const VkPipelineColorBlendStateCreateInfo* pColorBlendState, + const GraphicsPipelineExtStructs& extStructs, const uint64_t dynamicStateFlags, Pal::ColorBlendStateCreateInfo* pInfo) { @@ -196,8 +197,9 @@ static void BuildPalColorBlendStateCreateInfo( for (uint32_t i = 0; i < numColorTargets; ++i) { + uint32_t location = i; const VkPipelineColorBlendAttachmentState& attachmentState = pColorBlendState->pAttachments[i]; - auto pBlendDst = &pInfo->targets[i]; + auto pBlendDst = &pInfo->targets[location]; if (IsDynamicStateEnabled(dynamicStateFlags, DynamicStatesInternal::ColorBlendEnable) == false) { @@ -220,6 +222,7 @@ static void BuildPalColorBlendStateCreateInfo( bool GraphicsPipelineCommon::GetDualSourceBlendEnableState( const Device* pDevice, const VkPipelineColorBlendStateCreateInfo* pColorBlendState, + const GraphicsPipelineExtStructs& extStructs, const Pal::ColorBlendStateCreateInfo* pPalInfo) { bool dualSourceBlend = false; @@ -232,7 +235,7 @@ bool GraphicsPipelineCommon::GetDualSourceBlendEnableState( else { Pal::ColorBlendStateCreateInfo palInfo = {}; - BuildPalColorBlendStateCreateInfo(pColorBlendState, 0, &palInfo); + BuildPalColorBlendStateCreateInfo(pColorBlendState, extStructs, 0, &palInfo); canEnableDualSourceBlend = pDevice->PalDevice(DefaultDeviceIndex)->CanEnableDualSourceBlend(palInfo); } @@ -804,7 +807,9 @@ VkResult GraphicsPipelineCommon::Create( { VkResult result; - const bool isLibrary = Util::TestAnyFlagSet(flags, VK_PIPELINE_CREATE_LIBRARY_BIT_KHR); + GraphicsPipelineExtStructs extStructs = {}; + + HandleExtensionStructs(pCreateInfo, &extStructs); if (pDevice->GetRuntimeSettings().pipelineLinkOptimizationMode == PipelineLinkOptimizationNeverOptimized) { @@ -815,15 +820,15 @@ VkResult GraphicsPipelineCommon::Create( flags |= ~VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT; } - if (isLibrary) + if ((flags & VK_PIPELINE_CREATE_LIBRARY_BIT_KHR) != 0) { result = GraphicsPipelineLibrary::Create( - pDevice, pPipelineCache, pCreateInfo, flags, pAllocator, pPipeline); + pDevice, pPipelineCache, pCreateInfo, extStructs, flags, pAllocator, pPipeline); } else { result = GraphicsPipeline::Create( - pDevice, pPipelineCache, pCreateInfo, flags, pAllocator, pPipeline); + pDevice, pPipelineCache, pCreateInfo, extStructs, flags, pAllocator, pPipeline); } return result; @@ -1548,6 +1553,7 @@ static void BuildColorBlendState( const Device* pDevice, const VkPipelineRenderingCreateInfo* pRendering, const VkPipelineColorBlendStateCreateInfo* pCb, + const GraphicsPipelineExtStructs& extStructs, const RenderPass* pRenderPass, const uint32_t subpass, const uint64_t dynamicStateFlags, @@ -1629,7 +1635,8 @@ static void BuildColorBlendState( { for (uint32_t i = 0; i < numColorTargets; ++i) { - auto pCbDst = &pInfo->pipeline.cbState.target[i]; + uint32_t location = i; + auto pCbDst = &pInfo->pipeline.cbState.target[location]; if (pRenderPass != nullptr) { @@ -1688,9 +1695,9 @@ static void BuildColorBlendState( ((IsDynamicStateEnabled(dynamicStateFlags, DynamicStatesInternal::ColorBlendEnable) == false) || (IsDynamicStateEnabled(dynamicStateFlags, DynamicStatesInternal::ColorBlendEquation) == false))) { - BuildPalColorBlendStateCreateInfo(pCb, dynamicStateFlags, &pInfo->immedInfo.blendCreateInfo); + BuildPalColorBlendStateCreateInfo(pCb, extStructs, dynamicStateFlags, &pInfo->immedInfo.blendCreateInfo); dualSourceBlend = GraphicsPipelineCommon::GetDualSourceBlendEnableState( - pDevice, pCb, &pInfo->immedInfo.blendCreateInfo); + pDevice, pCb, extStructs , &pInfo->immedInfo.blendCreateInfo); } } @@ -1919,6 +1926,7 @@ static void BuildFragmentShaderState( static void BuildFragmentOutputInterfaceState( const Device* pDevice, const VkGraphicsPipelineCreateInfo* pIn, + const GraphicsPipelineExtStructs& extStructs, const uint64_t dynamicStateFlags, GraphicsPipelineObjectCreateInfo* pInfo) { @@ -1942,6 +1950,7 @@ static void BuildFragmentOutputInterfaceState( pDevice, pPipelineRenderingCreateInfoKHR, pIn->pColorBlendState, + extStructs, pRenderPass, subpass, dynamicStateFlags, @@ -2135,6 +2144,7 @@ static void BuildExecutablePipelineState( void GraphicsPipelineCommon::BuildPipelineObjectCreateInfo( const Device* pDevice, const VkGraphicsPipelineCreateInfo* pIn, + const GraphicsPipelineExtStructs& extStructs, VkPipelineCreateFlags2KHR flags, const PipelineOptimizerKey* pOptimizerKey, const PipelineMetadata* pBinMeta, @@ -2214,7 +2224,7 @@ void GraphicsPipelineCommon::BuildPipelineObjectCreateInfo( if (libInfo.libFlags & VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT) { - BuildFragmentOutputInterfaceState(pDevice, pIn, pInfo->dynamicStates, pInfo); + BuildFragmentOutputInterfaceState(pDevice, pIn, extStructs, pInfo->dynamicStates, pInfo); } else if (libInfo.pFragmentOutputInterfaceLib != nullptr) { @@ -2918,10 +2928,11 @@ bool GraphicsPipelineCommon::IsRasterizationDisabled( // - pCreateInfo->renderPass // - pCreateInfo->subpass void GraphicsPipelineCommon::BuildApiHash( - const VkGraphicsPipelineCreateInfo* pCreateInfo, - VkPipelineCreateFlags2KHR flags, - uint64_t* pApiHash, - Util::MetroHash::Hash* pElfHash) + const VkGraphicsPipelineCreateInfo* pCreateInfo, + VkPipelineCreateFlags2KHR flags, + const GraphicsPipelineBinaryCreateInfo& binaryCreateInfo, + uint64_t* pApiHash, + Util::MetroHash::Hash* pElfHash) { Util::MetroHash128 elfHasher; Util::MetroHash128 apiHasher; @@ -3013,4 +3024,30 @@ void GraphicsPipelineCommon::BuildApiHash( *pApiHash = Util::MetroHash::Compact64(&apiHashFull); } +// ===================================================================================================================== +void GraphicsPipelineCommon::HandleExtensionStructs( + const VkGraphicsPipelineCreateInfo* pCreateInfo, + GraphicsPipelineExtStructs* pExtStructs) +{ + const void* pNext = pCreateInfo->pNext; + + while (pNext != nullptr) + { + const VkStructHeader* pHeader = static_cast(pNext); + + switch (static_cast(pHeader->sType)) + { + // Handle extension specific structures + case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: + { + pExtStructs->pPipelineRenderingCreateInfo = static_cast(pNext); + break; + } + default: + break; + } + pNext = pHeader->pNext; + } +} + } diff --git a/icd/api/include/app_profile.h b/icd/api/include/app_profile.h index 0c2f8811..bf7757fe 100644 --- a/icd/api/include/app_profile.h +++ b/icd/api/include/app_profile.h @@ -112,6 +112,8 @@ enum class AppProfile : uint32_t SniperElite5, // Sniper Elite 5 by Rebellion SeriousSamVrTheLastHope, // Serious Sam VR The Last Hope by Croteam BaldursGate3, // Baldur's Gate by Larian Studios + Enshrouded, // Enshrouded by Keen Games + HolisticEngine, // Holistic Engine by Keen Games #if VKI_RAY_TRACING ControlDX12, // VKD3D Control Ultimate Edition RayTracingWeekends, // RayTracingInVulkan demo diff --git a/icd/api/include/color_space_helper.h b/icd/api/include/color_space_helper.h index dbc222e1..ddb8b193 100644 --- a/icd/api/include/color_space_helper.h +++ b/icd/api/include/color_space_helper.h @@ -55,20 +55,17 @@ class ColorSpaceHelper Fmt_8bpc_srgb = 0x0008, Fmt_8bpc_unorm = 0x0010, Fmt_9bpc = 0x0020, - Fmt_10bpc_srgb = 0x0040, - Fmt_10bpc_unorm = 0x0080, - Fmt_11bpc = 0x0100, - Fmt_12bpc = 0x0200, - Fmt_16bpc_unorm = 0x0400, - Fmt_16bpc_sfloat = 0x0800, - Fmt_32bpc = 0x1000, - - Fmt_8bpc = Fmt_8bpc_srgb | Fmt_8bpc_unorm, - Fmt_10bpc = Fmt_10bpc_srgb | Fmt_10bpc_unorm, - Fmt_16bpc = Fmt_16bpc_unorm | Fmt_16bpc_sfloat, - Fmt_KnownHDR = Fmt_10bpc_unorm | Fmt_11bpc | Fmt_12bpc | Fmt_16bpc, - Fmt_KnownSRGB = Fmt_8bpc | Fmt_10bpc, - Fmt_All = Fmt_4bpc | Fmt_5bpc | Fmt_6bpc | Fmt_8bpc | Fmt_10bpc_srgb | Fmt_KnownHDR | Fmt_32bpc, + Fmt_10bpc = 0x0040, + Fmt_11bpc = 0x0080, + Fmt_12bpc = 0x0100, + Fmt_16bpc_unorm = 0x0200, + Fmt_16bpc_sfloat = 0x0400, + Fmt_32bpc = 0x0800, + + Fmt_8bpc = Fmt_8bpc_srgb | Fmt_8bpc_unorm, + Fmt_16bpc = Fmt_16bpc_unorm | Fmt_16bpc_sfloat, + Fmt_KnownHDR = Fmt_10bpc | Fmt_11bpc | Fmt_12bpc | Fmt_16bpc, + Fmt_All = Fmt_4bpc | Fmt_5bpc | Fmt_6bpc | Fmt_8bpc | Fmt_KnownHDR | Fmt_32bpc, Fmt_FreeSync2 = Fmt_10bpc | Fmt_16bpc, }; diff --git a/icd/api/include/compiler_solution.h b/icd/api/include/compiler_solution.h index a149190b..08797103 100644 --- a/icd/api/include/compiler_solution.h +++ b/icd/api/include/compiler_solution.h @@ -51,6 +51,7 @@ class ShaderCache; class DeferredHostOperation; class PipelineCompiler; class InternalMemory; +struct GraphicsPipelineLibraryInfo; #if VKI_RAY_TRACING struct DeferredWorkload; @@ -67,10 +68,19 @@ enum FreeCompilerBinary : uint32_t struct ShaderModuleHandle { uint32_t* pRefCount; - Vkgc::BinaryData elfPackage; // Generated ElfPackage from LLPC + void* pLlpcShaderModule; // Shader module handle from LLPC }; +struct GplModuleState +{ + ShaderStage stage; + ShaderModuleHandle moduleHandle; + Vkgc::BinaryData elfPackage; + void* pFsOutputMetaData; + +}; + struct LlpcShaderLibraryBlobHeader { uint32_t binaryLength; // Partial ELF binary length @@ -260,8 +270,6 @@ class CompilerSolution VkShaderModuleCreateFlags flags, VkShaderModuleCreateFlags internalShaderFlags, const Vkgc::BinaryData& shaderBinary, - const bool adaptForFastLink, - bool isInternal, ShaderModuleHandle* pShaderModule, const PipelineOptimizerKey& profileKey) = 0; @@ -286,10 +294,10 @@ class CompilerSolution virtual VkResult CreateGraphicsShaderBinary( const Device* pDevice, PipelineCache* pPipelineCache, - const ShaderStage stage, + GraphicsLibraryType gplType, GraphicsPipelineBinaryCreateInfo* pCreateInfo, void* pPipelineDumpHandle, - ShaderModuleHandle* pShaderModule) = 0; + GplModuleState* pModuleState) = 0; virtual VkResult CreateComputePipelineBinary( Device* pDevice, @@ -339,14 +347,19 @@ class CompilerSolution virtual bool IsGplFastLinkCompatible( const Device* pDevice, uint32_t deviceIdx, - const GraphicsPipelineBinaryCreateInfo* pCreateInfo) = 0; + const GraphicsPipelineBinaryCreateInfo* pCreateInfo, + const GraphicsPipelineLibraryInfo& libInfo) = 0; virtual Vkgc::BinaryData ExtractPalElfBinary(const Vkgc::BinaryData& shaderBinary) = 0; static void DisableNggCulling(Vkgc::NggState* pNggState); #if VKI_RAY_TRACING - static void UpdateRayTracingFunctionNames(const Device* pDevice, Vkgc::RtState* pRtState); + static void UpdateRayTracingFunctionNames( + const Device* pDevice, + Pal::RayTracingIpLevel rayTracingIp, + Vkgc::RtState* pRtState); + uint32_t GetRayTracingVgprLimit(bool isIndirect); #endif diff --git a/icd/api/include/compiler_solution_llpc.h b/icd/api/include/compiler_solution_llpc.h index 0ec243b2..bd888a61 100644 --- a/icd/api/include/compiler_solution_llpc.h +++ b/icd/api/include/compiler_solution_llpc.h @@ -89,8 +89,6 @@ class CompilerSolutionLlpc final : public CompilerSolution VkShaderModuleCreateFlags flags, VkShaderModuleCreateFlags internalShaderFlags, const Vkgc::BinaryData& shaderBinary, - const bool adaptForFastLink, - bool isInternal, ShaderModuleHandle* pShaderModule, const PipelineOptimizerKey& profileKey) override; @@ -115,10 +113,10 @@ class CompilerSolutionLlpc final : public CompilerSolution virtual VkResult CreateGraphicsShaderBinary( const Device* pDevice, PipelineCache* pPipelineCache, - const ShaderStage stage, + GraphicsLibraryType gplType, GraphicsPipelineBinaryCreateInfo* pCreateInfo, void* pPipelineDumpHandle, - ShaderModuleHandle* pShaderModule) override; + GplModuleState* pModuleState) override; virtual VkResult CreateColorExportBinary( GraphicsPipelineBinaryCreateInfo* pCreateInfo, @@ -169,7 +167,8 @@ class CompilerSolutionLlpc final : public CompilerSolution virtual bool IsGplFastLinkCompatible( const Device* pDevice, uint32_t deviceIdx, - const GraphicsPipelineBinaryCreateInfo* pCreateInfo) override; + const GraphicsPipelineBinaryCreateInfo* pCreateInfo, + const GraphicsPipelineLibraryInfo& libInfo) override; virtual Vkgc::BinaryData ExtractPalElfBinary(const Vkgc::BinaryData& shaderBinary) override; diff --git a/icd/api/include/graphics_pipeline_common.h b/icd/api/include/graphics_pipeline_common.h index b33bff8c..bb42808f 100644 --- a/icd/api/include/graphics_pipeline_common.h +++ b/icd/api/include/graphics_pipeline_common.h @@ -188,6 +188,13 @@ struct GraphicsPipelineLibraryInfo const GraphicsPipelineLibrary* pFragmentOutputInterfaceLib; }; +// ===================================================================================================================== +// Extension structures for pipeline creation +struct GraphicsPipelineExtStructs +{ + const VkPipelineRenderingCreateInfo* pPipelineRenderingCreateInfo; +}; + // ===================================================================================================================== // The common part used by both executable graphics pipelines and graphics pipeline libraries class GraphicsPipelineCommon : public Pipeline @@ -211,6 +218,7 @@ class GraphicsPipelineCommon : public Pipeline static bool GetDualSourceBlendEnableState( const Device* pDevice, const VkPipelineColorBlendStateCreateInfo* pColorBlendState, + const GraphicsPipelineExtStructs& extStructs, const Pal::ColorBlendStateCreateInfo* pPalInfo = nullptr); // Returns true if src alpha is used in blending @@ -252,6 +260,7 @@ class GraphicsPipelineCommon : public Pipeline static void BuildPipelineObjectCreateInfo( const Device* pDevice, const VkGraphicsPipelineCreateInfo* pIn, + const GraphicsPipelineExtStructs& extStructs, VkPipelineCreateFlags2KHR flags, const PipelineOptimizerKey* pOptimizerKey, const PipelineMetadata* pBinMeta, @@ -268,10 +277,11 @@ class GraphicsPipelineCommon : public Pipeline // Generates the API PSO hash using the contents of the VkGraphicsPipelineCreateInfo struct static void BuildApiHash( - const VkGraphicsPipelineCreateInfo* pCreateInfo, - VkPipelineCreateFlags2KHR flags, - uint64_t* pApiHash, - Util::MetroHash::Hash* elfHash); + const VkGraphicsPipelineCreateInfo* pCreateInfo, + VkPipelineCreateFlags2KHR flags, + const GraphicsPipelineBinaryCreateInfo& pBinaryCreateInfo, + uint64_t* pApiHash, + Util::MetroHash::Hash* elfHash); // Generate API PSO hash for state of vertex input interface section static void GenerateHashForVertexInputInterfaceState( @@ -305,6 +315,11 @@ class GraphicsPipelineCommon : public Pipeline const GraphicsPipelineLibraryInfo* pLibInfo, uint64_t dynamicStateFlags); + // Extracts extension structs from VkGraphicsPipelineCreateInfo + static void HandleExtensionStructs( + const VkGraphicsPipelineCreateInfo* pCreateInfo, + GraphicsPipelineExtStructs* pExtStructs); + // Constructor of GraphicsPipelineCommon GraphicsPipelineCommon( #if VKI_RAY_TRACING diff --git a/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_av1std.h b/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_av1std.h new file mode 100644 index 00000000..8ce283e8 --- /dev/null +++ b/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_av1std.h @@ -0,0 +1,392 @@ +#ifndef VULKAN_VIDEO_CODEC_AV1STD_H_ +#define VULKAN_VIDEO_CODEC_AV1STD_H_ 1 + +/* +** Copyright 2015-2024 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// vulkan_video_codec_av1std is a preprocessor guard. Do not pass it to API calls. +#define vulkan_video_codec_av1std 1 +#include "vulkan_video_codecs_common.h" +#define STD_VIDEO_AV1_NUM_REF_FRAMES 8 +#define STD_VIDEO_AV1_REFS_PER_FRAME 7 +#define STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME 8 +#define STD_VIDEO_AV1_MAX_TILE_COLS 64 +#define STD_VIDEO_AV1_MAX_TILE_ROWS 64 +#define STD_VIDEO_AV1_MAX_SEGMENTS 8 +#define STD_VIDEO_AV1_SEG_LVL_MAX 8 +#define STD_VIDEO_AV1_PRIMARY_REF_NONE 7 +#define STD_VIDEO_AV1_SELECT_INTEGER_MV 2 +#define STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS 2 +#define STD_VIDEO_AV1_SKIP_MODE_FRAMES 2 +#define STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS 4 +#define STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS 2 +#define STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS 8 +#define STD_VIDEO_AV1_MAX_NUM_PLANES 3 +#define STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS 6 +#define STD_VIDEO_AV1_MAX_NUM_Y_POINTS 14 +#define STD_VIDEO_AV1_MAX_NUM_CB_POINTS 10 +#define STD_VIDEO_AV1_MAX_NUM_CR_POINTS 10 +#define STD_VIDEO_AV1_MAX_NUM_POS_LUMA 24 +#define STD_VIDEO_AV1_MAX_NUM_POS_CHROMA 25 + +typedef enum StdVideoAV1Profile { + STD_VIDEO_AV1_PROFILE_MAIN = 0, + STD_VIDEO_AV1_PROFILE_HIGH = 1, + STD_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, + STD_VIDEO_AV1_PROFILE_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_PROFILE_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1Profile; + +typedef enum StdVideoAV1Level { + STD_VIDEO_AV1_LEVEL_2_0 = 0, + STD_VIDEO_AV1_LEVEL_2_1 = 1, + STD_VIDEO_AV1_LEVEL_2_2 = 2, + STD_VIDEO_AV1_LEVEL_2_3 = 3, + STD_VIDEO_AV1_LEVEL_3_0 = 4, + STD_VIDEO_AV1_LEVEL_3_1 = 5, + STD_VIDEO_AV1_LEVEL_3_2 = 6, + STD_VIDEO_AV1_LEVEL_3_3 = 7, + STD_VIDEO_AV1_LEVEL_4_0 = 8, + STD_VIDEO_AV1_LEVEL_4_1 = 9, + STD_VIDEO_AV1_LEVEL_4_2 = 10, + STD_VIDEO_AV1_LEVEL_4_3 = 11, + STD_VIDEO_AV1_LEVEL_5_0 = 12, + STD_VIDEO_AV1_LEVEL_5_1 = 13, + STD_VIDEO_AV1_LEVEL_5_2 = 14, + STD_VIDEO_AV1_LEVEL_5_3 = 15, + STD_VIDEO_AV1_LEVEL_6_0 = 16, + STD_VIDEO_AV1_LEVEL_6_1 = 17, + STD_VIDEO_AV1_LEVEL_6_2 = 18, + STD_VIDEO_AV1_LEVEL_6_3 = 19, + STD_VIDEO_AV1_LEVEL_7_0 = 20, + STD_VIDEO_AV1_LEVEL_7_1 = 21, + STD_VIDEO_AV1_LEVEL_7_2 = 22, + STD_VIDEO_AV1_LEVEL_7_3 = 23, + STD_VIDEO_AV1_LEVEL_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_LEVEL_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1Level; + +typedef enum StdVideoAV1FrameType { + STD_VIDEO_AV1_FRAME_TYPE_KEY = 0, + STD_VIDEO_AV1_FRAME_TYPE_INTER = 1, + STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY = 2, + STD_VIDEO_AV1_FRAME_TYPE_SWITCH = 3, + STD_VIDEO_AV1_FRAME_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_FRAME_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1FrameType; + +typedef enum StdVideoAV1ReferenceName { + STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME = 0, + STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME = 1, + STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME = 2, + STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME = 3, + STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME = 4, + STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME = 5, + STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME = 6, + STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME = 7, + STD_VIDEO_AV1_REFERENCE_NAME_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_REFERENCE_NAME_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1ReferenceName; + +typedef enum StdVideoAV1InterpolationFilter { + STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, + STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, + STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, + STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR = 3, + STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, + STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_INTERPOLATION_FILTER_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1InterpolationFilter; + +typedef enum StdVideoAV1TxMode { + STD_VIDEO_AV1_TX_MODE_ONLY_4X4 = 0, + STD_VIDEO_AV1_TX_MODE_LARGEST = 1, + STD_VIDEO_AV1_TX_MODE_SELECT = 2, + STD_VIDEO_AV1_TX_MODE_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_TX_MODE_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1TxMode; + +typedef enum StdVideoAV1FrameRestorationType { + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE = 0, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER = 1, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ = 2, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE = 3, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1FrameRestorationType; + +typedef enum StdVideoAV1ColorPrimaries { + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709 = 1, + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = 2, + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M = 4, + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G = 5, + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601 = 6, + STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240 = 7, + STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM = 8, + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020 = 9, + STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ = 10, + STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431 = 11, + STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432 = 12, + STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213 = 22, + STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_COLOR_PRIMARIES_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1ColorPrimaries; + +typedef enum StdVideoAV1TransferCharacteristics { + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0 = 0, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709 = 1, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED = 2, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3 = 3, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M = 4, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G = 5, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601 = 6, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240 = 7, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR = 8, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100 = 9, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10 = 10, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966 = 11, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361 = 12, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB = 13, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT = 14, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT = 15, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084 = 16, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428 = 17, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG = 18, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1TransferCharacteristics; + +typedef enum StdVideoAV1MatrixCoefficients { + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY = 0, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709 = 1, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED = 2, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3 = 3, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC = 4, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G = 5, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601 = 6, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240 = 7, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO = 8, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL = 9, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL = 10, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085 = 11, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL = 12, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL = 13, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP = 14, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1MatrixCoefficients; + +typedef enum StdVideoAV1ChromaSamplePosition { + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN = 0, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL = 1, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED = 2, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED = 3, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1ChromaSamplePosition; +typedef struct StdVideoAV1ColorConfigFlags { + uint32_t mono_chrome : 1; + uint32_t color_range : 1; + uint32_t separate_uv_delta_q : 1; + uint32_t color_description_present_flag : 1; + uint32_t reserved : 28; +} StdVideoAV1ColorConfigFlags; + +typedef struct StdVideoAV1ColorConfig { + StdVideoAV1ColorConfigFlags flags; + uint8_t BitDepth; + uint8_t subsampling_x; + uint8_t subsampling_y; + uint8_t reserved1; + StdVideoAV1ColorPrimaries color_primaries; + StdVideoAV1TransferCharacteristics transfer_characteristics; + StdVideoAV1MatrixCoefficients matrix_coefficients; + StdVideoAV1ChromaSamplePosition chroma_sample_position; +} StdVideoAV1ColorConfig; + +typedef struct StdVideoAV1TimingInfoFlags { + uint32_t equal_picture_interval : 1; + uint32_t reserved : 31; +} StdVideoAV1TimingInfoFlags; + +typedef struct StdVideoAV1TimingInfo { + StdVideoAV1TimingInfoFlags flags; + uint32_t num_units_in_display_tick; + uint32_t time_scale; + uint32_t num_ticks_per_picture_minus_1; +} StdVideoAV1TimingInfo; + +typedef struct StdVideoAV1LoopFilterFlags { + uint32_t loop_filter_delta_enabled : 1; + uint32_t loop_filter_delta_update : 1; + uint32_t reserved : 30; +} StdVideoAV1LoopFilterFlags; + +typedef struct StdVideoAV1LoopFilter { + StdVideoAV1LoopFilterFlags flags; + uint8_t loop_filter_level[STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS]; + uint8_t loop_filter_sharpness; + uint8_t update_ref_delta; + int8_t loop_filter_ref_deltas[STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME]; + uint8_t update_mode_delta; + int8_t loop_filter_mode_deltas[STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS]; +} StdVideoAV1LoopFilter; + +typedef struct StdVideoAV1QuantizationFlags { + uint32_t using_qmatrix : 1; + uint32_t diff_uv_delta : 1; + uint32_t reserved : 30; +} StdVideoAV1QuantizationFlags; + +typedef struct StdVideoAV1Quantization { + StdVideoAV1QuantizationFlags flags; + uint8_t base_q_idx; + int8_t DeltaQYDc; + int8_t DeltaQUDc; + int8_t DeltaQUAc; + int8_t DeltaQVDc; + int8_t DeltaQVAc; + uint8_t qm_y; + uint8_t qm_u; + uint8_t qm_v; +} StdVideoAV1Quantization; + +typedef struct StdVideoAV1Segmentation { + uint8_t FeatureEnabled[STD_VIDEO_AV1_MAX_SEGMENTS]; + int16_t FeatureData[STD_VIDEO_AV1_MAX_SEGMENTS][STD_VIDEO_AV1_SEG_LVL_MAX]; +} StdVideoAV1Segmentation; + +typedef struct StdVideoAV1TileInfoFlags { + uint32_t uniform_tile_spacing_flag : 1; + uint32_t reserved : 31; +} StdVideoAV1TileInfoFlags; + +typedef struct StdVideoAV1TileInfo { + StdVideoAV1TileInfoFlags flags; + uint8_t TileCols; + uint8_t TileRows; + uint16_t context_update_tile_id; + uint8_t tile_size_bytes_minus_1; + uint8_t reserved1[7]; + const uint16_t* pMiColStarts; + const uint16_t* pMiRowStarts; + const uint16_t* pWidthInSbsMinus1; + const uint16_t* pHeightInSbsMinus1; +} StdVideoAV1TileInfo; + +typedef struct StdVideoAV1CDEF { + uint8_t cdef_damping_minus_3; + uint8_t cdef_bits; + uint8_t cdef_y_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; + uint8_t cdef_y_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; + uint8_t cdef_uv_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; + uint8_t cdef_uv_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; +} StdVideoAV1CDEF; + +typedef struct StdVideoAV1LoopRestoration { + StdVideoAV1FrameRestorationType FrameRestorationType[STD_VIDEO_AV1_MAX_NUM_PLANES]; + uint16_t LoopRestorationSize[STD_VIDEO_AV1_MAX_NUM_PLANES]; +} StdVideoAV1LoopRestoration; + +typedef struct StdVideoAV1GlobalMotion { + uint8_t GmType[STD_VIDEO_AV1_NUM_REF_FRAMES]; + int32_t gm_params[STD_VIDEO_AV1_NUM_REF_FRAMES][STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS]; +} StdVideoAV1GlobalMotion; + +typedef struct StdVideoAV1FilmGrainFlags { + uint32_t chroma_scaling_from_luma : 1; + uint32_t overlap_flag : 1; + uint32_t clip_to_restricted_range : 1; + uint32_t update_grain : 1; + uint32_t reserved : 28; +} StdVideoAV1FilmGrainFlags; + +typedef struct StdVideoAV1FilmGrain { + StdVideoAV1FilmGrainFlags flags; + uint8_t grain_scaling_minus_8; + uint8_t ar_coeff_lag; + uint8_t ar_coeff_shift_minus_6; + uint8_t grain_scale_shift; + uint16_t grain_seed; + uint8_t film_grain_params_ref_idx; + uint8_t num_y_points; + uint8_t point_y_value[STD_VIDEO_AV1_MAX_NUM_Y_POINTS]; + uint8_t point_y_scaling[STD_VIDEO_AV1_MAX_NUM_Y_POINTS]; + uint8_t num_cb_points; + uint8_t point_cb_value[STD_VIDEO_AV1_MAX_NUM_CB_POINTS]; + uint8_t point_cb_scaling[STD_VIDEO_AV1_MAX_NUM_CB_POINTS]; + uint8_t num_cr_points; + uint8_t point_cr_value[STD_VIDEO_AV1_MAX_NUM_CR_POINTS]; + uint8_t point_cr_scaling[STD_VIDEO_AV1_MAX_NUM_CR_POINTS]; + int8_t ar_coeffs_y_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_LUMA]; + int8_t ar_coeffs_cb_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA]; + int8_t ar_coeffs_cr_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA]; + uint8_t cb_mult; + uint8_t cb_luma_mult; + uint16_t cb_offset; + uint8_t cr_mult; + uint8_t cr_luma_mult; + uint16_t cr_offset; +} StdVideoAV1FilmGrain; + +typedef struct StdVideoAV1SequenceHeaderFlags { + uint32_t still_picture : 1; + uint32_t reduced_still_picture_header : 1; + uint32_t use_128x128_superblock : 1; + uint32_t enable_filter_intra : 1; + uint32_t enable_intra_edge_filter : 1; + uint32_t enable_interintra_compound : 1; + uint32_t enable_masked_compound : 1; + uint32_t enable_warped_motion : 1; + uint32_t enable_dual_filter : 1; + uint32_t enable_order_hint : 1; + uint32_t enable_jnt_comp : 1; + uint32_t enable_ref_frame_mvs : 1; + uint32_t frame_id_numbers_present_flag : 1; + uint32_t enable_superres : 1; + uint32_t enable_cdef : 1; + uint32_t enable_restoration : 1; + uint32_t film_grain_params_present : 1; + uint32_t timing_info_present_flag : 1; + uint32_t initial_display_delay_present_flag : 1; + uint32_t reserved : 13; +} StdVideoAV1SequenceHeaderFlags; + +typedef struct StdVideoAV1SequenceHeader { + StdVideoAV1SequenceHeaderFlags flags; + StdVideoAV1Profile seq_profile; + uint8_t frame_width_bits_minus_1; + uint8_t frame_height_bits_minus_1; + uint16_t max_frame_width_minus_1; + uint16_t max_frame_height_minus_1; + uint8_t delta_frame_id_length_minus_2; + uint8_t additional_frame_id_length_minus_1; + uint8_t order_hint_bits_minus_1; + uint8_t seq_force_integer_mv; + uint8_t seq_force_screen_content_tools; + uint8_t reserved1[5]; + const StdVideoAV1ColorConfig* pColorConfig; + const StdVideoAV1TimingInfo* pTimingInfo; +} StdVideoAV1SequenceHeader; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_av1std_decode.h b/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_av1std_decode.h new file mode 100644 index 00000000..6b8130cd --- /dev/null +++ b/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_av1std_decode.h @@ -0,0 +1,109 @@ +#ifndef VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ +#define VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ 1 + +/* +** Copyright 2015-2024 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// vulkan_video_codec_av1std_decode is a preprocessor guard. Do not pass it to API calls. +#define vulkan_video_codec_av1std_decode 1 +#include "vulkan_video_codec_av1std.h" + +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) + +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_av1_decode" +typedef struct StdVideoDecodeAV1PictureInfoFlags { + uint32_t error_resilient_mode : 1; + uint32_t disable_cdf_update : 1; + uint32_t use_superres : 1; + uint32_t render_and_frame_size_different : 1; + uint32_t allow_screen_content_tools : 1; + uint32_t is_filter_switchable : 1; + uint32_t force_integer_mv : 1; + uint32_t frame_size_override_flag : 1; + uint32_t buffer_removal_time_present_flag : 1; + uint32_t allow_intrabc : 1; + uint32_t frame_refs_short_signaling : 1; + uint32_t allow_high_precision_mv : 1; + uint32_t is_motion_mode_switchable : 1; + uint32_t use_ref_frame_mvs : 1; + uint32_t disable_frame_end_update_cdf : 1; + uint32_t allow_warped_motion : 1; + uint32_t reduced_tx_set : 1; + uint32_t reference_select : 1; + uint32_t skip_mode_present : 1; + uint32_t delta_q_present : 1; + uint32_t delta_lf_present : 1; + uint32_t delta_lf_multi : 1; + uint32_t segmentation_enabled : 1; + uint32_t segmentation_update_map : 1; + uint32_t segmentation_temporal_update : 1; + uint32_t segmentation_update_data : 1; + uint32_t UsesLr : 1; + uint32_t usesChromaLr : 1; + uint32_t apply_grain : 1; + uint32_t reserved : 3; +} StdVideoDecodeAV1PictureInfoFlags; + +typedef struct StdVideoDecodeAV1PictureInfo { + StdVideoDecodeAV1PictureInfoFlags flags; + StdVideoAV1FrameType frame_type; + uint32_t current_frame_id; + uint8_t OrderHint; + uint8_t primary_ref_frame; + uint8_t refresh_frame_flags; + uint8_t reserved1; + StdVideoAV1InterpolationFilter interpolation_filter; + StdVideoAV1TxMode TxMode; + uint8_t delta_q_res; + uint8_t delta_lf_res; + uint8_t SkipModeFrame[STD_VIDEO_AV1_SKIP_MODE_FRAMES]; + uint8_t coded_denom; + uint8_t reserved2[3]; + uint8_t OrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES]; + uint32_t expectedFrameId[STD_VIDEO_AV1_NUM_REF_FRAMES]; + const StdVideoAV1TileInfo* pTileInfo; + const StdVideoAV1Quantization* pQuantization; + const StdVideoAV1Segmentation* pSegmentation; + const StdVideoAV1LoopFilter* pLoopFilter; + const StdVideoAV1CDEF* pCDEF; + const StdVideoAV1LoopRestoration* pLoopRestoration; + const StdVideoAV1GlobalMotion* pGlobalMotion; + const StdVideoAV1FilmGrain* pFilmGrain; +} StdVideoDecodeAV1PictureInfo; + +typedef struct StdVideoDecodeAV1ReferenceInfoFlags { + uint32_t disable_frame_end_update_cdf : 1; + uint32_t segmentation_enabled : 1; + uint32_t reserved : 30; +} StdVideoDecodeAV1ReferenceInfoFlags; + +typedef struct StdVideoDecodeAV1ReferenceInfo { + StdVideoDecodeAV1ReferenceInfoFlags flags; + uint8_t frame_type; + uint8_t RefFrameSignBias; + uint8_t OrderHint; + uint8_t SavedOrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES]; +} StdVideoDecodeAV1ReferenceInfo; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h264std.h b/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h264std.h index ef7eaf74..6d27af37 100644 --- a/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h264std.h +++ b/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h264std.h @@ -2,7 +2,7 @@ #define VULKAN_VIDEO_CODEC_H264STD_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h264std_decode.h b/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h264std_decode.h index dd24112e..439cb885 100644 --- a/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h264std_decode.h +++ b/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h264std_decode.h @@ -2,7 +2,7 @@ #define VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h264std_encode.h b/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h264std_encode.h index 58b8bdb2..9e24aa5d 100644 --- a/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h264std_encode.h +++ b/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h264std_encode.h @@ -2,7 +2,7 @@ #define VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ @@ -22,10 +22,10 @@ extern "C" { // vulkan_video_codec_h264std_encode is a preprocessor guard. Do not pass it to API calls. #define vulkan_video_codec_h264std_encode 1 #include "vulkan_video_codec_h264std.h" -// Vulkan 0.9 provisional Vulkan video H.264 encode std specification version number -#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_11 VK_MAKE_VIDEO_STD_VERSION(0, 9, 11) -#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_11 +#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) + +#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0 #define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_encode" typedef struct StdVideoEncodeH264WeightTableFlags { uint32_t luma_weight_l0_flag; diff --git a/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h265std.h b/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h265std.h index ff5d0dac..d0a1bacb 100644 --- a/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h265std.h +++ b/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h265std.h @@ -2,7 +2,7 @@ #define VULKAN_VIDEO_CODEC_H265STD_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h265std_decode.h b/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h265std_decode.h index 75cf4d09..0178793e 100644 --- a/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h265std_decode.h +++ b/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h265std_decode.h @@ -2,7 +2,7 @@ #define VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h265std_encode.h b/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h265std_encode.h index 2a7024ca..ee34491f 100644 --- a/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h265std_encode.h +++ b/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codec_h265std_encode.h @@ -2,7 +2,7 @@ #define VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ @@ -22,10 +22,10 @@ extern "C" { // vulkan_video_codec_h265std_encode is a preprocessor guard. Do not pass it to API calls. #define vulkan_video_codec_h265std_encode 1 #include "vulkan_video_codec_h265std.h" -// Vulkan 0.9 provisional Vulkan video H.265 encode std specification version number -#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_12 VK_MAKE_VIDEO_STD_VERSION(0, 9, 12) -#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_12 +#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) + +#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0 #define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_encode" typedef struct StdVideoEncodeH265WeightTableFlags { uint16_t luma_weight_l0_flag; diff --git a/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codecs_common.h b/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codecs_common.h index 6568975e..5e6ef1db 100644 --- a/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codecs_common.h +++ b/icd/api/include/khronos/sdk-1.3/vk_video/vulkan_video_codecs_common.h @@ -2,7 +2,7 @@ #define VULKAN_VIDEO_CODECS_COMMON_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vulkan/vk_platform.h b/icd/api/include/khronos/sdk-1.3/vulkan/vk_platform.h index ed67a600..0ecd4f64 100644 --- a/icd/api/include/khronos/sdk-1.3/vulkan/vk_platform.h +++ b/icd/api/include/khronos/sdk-1.3/vulkan/vk_platform.h @@ -2,7 +2,7 @@ // File: vk_platform.h // /* -** Copyright 2014-2023 The Khronos Group Inc. +** Copyright 2014-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan.h b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan.h index 426cff58..ef94006b 100644 --- a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan.h +++ b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan.h @@ -2,7 +2,7 @@ #define VULKAN_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_android.h b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_android.h index 40b3c67b..61ff40ba 100644 --- a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_android.h +++ b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_android.h @@ -2,7 +2,7 @@ #define VULKAN_ANDROID_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_beta.h b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_beta.h index 1871651d..df18b404 100644 --- a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_beta.h +++ b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_beta.h @@ -2,7 +2,7 @@ #define VULKAN_BETA_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ @@ -51,603 +51,6 @@ typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR { -// VK_KHR_video_encode_queue is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_video_encode_queue 1 -#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 10 -#define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue" - -typedef enum VkVideoEncodeTuningModeKHR { - VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR = 0, - VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR = 1, - VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR = 2, - VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR = 3, - VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR = 4, - VK_VIDEO_ENCODE_TUNING_MODE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeTuningModeKHR; -typedef VkFlags VkVideoEncodeFlagsKHR; - -typedef enum VkVideoEncodeCapabilityFlagBitsKHR { - VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeCapabilityFlagBitsKHR; -typedef VkFlags VkVideoEncodeCapabilityFlagsKHR; - -typedef enum VkVideoEncodeRateControlModeFlagBitsKHR { - VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR = 0, - VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeRateControlModeFlagBitsKHR; -typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR; - -typedef enum VkVideoEncodeFeedbackFlagBitsKHR { - VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_FEEDBACK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeFeedbackFlagBitsKHR; -typedef VkFlags VkVideoEncodeFeedbackFlagsKHR; - -typedef enum VkVideoEncodeUsageFlagBitsKHR { - VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR = 0, - VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR = 0x00000008, - VK_VIDEO_ENCODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeUsageFlagBitsKHR; -typedef VkFlags VkVideoEncodeUsageFlagsKHR; - -typedef enum VkVideoEncodeContentFlagBitsKHR { - VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR = 0, - VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_CONTENT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeContentFlagBitsKHR; -typedef VkFlags VkVideoEncodeContentFlagsKHR; -typedef VkFlags VkVideoEncodeRateControlFlagsKHR; -typedef struct VkVideoEncodeInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoEncodeFlagsKHR flags; - VkBuffer dstBuffer; - VkDeviceSize dstBufferOffset; - VkDeviceSize dstBufferRange; - VkVideoPictureResourceInfoKHR srcPictureResource; - const VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot; - uint32_t referenceSlotCount; - const VkVideoReferenceSlotInfoKHR* pReferenceSlots; - uint32_t precedingExternallyEncodedBytes; -} VkVideoEncodeInfoKHR; - -typedef struct VkVideoEncodeCapabilitiesKHR { - VkStructureType sType; - void* pNext; - VkVideoEncodeCapabilityFlagsKHR flags; - VkVideoEncodeRateControlModeFlagsKHR rateControlModes; - uint32_t maxRateControlLayers; - uint64_t maxBitrate; - uint32_t maxQualityLevels; - VkExtent2D encodeInputPictureGranularity; - VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags; -} VkVideoEncodeCapabilitiesKHR; - -typedef struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags; -} VkQueryPoolVideoEncodeFeedbackCreateInfoKHR; - -typedef struct VkVideoEncodeUsageInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoEncodeUsageFlagsKHR videoUsageHints; - VkVideoEncodeContentFlagsKHR videoContentHints; - VkVideoEncodeTuningModeKHR tuningMode; -} VkVideoEncodeUsageInfoKHR; - -typedef struct VkVideoEncodeRateControlLayerInfoKHR { - VkStructureType sType; - const void* pNext; - uint64_t averageBitrate; - uint64_t maxBitrate; - uint32_t frameRateNumerator; - uint32_t frameRateDenominator; -} VkVideoEncodeRateControlLayerInfoKHR; - -typedef struct VkVideoEncodeRateControlInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoEncodeRateControlFlagsKHR flags; - VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode; - uint32_t layerCount; - const VkVideoEncodeRateControlLayerInfoKHR* pLayers; - uint32_t virtualBufferSizeInMs; - uint32_t initialVirtualBufferSizeInMs; -} VkVideoEncodeRateControlInfoKHR; - -typedef struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR { - VkStructureType sType; - const void* pNext; - const VkVideoProfileInfoKHR* pVideoProfile; - uint32_t qualityLevel; -} VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR; - -typedef struct VkVideoEncodeQualityLevelPropertiesKHR { - VkStructureType sType; - void* pNext; - VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode; - uint32_t preferredRateControlLayerCount; -} VkVideoEncodeQualityLevelPropertiesKHR; - -typedef struct VkVideoEncodeQualityLevelInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t qualityLevel; -} VkVideoEncodeQualityLevelInfoKHR; - -typedef struct VkVideoEncodeSessionParametersGetInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoSessionParametersKHR videoSessionParameters; -} VkVideoEncodeSessionParametersGetInfoKHR; - -typedef struct VkVideoEncodeSessionParametersFeedbackInfoKHR { - VkStructureType sType; - void* pNext; - VkBool32 hasOverrides; -} VkVideoEncodeSessionParametersFeedbackInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetEncodedVideoSessionParametersKHR)(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData); -typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, - VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetEncodedVideoSessionParametersKHR( - VkDevice device, - const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, - VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, - size_t* pDataSize, - void* pData); - -VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR( - VkCommandBuffer commandBuffer, - const VkVideoEncodeInfoKHR* pEncodeInfo); -#endif - - -// VK_EXT_video_encode_h264 is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_video_encode_h264 1 -#include "vk_video/vulkan_video_codec_h264std.h" -#include "vk_video/vulkan_video_codec_h264std_encode.h" -#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 12 -#define VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_EXT_video_encode_h264" - -typedef enum VkVideoEncodeH264CapabilityFlagBitsEXT { - VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000001, - VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT = 0x00000002, - VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT = 0x00000004, - VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0x00000008, - VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT = 0x00000010, - VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x00000020, - VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT = 0x00000040, - VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_EXT = 0x00000080, - VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_EXT = 0x00000100, - VK_VIDEO_ENCODE_H264_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkVideoEncodeH264CapabilityFlagBitsEXT; -typedef VkFlags VkVideoEncodeH264CapabilityFlagsEXT; - -typedef enum VkVideoEncodeH264StdFlagBitsEXT { - VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT = 0x00000001, - VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_EXT = 0x00000002, - VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_EXT = 0x00000004, - VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_EXT = 0x00000008, - VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_EXT = 0x00000010, - VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_EXT = 0x00000020, - VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT = 0x00000040, - VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_EXT = 0x00000080, - VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_EXT = 0x00000100, - VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_EXT = 0x00000200, - VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_EXT = 0x00000400, - VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_EXT = 0x00000800, - VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_EXT = 0x00001000, - VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_EXT = 0x00002000, - VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT = 0x00004000, - VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_EXT = 0x00008000, - VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_EXT = 0x00010000, - VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00020000, - VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_EXT = 0x00080000, - VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT = 0x00100000, - VK_VIDEO_ENCODE_H264_STD_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkVideoEncodeH264StdFlagBitsEXT; -typedef VkFlags VkVideoEncodeH264StdFlagsEXT; - -typedef enum VkVideoEncodeH264RateControlFlagBitsEXT { - VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT = 0x00000001, - VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_EXT = 0x00000002, - VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT = 0x00000004, - VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT = 0x00000008, - VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_EXT = 0x00000010, - VK_VIDEO_ENCODE_H264_RATE_CONTROL_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkVideoEncodeH264RateControlFlagBitsEXT; -typedef VkFlags VkVideoEncodeH264RateControlFlagsEXT; -typedef struct VkVideoEncodeH264CapabilitiesEXT { - VkStructureType sType; - void* pNext; - VkVideoEncodeH264CapabilityFlagsEXT flags; - StdVideoH264LevelIdc maxLevelIdc; - uint32_t maxSliceCount; - uint32_t maxPPictureL0ReferenceCount; - uint32_t maxBPictureL0ReferenceCount; - uint32_t maxL1ReferenceCount; - uint32_t maxTemporalLayerCount; - VkBool32 expectDyadicTemporalLayerPattern; - int32_t minQp; - int32_t maxQp; - VkBool32 prefersGopRemainingFrames; - VkBool32 requiresGopRemainingFrames; - VkVideoEncodeH264StdFlagsEXT stdSyntaxFlags; -} VkVideoEncodeH264CapabilitiesEXT; - -typedef struct VkVideoEncodeH264QpEXT { - int32_t qpI; - int32_t qpP; - int32_t qpB; -} VkVideoEncodeH264QpEXT; - -typedef struct VkVideoEncodeH264QualityLevelPropertiesEXT { - VkStructureType sType; - void* pNext; - VkVideoEncodeH264RateControlFlagsEXT preferredRateControlFlags; - uint32_t preferredGopFrameCount; - uint32_t preferredIdrPeriod; - uint32_t preferredConsecutiveBFrameCount; - uint32_t preferredTemporalLayerCount; - VkVideoEncodeH264QpEXT preferredConstantQp; - uint32_t preferredMaxL0ReferenceCount; - uint32_t preferredMaxL1ReferenceCount; - VkBool32 preferredStdEntropyCodingModeFlag; -} VkVideoEncodeH264QualityLevelPropertiesEXT; - -typedef struct VkVideoEncodeH264SessionCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 useMaxLevelIdc; - StdVideoH264LevelIdc maxLevelIdc; -} VkVideoEncodeH264SessionCreateInfoEXT; - -typedef struct VkVideoEncodeH264SessionParametersAddInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t stdSPSCount; - const StdVideoH264SequenceParameterSet* pStdSPSs; - uint32_t stdPPSCount; - const StdVideoH264PictureParameterSet* pStdPPSs; -} VkVideoEncodeH264SessionParametersAddInfoEXT; - -typedef struct VkVideoEncodeH264SessionParametersCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t maxStdSPSCount; - uint32_t maxStdPPSCount; - const VkVideoEncodeH264SessionParametersAddInfoEXT* pParametersAddInfo; -} VkVideoEncodeH264SessionParametersCreateInfoEXT; - -typedef struct VkVideoEncodeH264SessionParametersGetInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 writeStdSPS; - VkBool32 writeStdPPS; - uint32_t stdSPSId; - uint32_t stdPPSId; -} VkVideoEncodeH264SessionParametersGetInfoEXT; - -typedef struct VkVideoEncodeH264SessionParametersFeedbackInfoEXT { - VkStructureType sType; - void* pNext; - VkBool32 hasStdSPSOverrides; - VkBool32 hasStdPPSOverrides; -} VkVideoEncodeH264SessionParametersFeedbackInfoEXT; - -typedef struct VkVideoEncodeH264NaluSliceInfoEXT { - VkStructureType sType; - const void* pNext; - int32_t constantQp; - const StdVideoEncodeH264SliceHeader* pStdSliceHeader; -} VkVideoEncodeH264NaluSliceInfoEXT; - -typedef struct VkVideoEncodeH264PictureInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t naluSliceEntryCount; - const VkVideoEncodeH264NaluSliceInfoEXT* pNaluSliceEntries; - const StdVideoEncodeH264PictureInfo* pStdPictureInfo; - VkBool32 generatePrefixNalu; -} VkVideoEncodeH264PictureInfoEXT; - -typedef struct VkVideoEncodeH264DpbSlotInfoEXT { - VkStructureType sType; - const void* pNext; - const StdVideoEncodeH264ReferenceInfo* pStdReferenceInfo; -} VkVideoEncodeH264DpbSlotInfoEXT; - -typedef struct VkVideoEncodeH264ProfileInfoEXT { - VkStructureType sType; - const void* pNext; - StdVideoH264ProfileIdc stdProfileIdc; -} VkVideoEncodeH264ProfileInfoEXT; - -typedef struct VkVideoEncodeH264RateControlInfoEXT { - VkStructureType sType; - const void* pNext; - VkVideoEncodeH264RateControlFlagsEXT flags; - uint32_t gopFrameCount; - uint32_t idrPeriod; - uint32_t consecutiveBFrameCount; - uint32_t temporalLayerCount; -} VkVideoEncodeH264RateControlInfoEXT; - -typedef struct VkVideoEncodeH264FrameSizeEXT { - uint32_t frameISize; - uint32_t framePSize; - uint32_t frameBSize; -} VkVideoEncodeH264FrameSizeEXT; - -typedef struct VkVideoEncodeH264RateControlLayerInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 useMinQp; - VkVideoEncodeH264QpEXT minQp; - VkBool32 useMaxQp; - VkVideoEncodeH264QpEXT maxQp; - VkBool32 useMaxFrameSize; - VkVideoEncodeH264FrameSizeEXT maxFrameSize; -} VkVideoEncodeH264RateControlLayerInfoEXT; - -typedef struct VkVideoEncodeH264GopRemainingFrameInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 useGopRemainingFrames; - uint32_t gopRemainingI; - uint32_t gopRemainingP; - uint32_t gopRemainingB; -} VkVideoEncodeH264GopRemainingFrameInfoEXT; - - - -// VK_EXT_video_encode_h265 is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_video_encode_h265 1 -#include "vk_video/vulkan_video_codec_h265std.h" -#include "vk_video/vulkan_video_codec_h265std_encode.h" -#define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 12 -#define VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME "VK_EXT_video_encode_h265" - -typedef enum VkVideoEncodeH265CapabilityFlagBitsEXT { - VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000001, - VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT = 0x00000002, - VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT = 0x00000004, - VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_EXT = 0x00000008, - VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT = 0x00000010, - VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x00000020, - VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT = 0x00000040, - VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_EXT = 0x00000080, - VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_EXT = 0x00000100, - VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_EXT = 0x00000200, - VK_VIDEO_ENCODE_H265_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkVideoEncodeH265CapabilityFlagBitsEXT; -typedef VkFlags VkVideoEncodeH265CapabilityFlagsEXT; - -typedef enum VkVideoEncodeH265StdFlagBitsEXT { - VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT = 0x00000001, - VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_EXT = 0x00000002, - VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_EXT = 0x00000004, - VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_EXT = 0x00000008, - VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_EXT = 0x00000010, - VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_EXT = 0x00000020, - VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT = 0x00000040, - VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_EXT = 0x00000080, - VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT = 0x00000100, - VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_EXT = 0x00000200, - VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_EXT = 0x00000400, - VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_EXT = 0x00000800, - VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_EXT = 0x00001000, - VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_EXT = 0x00002000, - VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT = 0x00004000, - VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_EXT = 0x00008000, - VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_EXT = 0x00010000, - VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_EXT = 0x00020000, - VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_EXT = 0x00040000, - VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_EXT = 0x00080000, - VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT = 0x00100000, - VK_VIDEO_ENCODE_H265_STD_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkVideoEncodeH265StdFlagBitsEXT; -typedef VkFlags VkVideoEncodeH265StdFlagsEXT; - -typedef enum VkVideoEncodeH265CtbSizeFlagBitsEXT { - VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT = 0x00000001, - VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT = 0x00000002, - VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT = 0x00000004, - VK_VIDEO_ENCODE_H265_CTB_SIZE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkVideoEncodeH265CtbSizeFlagBitsEXT; -typedef VkFlags VkVideoEncodeH265CtbSizeFlagsEXT; - -typedef enum VkVideoEncodeH265TransformBlockSizeFlagBitsEXT { - VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT = 0x00000001, - VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT = 0x00000002, - VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT = 0x00000004, - VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT = 0x00000008, - VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkVideoEncodeH265TransformBlockSizeFlagBitsEXT; -typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsEXT; - -typedef enum VkVideoEncodeH265RateControlFlagBitsEXT { - VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT = 0x00000001, - VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_EXT = 0x00000002, - VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT = 0x00000004, - VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT = 0x00000008, - VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_EXT = 0x00000010, - VK_VIDEO_ENCODE_H265_RATE_CONTROL_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkVideoEncodeH265RateControlFlagBitsEXT; -typedef VkFlags VkVideoEncodeH265RateControlFlagsEXT; -typedef struct VkVideoEncodeH265CapabilitiesEXT { - VkStructureType sType; - void* pNext; - VkVideoEncodeH265CapabilityFlagsEXT flags; - StdVideoH265LevelIdc maxLevelIdc; - uint32_t maxSliceSegmentCount; - VkExtent2D maxTiles; - VkVideoEncodeH265CtbSizeFlagsEXT ctbSizes; - VkVideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes; - uint32_t maxPPictureL0ReferenceCount; - uint32_t maxBPictureL0ReferenceCount; - uint32_t maxL1ReferenceCount; - uint32_t maxSubLayerCount; - VkBool32 expectDyadicTemporalSubLayerPattern; - int32_t minQp; - int32_t maxQp; - VkBool32 prefersGopRemainingFrames; - VkBool32 requiresGopRemainingFrames; - VkVideoEncodeH265StdFlagsEXT stdSyntaxFlags; -} VkVideoEncodeH265CapabilitiesEXT; - -typedef struct VkVideoEncodeH265SessionCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 useMaxLevelIdc; - StdVideoH265LevelIdc maxLevelIdc; -} VkVideoEncodeH265SessionCreateInfoEXT; - -typedef struct VkVideoEncodeH265QpEXT { - int32_t qpI; - int32_t qpP; - int32_t qpB; -} VkVideoEncodeH265QpEXT; - -typedef struct VkVideoEncodeH265QualityLevelPropertiesEXT { - VkStructureType sType; - void* pNext; - VkVideoEncodeH265RateControlFlagsEXT preferredRateControlFlags; - uint32_t preferredGopFrameCount; - uint32_t preferredIdrPeriod; - uint32_t preferredConsecutiveBFrameCount; - uint32_t preferredSubLayerCount; - VkVideoEncodeH265QpEXT preferredConstantQp; - uint32_t preferredMaxL0ReferenceCount; - uint32_t preferredMaxL1ReferenceCount; -} VkVideoEncodeH265QualityLevelPropertiesEXT; - -typedef struct VkVideoEncodeH265SessionParametersAddInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t stdVPSCount; - const StdVideoH265VideoParameterSet* pStdVPSs; - uint32_t stdSPSCount; - const StdVideoH265SequenceParameterSet* pStdSPSs; - uint32_t stdPPSCount; - const StdVideoH265PictureParameterSet* pStdPPSs; -} VkVideoEncodeH265SessionParametersAddInfoEXT; - -typedef struct VkVideoEncodeH265SessionParametersCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t maxStdVPSCount; - uint32_t maxStdSPSCount; - uint32_t maxStdPPSCount; - const VkVideoEncodeH265SessionParametersAddInfoEXT* pParametersAddInfo; -} VkVideoEncodeH265SessionParametersCreateInfoEXT; - -typedef struct VkVideoEncodeH265SessionParametersGetInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 writeStdVPS; - VkBool32 writeStdSPS; - VkBool32 writeStdPPS; - uint32_t stdVPSId; - uint32_t stdSPSId; - uint32_t stdPPSId; -} VkVideoEncodeH265SessionParametersGetInfoEXT; - -typedef struct VkVideoEncodeH265SessionParametersFeedbackInfoEXT { - VkStructureType sType; - void* pNext; - VkBool32 hasStdVPSOverrides; - VkBool32 hasStdSPSOverrides; - VkBool32 hasStdPPSOverrides; -} VkVideoEncodeH265SessionParametersFeedbackInfoEXT; - -typedef struct VkVideoEncodeH265NaluSliceSegmentInfoEXT { - VkStructureType sType; - const void* pNext; - int32_t constantQp; - const StdVideoEncodeH265SliceSegmentHeader* pStdSliceSegmentHeader; -} VkVideoEncodeH265NaluSliceSegmentInfoEXT; - -typedef struct VkVideoEncodeH265PictureInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t naluSliceSegmentEntryCount; - const VkVideoEncodeH265NaluSliceSegmentInfoEXT* pNaluSliceSegmentEntries; - const StdVideoEncodeH265PictureInfo* pStdPictureInfo; -} VkVideoEncodeH265PictureInfoEXT; - -typedef struct VkVideoEncodeH265DpbSlotInfoEXT { - VkStructureType sType; - const void* pNext; - const StdVideoEncodeH265ReferenceInfo* pStdReferenceInfo; -} VkVideoEncodeH265DpbSlotInfoEXT; - -typedef struct VkVideoEncodeH265ProfileInfoEXT { - VkStructureType sType; - const void* pNext; - StdVideoH265ProfileIdc stdProfileIdc; -} VkVideoEncodeH265ProfileInfoEXT; - -typedef struct VkVideoEncodeH265RateControlInfoEXT { - VkStructureType sType; - const void* pNext; - VkVideoEncodeH265RateControlFlagsEXT flags; - uint32_t gopFrameCount; - uint32_t idrPeriod; - uint32_t consecutiveBFrameCount; - uint32_t subLayerCount; -} VkVideoEncodeH265RateControlInfoEXT; - -typedef struct VkVideoEncodeH265FrameSizeEXT { - uint32_t frameISize; - uint32_t framePSize; - uint32_t frameBSize; -} VkVideoEncodeH265FrameSizeEXT; - -typedef struct VkVideoEncodeH265RateControlLayerInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 useMinQp; - VkVideoEncodeH265QpEXT minQp; - VkBool32 useMaxQp; - VkVideoEncodeH265QpEXT maxQp; - VkBool32 useMaxFrameSize; - VkVideoEncodeH265FrameSizeEXT maxFrameSize; -} VkVideoEncodeH265RateControlLayerInfoEXT; - -typedef struct VkVideoEncodeH265GopRemainingFrameInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 useGopRemainingFrames; - uint32_t gopRemainingI; - uint32_t gopRemainingP; - uint32_t gopRemainingB; -} VkVideoEncodeH265GopRemainingFrameInfoEXT; - - - // VK_AMDX_shader_enqueue is a preprocessor guard. Do not pass it to API calls. #define VK_AMDX_shader_enqueue 1 #define VK_AMDX_SHADER_ENQUEUE_SPEC_VERSION 1 diff --git a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_core.h b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_core.h index 51408d77..a4666edc 100644 --- a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_core.h +++ b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_core.h @@ -2,7 +2,7 @@ #define VULKAN_CORE_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ @@ -69,7 +69,7 @@ extern "C" { #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 273 +#define VK_HEADER_VERSION 277 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) @@ -182,9 +182,7 @@ typedef enum VkResult { VK_THREAD_DONE_KHR = 1000268001, VK_OPERATION_DEFERRED_KHR = 1000268002, VK_OPERATION_NOT_DEFERRED_KHR = 1000268003, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR = -1000299000, -#endif VK_ERROR_COMPRESSION_EXHAUSTED_EXT = -1000338000, VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000, VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, @@ -467,90 +465,34 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX = 1000029002, VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000, VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT = 1000038000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000038001, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000038002, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT = 1000038003, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT = 1000038004, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT = 1000038005, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT = 1000038006, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT = 1000038007, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT = 1000038008, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT = 1000038009, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT = 1000038010, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT = 1000038011, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT = 1000038012, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT = 1000038013, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT = 1000039000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000039001, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000039002, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT = 1000039003, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT = 1000039004, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT = 1000039005, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT = 1000039006, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT = 1000039007, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT = 1000039009, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT = 1000039010, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT = 1000039011, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT = 1000039012, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT = 1000039013, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT = 1000039014, -#endif + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR = 1000038000, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000038001, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR = 1000038002, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR = 1000038003, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR = 1000038004, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR = 1000038005, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR = 1000038006, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR = 1000038007, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR = 1000038008, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR = 1000038009, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR = 1000038010, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR = 1000038011, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR = 1000038012, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000038013, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR = 1000039000, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000039001, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR = 1000039002, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR = 1000039003, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR = 1000039004, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR = 1000039005, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR = 1000039006, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR = 1000039007, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR = 1000039009, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR = 1000039010, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR = 1000039011, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR = 1000039012, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR = 1000039013, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000039014, VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR = 1000040000, VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR = 1000040001, VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR = 1000040003, @@ -776,7 +718,11 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR = 1000232000, + VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR = 1000232001, + VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR = 1000232002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR = 1000235000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000, VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001, @@ -801,11 +747,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002, VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001, VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000, VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001, @@ -865,39 +807,17 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV = 1000292002, VK_STRUCTURE_TYPE_PRESENT_ID_KHR = 1000294000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR = 1000299000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR = 1000299001, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR = 1000299002, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR = 1000299003, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR = 1000299004, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR = 1000299005, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR = 1000299006, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR = 1000299007, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR = 1000299008, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR = 1000299009, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000299010, -#endif VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000, VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001, VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV = 1000307000, @@ -1039,6 +959,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM = 1000415000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR = 1000416000, VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM = 1000417000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM = 1000417001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM = 1000417002, @@ -1065,6 +986,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV = 1000428001, VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV = 1000428002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR = 1000434000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT = 1000437000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001, @@ -1139,6 +1061,14 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000, VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR = 1000512000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR = 1000512001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR = 1000512003, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000512004, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR = 1000512005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR = 1000515000, + VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR = 1000515001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV = 1000516000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM = 1000518000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM = 1000518001, VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM = 1000518002, @@ -1152,13 +1082,28 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR = 1000525000, VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR = 1000190001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR = 1000190002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR = 1000528000, VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX = 1000529000, VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX = 1000529001, VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX = 1000529002, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX = 1000529003, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX = 1000529004, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT = 1000530000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR = 1000265000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR = 1000259000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR = 1000259001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR = 1000259002, VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR = 1000184000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR = 1000544000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR = 1000545000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR = 1000545001, + VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR = 1000545002, + VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR = 1000545003, + VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR = 1000545004, + VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR = 1000545005, + VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR = 1000545006, + VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT = 1000545007, + VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT = 1000545008, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, @@ -1295,7 +1240,11 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES, @@ -1372,15 +1321,10 @@ typedef enum VkImageLayout { VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000, VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003, -#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR = 1000232000, VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR = 1000299000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR = 1000299001, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002, -#endif VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT = 1000339000, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, @@ -1819,9 +1763,7 @@ typedef enum VkQueryType { VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001, VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR = 1000299000, -#endif VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT = 1000328000, VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT = 1000382000, VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR = 1000386000, @@ -1985,12 +1927,10 @@ typedef enum VkDynamicState { VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV = 1000205000, VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001, VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000, - VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000, VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000, VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000, VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003, VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000, - VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002, VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT = 1000455003, VK_DYNAMIC_STATE_POLYGON_MODE_EXT = 1000455004, VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT = 1000455005, @@ -2001,6 +1941,7 @@ typedef enum VkDynamicState { VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT = 1000455010, VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT = 1000455011, VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT = 1000455012, + VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002, VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT = 1000455013, VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT = 1000455014, VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT = 1000455015, @@ -2022,6 +1963,8 @@ typedef enum VkDynamicState { VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031, VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032, VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT = 1000524000, + VK_DYNAMIC_STATE_LINE_STIPPLE_KHR = 1000259000, + VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = VK_DYNAMIC_STATE_LINE_STIPPLE_KHR, VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE, VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE, VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY, @@ -2170,7 +2113,8 @@ typedef enum VkAttachmentLoadOp { VK_ATTACHMENT_LOAD_OP_LOAD = 0, VK_ATTACHMENT_LOAD_OP_CLEAR = 1, VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, - VK_ATTACHMENT_LOAD_OP_NONE_EXT = 1000400000, + VK_ATTACHMENT_LOAD_OP_NONE_KHR = 1000400000, + VK_ATTACHMENT_LOAD_OP_NONE_EXT = VK_ATTACHMENT_LOAD_OP_NONE_KHR, VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF } VkAttachmentLoadOp; @@ -2206,8 +2150,9 @@ typedef enum VkIndexType { VK_INDEX_TYPE_UINT16 = 0, VK_INDEX_TYPE_UINT32 = 1, VK_INDEX_TYPE_NONE_KHR = 1000165000, - VK_INDEX_TYPE_UINT8_EXT = 1000265000, + VK_INDEX_TYPE_UINT8_KHR = 1000265000, VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR, + VK_INDEX_TYPE_UINT8_EXT = VK_INDEX_TYPE_UINT8_KHR, VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF } VkIndexType; @@ -2307,12 +2252,8 @@ typedef enum VkFormatFeatureFlagBits { VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000, VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000, VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000, -#endif VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT, VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, @@ -2348,6 +2289,7 @@ typedef enum VkImageCreateFlagBits { VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00040000, VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000, VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = 0x00008000, + VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 0x00100000, VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, @@ -2385,15 +2327,9 @@ typedef enum VkImageUsageFlagBits { VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200, VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00000100, VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT = 0x00400000, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00002000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00004000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR = 0x00008000, -#endif VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x00080000, VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0x00040000, VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 0x00100000, @@ -2438,9 +2374,7 @@ typedef enum VkQueueFlagBits { VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, VK_QUEUE_PROTECTED_BIT = 0x00000010, VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0x00000020, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_QUEUE_VIDEO_ENCODE_BIT_KHR = 0x00000040, -#endif VK_QUEUE_OPTICAL_FLOW_BIT_NV = 0x00000100, VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkQueueFlagBits; @@ -2557,6 +2491,7 @@ typedef enum VkBufferCreateFlagBits { VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008, VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000010, VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000020, + VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 0x00000040, VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF @@ -2585,12 +2520,8 @@ typedef enum VkBufferUsageFlagBits { VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000, VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000, VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR = 0x00000400, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00008000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00010000, -#endif VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 0x00200000, VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00400000, VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000, @@ -2782,6 +2713,7 @@ typedef enum VkDescriptorSetLayoutCreateFlagBits { VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT = 0x00000020, VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00000080, VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT = 0x00000004, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV = 0x00000040, VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT, VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF @@ -5011,6 +4943,8 @@ typedef enum VkSubgroupFeatureFlagBits { VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100, + VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR = 0x00000200, + VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR = 0x00000400, VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkSubgroupFeatureFlagBits; typedef VkFlags VkSubgroupFeatureFlags; @@ -6655,9 +6589,7 @@ static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT = 0x4000000000ULL; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 0x4000000000ULL; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR = 0x04000000ULL; -#ifdef VK_ENABLE_BETA_EXTENSIONS static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR = 0x08000000ULL; -#endif static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000ULL; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000ULL; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0x00020000ULL; @@ -6728,12 +6660,8 @@ static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT = 0x40000000 static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 0x400000000ULL; static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0x800000000ULL; static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0x1000000000ULL; -#ifdef VK_ENABLE_BETA_EXTENSIONS static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR = 0x2000000000ULL; -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR = 0x4000000000ULL; -#endif static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000ULL; static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000ULL; static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000ULL; @@ -6840,12 +6768,8 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT = 0x400000000000ULL; -#ifdef VK_ENABLE_BETA_EXTENSIONS static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000ULL; -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000ULL; -#endif static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 0x4000000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM = 0x400000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM = 0x800000000ULL; @@ -8056,14 +7980,11 @@ typedef enum VkQueryResultStatusKHR { typedef enum VkVideoCodecOperationFlagBitsKHR { VK_VIDEO_CODEC_OPERATION_NONE_KHR = 0, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT = 0x00010000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT = 0x00020000, -#endif + VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR = 0x00010000, + VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR = 0x00020000, VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR = 0x00000001, VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR = 0x00000002, + VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR = 0x00000004, VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkVideoCodecOperationFlagBitsKHR; typedef VkFlags VkVideoCodecOperationFlagsKHR; @@ -8096,9 +8017,8 @@ typedef VkFlags VkVideoCapabilityFlagsKHR; typedef enum VkVideoSessionCreateFlagBitsKHR { VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x00000001, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR = 0x00000002, -#endif + VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR = 0x00000004, VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkVideoSessionCreateFlagBitsKHR; typedef VkFlags VkVideoSessionCreateFlagsKHR; @@ -8108,12 +8028,8 @@ typedef VkFlags VkVideoEndCodingFlagsKHR; typedef enum VkVideoCodingControlFlagBitsKHR { VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0x00000001, -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR = 0x00000002, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR = 0x00000004, -#endif VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkVideoCodingControlFlagBitsKHR; typedef VkFlags VkVideoCodingControlFlagsKHR; @@ -8338,7 +8254,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR( // VK_KHR_video_decode_queue is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_video_decode_queue 1 -#define VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION 7 +#define VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION 8 #define VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME "VK_KHR_video_decode_queue" typedef enum VkVideoDecodeCapabilityFlagBitsKHR { @@ -8391,11 +8307,434 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR( #endif +// VK_KHR_video_encode_h264 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_encode_h264 1 +#include "vk_video/vulkan_video_codec_h264std.h" +#include "vk_video/vulkan_video_codec_h264std_encode.h" +#define VK_KHR_VIDEO_ENCODE_H264_SPEC_VERSION 14 +#define VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_KHR_video_encode_h264" + +typedef enum VkVideoEncodeH264CapabilityFlagBitsKHR { + VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR = 0x00000010, + VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR = 0x00000020, + VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR = 0x00000040, + VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR = 0x00000080, + VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR = 0x00000100, + VK_VIDEO_ENCODE_H264_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeH264CapabilityFlagBitsKHR; +typedef VkFlags VkVideoEncodeH264CapabilityFlagsKHR; + +typedef enum VkVideoEncodeH264StdFlagBitsKHR { + VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR = 0x00000010, + VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR = 0x00000020, + VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR = 0x00000040, + VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR = 0x00000080, + VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR = 0x00000100, + VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR = 0x00000200, + VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR = 0x00000400, + VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR = 0x00000800, + VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR = 0x00001000, + VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR = 0x00002000, + VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR = 0x00004000, + VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR = 0x00008000, + VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR = 0x00010000, + VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR = 0x00020000, + VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR = 0x00080000, + VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR = 0x00100000, + VK_VIDEO_ENCODE_H264_STD_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeH264StdFlagBitsKHR; +typedef VkFlags VkVideoEncodeH264StdFlagsKHR; + +typedef enum VkVideoEncodeH264RateControlFlagBitsKHR { + VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR = 0x00000010, + VK_VIDEO_ENCODE_H264_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeH264RateControlFlagBitsKHR; +typedef VkFlags VkVideoEncodeH264RateControlFlagsKHR; +typedef struct VkVideoEncodeH264CapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeH264CapabilityFlagsKHR flags; + StdVideoH264LevelIdc maxLevelIdc; + uint32_t maxSliceCount; + uint32_t maxPPictureL0ReferenceCount; + uint32_t maxBPictureL0ReferenceCount; + uint32_t maxL1ReferenceCount; + uint32_t maxTemporalLayerCount; + VkBool32 expectDyadicTemporalLayerPattern; + int32_t minQp; + int32_t maxQp; + VkBool32 prefersGopRemainingFrames; + VkBool32 requiresGopRemainingFrames; + VkVideoEncodeH264StdFlagsKHR stdSyntaxFlags; +} VkVideoEncodeH264CapabilitiesKHR; + +typedef struct VkVideoEncodeH264QpKHR { + int32_t qpI; + int32_t qpP; + int32_t qpB; +} VkVideoEncodeH264QpKHR; + +typedef struct VkVideoEncodeH264QualityLevelPropertiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeH264RateControlFlagsKHR preferredRateControlFlags; + uint32_t preferredGopFrameCount; + uint32_t preferredIdrPeriod; + uint32_t preferredConsecutiveBFrameCount; + uint32_t preferredTemporalLayerCount; + VkVideoEncodeH264QpKHR preferredConstantQp; + uint32_t preferredMaxL0ReferenceCount; + uint32_t preferredMaxL1ReferenceCount; + VkBool32 preferredStdEntropyCodingModeFlag; +} VkVideoEncodeH264QualityLevelPropertiesKHR; + +typedef struct VkVideoEncodeH264SessionCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 useMaxLevelIdc; + StdVideoH264LevelIdc maxLevelIdc; +} VkVideoEncodeH264SessionCreateInfoKHR; + +typedef struct VkVideoEncodeH264SessionParametersAddInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t stdSPSCount; + const StdVideoH264SequenceParameterSet* pStdSPSs; + uint32_t stdPPSCount; + const StdVideoH264PictureParameterSet* pStdPPSs; +} VkVideoEncodeH264SessionParametersAddInfoKHR; + +typedef struct VkVideoEncodeH264SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + const VkVideoEncodeH264SessionParametersAddInfoKHR* pParametersAddInfo; +} VkVideoEncodeH264SessionParametersCreateInfoKHR; + +typedef struct VkVideoEncodeH264SessionParametersGetInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 writeStdSPS; + VkBool32 writeStdPPS; + uint32_t stdSPSId; + uint32_t stdPPSId; +} VkVideoEncodeH264SessionParametersGetInfoKHR; + +typedef struct VkVideoEncodeH264SessionParametersFeedbackInfoKHR { + VkStructureType sType; + void* pNext; + VkBool32 hasStdSPSOverrides; + VkBool32 hasStdPPSOverrides; +} VkVideoEncodeH264SessionParametersFeedbackInfoKHR; + +typedef struct VkVideoEncodeH264NaluSliceInfoKHR { + VkStructureType sType; + const void* pNext; + int32_t constantQp; + const StdVideoEncodeH264SliceHeader* pStdSliceHeader; +} VkVideoEncodeH264NaluSliceInfoKHR; + +typedef struct VkVideoEncodeH264PictureInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t naluSliceEntryCount; + const VkVideoEncodeH264NaluSliceInfoKHR* pNaluSliceEntries; + const StdVideoEncodeH264PictureInfo* pStdPictureInfo; + VkBool32 generatePrefixNalu; +} VkVideoEncodeH264PictureInfoKHR; + +typedef struct VkVideoEncodeH264DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoEncodeH264ReferenceInfo* pStdReferenceInfo; +} VkVideoEncodeH264DpbSlotInfoKHR; + +typedef struct VkVideoEncodeH264ProfileInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoH264ProfileIdc stdProfileIdc; +} VkVideoEncodeH264ProfileInfoKHR; + +typedef struct VkVideoEncodeH264RateControlInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeH264RateControlFlagsKHR flags; + uint32_t gopFrameCount; + uint32_t idrPeriod; + uint32_t consecutiveBFrameCount; + uint32_t temporalLayerCount; +} VkVideoEncodeH264RateControlInfoKHR; + +typedef struct VkVideoEncodeH264FrameSizeKHR { + uint32_t frameISize; + uint32_t framePSize; + uint32_t frameBSize; +} VkVideoEncodeH264FrameSizeKHR; + +typedef struct VkVideoEncodeH264RateControlLayerInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 useMinQp; + VkVideoEncodeH264QpKHR minQp; + VkBool32 useMaxQp; + VkVideoEncodeH264QpKHR maxQp; + VkBool32 useMaxFrameSize; + VkVideoEncodeH264FrameSizeKHR maxFrameSize; +} VkVideoEncodeH264RateControlLayerInfoKHR; + +typedef struct VkVideoEncodeH264GopRemainingFrameInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 useGopRemainingFrames; + uint32_t gopRemainingI; + uint32_t gopRemainingP; + uint32_t gopRemainingB; +} VkVideoEncodeH264GopRemainingFrameInfoKHR; + + + +// VK_KHR_video_encode_h265 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_encode_h265 1 +#include "vk_video/vulkan_video_codec_h265std.h" +#include "vk_video/vulkan_video_codec_h265std_encode.h" +#define VK_KHR_VIDEO_ENCODE_H265_SPEC_VERSION 14 +#define VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME "VK_KHR_video_encode_h265" + +typedef enum VkVideoEncodeH265CapabilityFlagBitsKHR { + VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR = 0x00000010, + VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR = 0x00000020, + VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR = 0x00000040, + VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR = 0x00000080, + VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR = 0x00000100, + VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR = 0x00000200, + VK_VIDEO_ENCODE_H265_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeH265CapabilityFlagBitsKHR; +typedef VkFlags VkVideoEncodeH265CapabilityFlagsKHR; + +typedef enum VkVideoEncodeH265StdFlagBitsKHR { + VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR = 0x00000010, + VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR = 0x00000020, + VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR = 0x00000040, + VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR = 0x00000080, + VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR = 0x00000100, + VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR = 0x00000200, + VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR = 0x00000400, + VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR = 0x00000800, + VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR = 0x00001000, + VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR = 0x00002000, + VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR = 0x00004000, + VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR = 0x00008000, + VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR = 0x00010000, + VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR = 0x00020000, + VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR = 0x00040000, + VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR = 0x00080000, + VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR = 0x00100000, + VK_VIDEO_ENCODE_H265_STD_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeH265StdFlagBitsKHR; +typedef VkFlags VkVideoEncodeH265StdFlagsKHR; + +typedef enum VkVideoEncodeH265CtbSizeFlagBitsKHR { + VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_H265_CTB_SIZE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeH265CtbSizeFlagBitsKHR; +typedef VkFlags VkVideoEncodeH265CtbSizeFlagsKHR; + +typedef enum VkVideoEncodeH265TransformBlockSizeFlagBitsKHR { + VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeH265TransformBlockSizeFlagBitsKHR; +typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsKHR; + +typedef enum VkVideoEncodeH265RateControlFlagBitsKHR { + VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR = 0x00000010, + VK_VIDEO_ENCODE_H265_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeH265RateControlFlagBitsKHR; +typedef VkFlags VkVideoEncodeH265RateControlFlagsKHR; +typedef struct VkVideoEncodeH265CapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeH265CapabilityFlagsKHR flags; + StdVideoH265LevelIdc maxLevelIdc; + uint32_t maxSliceSegmentCount; + VkExtent2D maxTiles; + VkVideoEncodeH265CtbSizeFlagsKHR ctbSizes; + VkVideoEncodeH265TransformBlockSizeFlagsKHR transformBlockSizes; + uint32_t maxPPictureL0ReferenceCount; + uint32_t maxBPictureL0ReferenceCount; + uint32_t maxL1ReferenceCount; + uint32_t maxSubLayerCount; + VkBool32 expectDyadicTemporalSubLayerPattern; + int32_t minQp; + int32_t maxQp; + VkBool32 prefersGopRemainingFrames; + VkBool32 requiresGopRemainingFrames; + VkVideoEncodeH265StdFlagsKHR stdSyntaxFlags; +} VkVideoEncodeH265CapabilitiesKHR; + +typedef struct VkVideoEncodeH265SessionCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 useMaxLevelIdc; + StdVideoH265LevelIdc maxLevelIdc; +} VkVideoEncodeH265SessionCreateInfoKHR; + +typedef struct VkVideoEncodeH265QpKHR { + int32_t qpI; + int32_t qpP; + int32_t qpB; +} VkVideoEncodeH265QpKHR; + +typedef struct VkVideoEncodeH265QualityLevelPropertiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeH265RateControlFlagsKHR preferredRateControlFlags; + uint32_t preferredGopFrameCount; + uint32_t preferredIdrPeriod; + uint32_t preferredConsecutiveBFrameCount; + uint32_t preferredSubLayerCount; + VkVideoEncodeH265QpKHR preferredConstantQp; + uint32_t preferredMaxL0ReferenceCount; + uint32_t preferredMaxL1ReferenceCount; +} VkVideoEncodeH265QualityLevelPropertiesKHR; + +typedef struct VkVideoEncodeH265SessionParametersAddInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t stdVPSCount; + const StdVideoH265VideoParameterSet* pStdVPSs; + uint32_t stdSPSCount; + const StdVideoH265SequenceParameterSet* pStdSPSs; + uint32_t stdPPSCount; + const StdVideoH265PictureParameterSet* pStdPPSs; +} VkVideoEncodeH265SessionParametersAddInfoKHR; + +typedef struct VkVideoEncodeH265SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t maxStdVPSCount; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + const VkVideoEncodeH265SessionParametersAddInfoKHR* pParametersAddInfo; +} VkVideoEncodeH265SessionParametersCreateInfoKHR; + +typedef struct VkVideoEncodeH265SessionParametersGetInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 writeStdVPS; + VkBool32 writeStdSPS; + VkBool32 writeStdPPS; + uint32_t stdVPSId; + uint32_t stdSPSId; + uint32_t stdPPSId; +} VkVideoEncodeH265SessionParametersGetInfoKHR; + +typedef struct VkVideoEncodeH265SessionParametersFeedbackInfoKHR { + VkStructureType sType; + void* pNext; + VkBool32 hasStdVPSOverrides; + VkBool32 hasStdSPSOverrides; + VkBool32 hasStdPPSOverrides; +} VkVideoEncodeH265SessionParametersFeedbackInfoKHR; + +typedef struct VkVideoEncodeH265NaluSliceSegmentInfoKHR { + VkStructureType sType; + const void* pNext; + int32_t constantQp; + const StdVideoEncodeH265SliceSegmentHeader* pStdSliceSegmentHeader; +} VkVideoEncodeH265NaluSliceSegmentInfoKHR; + +typedef struct VkVideoEncodeH265PictureInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t naluSliceSegmentEntryCount; + const VkVideoEncodeH265NaluSliceSegmentInfoKHR* pNaluSliceSegmentEntries; + const StdVideoEncodeH265PictureInfo* pStdPictureInfo; +} VkVideoEncodeH265PictureInfoKHR; + +typedef struct VkVideoEncodeH265DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoEncodeH265ReferenceInfo* pStdReferenceInfo; +} VkVideoEncodeH265DpbSlotInfoKHR; + +typedef struct VkVideoEncodeH265ProfileInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoH265ProfileIdc stdProfileIdc; +} VkVideoEncodeH265ProfileInfoKHR; + +typedef struct VkVideoEncodeH265RateControlInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeH265RateControlFlagsKHR flags; + uint32_t gopFrameCount; + uint32_t idrPeriod; + uint32_t consecutiveBFrameCount; + uint32_t subLayerCount; +} VkVideoEncodeH265RateControlInfoKHR; + +typedef struct VkVideoEncodeH265FrameSizeKHR { + uint32_t frameISize; + uint32_t framePSize; + uint32_t frameBSize; +} VkVideoEncodeH265FrameSizeKHR; + +typedef struct VkVideoEncodeH265RateControlLayerInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 useMinQp; + VkVideoEncodeH265QpKHR minQp; + VkBool32 useMaxQp; + VkVideoEncodeH265QpKHR maxQp; + VkBool32 useMaxFrameSize; + VkVideoEncodeH265FrameSizeKHR maxFrameSize; +} VkVideoEncodeH265RateControlLayerInfoKHR; + +typedef struct VkVideoEncodeH265GopRemainingFrameInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 useGopRemainingFrames; + uint32_t gopRemainingI; + uint32_t gopRemainingP; + uint32_t gopRemainingB; +} VkVideoEncodeH265GopRemainingFrameInfoKHR; + + + // VK_KHR_video_decode_h264 is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_video_decode_h264 1 -#include "vk_video/vulkan_video_codec_h264std.h" #include "vk_video/vulkan_video_codec_h264std_decode.h" -#define VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION 8 +#define VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION 9 #define VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME "VK_KHR_video_decode_h264" typedef enum VkVideoDecodeH264PictureLayoutFlagBitsKHR { @@ -9609,9 +9948,8 @@ typedef struct VkPhysicalDeviceShaderClockFeaturesKHR { // VK_KHR_video_decode_h265 is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_video_decode_h265 1 -#include "vk_video/vulkan_video_codec_h265std.h" #include "vk_video/vulkan_video_codec_h265std_decode.h" -#define VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION 7 +#define VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION 8 #define VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME "VK_KHR_video_decode_h265" typedef struct VkVideoDecodeH265ProfileInfoKHR { VkStructureType sType; @@ -9882,6 +10220,58 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR( #endif +// VK_KHR_dynamic_rendering_local_read is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_dynamic_rendering_local_read 1 +#define VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION 1 +#define VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME "VK_KHR_dynamic_rendering_local_read" +typedef struct VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 dynamicRenderingLocalRead; +} VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR; + +typedef struct VkRenderingAttachmentLocationInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t colorAttachmentCount; + const uint32_t* pColorAttachmentLocations; +} VkRenderingAttachmentLocationInfoKHR; + +typedef struct VkRenderingInputAttachmentIndexInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t colorAttachmentCount; + const uint32_t* pColorAttachmentInputIndices; + const uint32_t* pDepthInputAttachmentIndex; + const uint32_t* pStencilInputAttachmentIndex; +} VkRenderingInputAttachmentIndexInfoKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingAttachmentLocationsKHR)(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfoKHR* pLocationInfo); +typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingInputAttachmentIndicesKHR)(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfoKHR* pLocationInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocationsKHR( + VkCommandBuffer commandBuffer, + const VkRenderingAttachmentLocationInfoKHR* pLocationInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndicesKHR( + VkCommandBuffer commandBuffer, + const VkRenderingInputAttachmentIndexInfoKHR* pLocationInfo); +#endif + + +// VK_KHR_shader_quad_control is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_quad_control 1 +#define VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION 1 +#define VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME "VK_KHR_shader_quad_control" +typedef struct VkPhysicalDeviceShaderQuadControlFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderQuadControl; +} VkPhysicalDeviceShaderQuadControlFeaturesKHR; + + + // VK_KHR_spirv_1_4 is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_spirv_1_4 1 #define VK_KHR_SPIRV_1_4_SPEC_VERSION 1 @@ -10185,6 +10575,179 @@ typedef struct VkPhysicalDevicePresentIdFeaturesKHR { +// VK_KHR_video_encode_queue is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_encode_queue 1 +#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 12 +#define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue" + +typedef enum VkVideoEncodeTuningModeKHR { + VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR = 0, + VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR = 1, + VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR = 2, + VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR = 3, + VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR = 4, + VK_VIDEO_ENCODE_TUNING_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeTuningModeKHR; +typedef VkFlags VkVideoEncodeFlagsKHR; + +typedef enum VkVideoEncodeCapabilityFlagBitsKHR { + VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeCapabilityFlagBitsKHR; +typedef VkFlags VkVideoEncodeCapabilityFlagsKHR; + +typedef enum VkVideoEncodeRateControlModeFlagBitsKHR { + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR = 0, + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeRateControlModeFlagBitsKHR; +typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR; + +typedef enum VkVideoEncodeFeedbackFlagBitsKHR { + VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_FEEDBACK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeFeedbackFlagBitsKHR; +typedef VkFlags VkVideoEncodeFeedbackFlagsKHR; + +typedef enum VkVideoEncodeUsageFlagBitsKHR { + VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR = 0, + VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeUsageFlagBitsKHR; +typedef VkFlags VkVideoEncodeUsageFlagsKHR; + +typedef enum VkVideoEncodeContentFlagBitsKHR { + VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR = 0, + VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_CONTENT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeContentFlagBitsKHR; +typedef VkFlags VkVideoEncodeContentFlagsKHR; +typedef VkFlags VkVideoEncodeRateControlFlagsKHR; +typedef struct VkVideoEncodeInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeFlagsKHR flags; + VkBuffer dstBuffer; + VkDeviceSize dstBufferOffset; + VkDeviceSize dstBufferRange; + VkVideoPictureResourceInfoKHR srcPictureResource; + const VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot; + uint32_t referenceSlotCount; + const VkVideoReferenceSlotInfoKHR* pReferenceSlots; + uint32_t precedingExternallyEncodedBytes; +} VkVideoEncodeInfoKHR; + +typedef struct VkVideoEncodeCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeCapabilityFlagsKHR flags; + VkVideoEncodeRateControlModeFlagsKHR rateControlModes; + uint32_t maxRateControlLayers; + uint64_t maxBitrate; + uint32_t maxQualityLevels; + VkExtent2D encodeInputPictureGranularity; + VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags; +} VkVideoEncodeCapabilitiesKHR; + +typedef struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags; +} VkQueryPoolVideoEncodeFeedbackCreateInfoKHR; + +typedef struct VkVideoEncodeUsageInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeUsageFlagsKHR videoUsageHints; + VkVideoEncodeContentFlagsKHR videoContentHints; + VkVideoEncodeTuningModeKHR tuningMode; +} VkVideoEncodeUsageInfoKHR; + +typedef struct VkVideoEncodeRateControlLayerInfoKHR { + VkStructureType sType; + const void* pNext; + uint64_t averageBitrate; + uint64_t maxBitrate; + uint32_t frameRateNumerator; + uint32_t frameRateDenominator; +} VkVideoEncodeRateControlLayerInfoKHR; + +typedef struct VkVideoEncodeRateControlInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeRateControlFlagsKHR flags; + VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode; + uint32_t layerCount; + const VkVideoEncodeRateControlLayerInfoKHR* pLayers; + uint32_t virtualBufferSizeInMs; + uint32_t initialVirtualBufferSizeInMs; +} VkVideoEncodeRateControlInfoKHR; + +typedef struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR { + VkStructureType sType; + const void* pNext; + const VkVideoProfileInfoKHR* pVideoProfile; + uint32_t qualityLevel; +} VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR; + +typedef struct VkVideoEncodeQualityLevelPropertiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode; + uint32_t preferredRateControlLayerCount; +} VkVideoEncodeQualityLevelPropertiesKHR; + +typedef struct VkVideoEncodeQualityLevelInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t qualityLevel; +} VkVideoEncodeQualityLevelInfoKHR; + +typedef struct VkVideoEncodeSessionParametersGetInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoSessionParametersKHR videoSessionParameters; +} VkVideoEncodeSessionParametersGetInfoKHR; + +typedef struct VkVideoEncodeSessionParametersFeedbackInfoKHR { + VkStructureType sType; + void* pNext; + VkBool32 hasOverrides; +} VkVideoEncodeSessionParametersFeedbackInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetEncodedVideoSessionParametersKHR)(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, + VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetEncodedVideoSessionParametersKHR( + VkDevice device, + const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, + VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, + size_t* pDataSize, + void* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR( + VkCommandBuffer commandBuffer, + const VkVideoEncodeInfoKHR* pEncodeInfo); +#endif + + // VK_KHR_synchronization2 is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_synchronization2 1 #define VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION 1 @@ -10489,6 +11052,31 @@ VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR( #endif +// VK_KHR_shader_subgroup_rotate is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_subgroup_rotate 1 +#define VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION 2 +#define VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME "VK_KHR_shader_subgroup_rotate" +typedef struct VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderSubgroupRotate; + VkBool32 shaderSubgroupRotateClustered; +} VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR; + + + +// VK_KHR_shader_maximal_reconvergence is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_maximal_reconvergence 1 +#define VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION 1 +#define VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME "VK_KHR_shader_maximal_reconvergence" +typedef struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderMaximalReconvergence; +} VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; + + + // VK_KHR_maintenance5 is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_maintenance5 1 #define VK_KHR_MAINTENANCE_5_SPEC_VERSION 1 @@ -10745,6 +11333,71 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR #endif +// VK_KHR_video_decode_av1 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_decode_av1 1 +#include "vk_video/vulkan_video_codec_av1std.h" +#include "vk_video/vulkan_video_codec_av1std_decode.h" +#define VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR 7U +#define VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION 1 +#define VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME "VK_KHR_video_decode_av1" +typedef struct VkVideoDecodeAV1ProfileInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoAV1Profile stdProfile; + VkBool32 filmGrainSupport; +} VkVideoDecodeAV1ProfileInfoKHR; + +typedef struct VkVideoDecodeAV1CapabilitiesKHR { + VkStructureType sType; + void* pNext; + StdVideoAV1Level maxLevel; +} VkVideoDecodeAV1CapabilitiesKHR; + +typedef struct VkVideoDecodeAV1SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoAV1SequenceHeader* pStdSequenceHeader; +} VkVideoDecodeAV1SessionParametersCreateInfoKHR; + +typedef struct VkVideoDecodeAV1PictureInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeAV1PictureInfo* pStdPictureInfo; + int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]; + uint32_t frameHeaderOffset; + uint32_t tileCount; + const uint32_t* pTileOffsets; + const uint32_t* pTileSizes; +} VkVideoDecodeAV1PictureInfoKHR; + +typedef struct VkVideoDecodeAV1DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeAV1ReferenceInfo* pStdReferenceInfo; +} VkVideoDecodeAV1DpbSlotInfoKHR; + + + +// VK_KHR_video_maintenance1 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_maintenance1 1 +#define VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION 1 +#define VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_video_maintenance1" +typedef struct VkPhysicalDeviceVideoMaintenance1FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 videoMaintenance1; +} VkPhysicalDeviceVideoMaintenance1FeaturesKHR; + +typedef struct VkVideoInlineQueryInfoKHR { + VkStructureType sType; + const void* pNext; + VkQueryPool queryPool; + uint32_t firstQuery; + uint32_t queryCount; +} VkVideoInlineQueryInfoKHR; + + + // VK_KHR_vertex_attribute_divisor is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_vertex_attribute_divisor 1 #define VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 1 @@ -10777,6 +11430,88 @@ typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR { +// VK_KHR_load_store_op_none is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_load_store_op_none 1 +#define VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION 1 +#define VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_KHR_load_store_op_none" + + +// VK_KHR_shader_float_controls2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_float_controls2 1 +#define VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION 1 +#define VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME "VK_KHR_shader_float_controls2" +typedef struct VkPhysicalDeviceShaderFloatControls2FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderFloatControls2; +} VkPhysicalDeviceShaderFloatControls2FeaturesKHR; + + + +// VK_KHR_index_type_uint8 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_index_type_uint8 1 +#define VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION 1 +#define VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_KHR_index_type_uint8" +typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 indexTypeUint8; +} VkPhysicalDeviceIndexTypeUint8FeaturesKHR; + + + +// VK_KHR_line_rasterization is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_line_rasterization 1 +#define VK_KHR_LINE_RASTERIZATION_SPEC_VERSION 1 +#define VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME "VK_KHR_line_rasterization" + +typedef enum VkLineRasterizationModeKHR { + VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR = 0, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR = 1, + VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR = 2, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR = 3, + VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR, + VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR, + VK_LINE_RASTERIZATION_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkLineRasterizationModeKHR; +typedef struct VkPhysicalDeviceLineRasterizationFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 rectangularLines; + VkBool32 bresenhamLines; + VkBool32 smoothLines; + VkBool32 stippledRectangularLines; + VkBool32 stippledBresenhamLines; + VkBool32 stippledSmoothLines; +} VkPhysicalDeviceLineRasterizationFeaturesKHR; + +typedef struct VkPhysicalDeviceLineRasterizationPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t lineSubPixelPrecisionBits; +} VkPhysicalDeviceLineRasterizationPropertiesKHR; + +typedef struct VkPipelineRasterizationLineStateCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkLineRasterizationModeKHR lineRasterizationMode; + VkBool32 stippledLineEnable; + uint32_t lineStippleFactor; + uint16_t lineStipplePattern; +} VkPipelineRasterizationLineStateCreateInfoKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleKHR)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleKHR( + VkCommandBuffer commandBuffer, + uint32_t lineStippleFactor, + uint16_t lineStipplePattern); +#endif + + // VK_KHR_calibrated_timestamps is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_calibrated_timestamps 1 #define VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION 1 @@ -10817,6 +11552,136 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsKHR( #endif +// VK_KHR_shader_expect_assume is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_expect_assume 1 +#define VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION 1 +#define VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME "VK_KHR_shader_expect_assume" +typedef struct VkPhysicalDeviceShaderExpectAssumeFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderExpectAssume; +} VkPhysicalDeviceShaderExpectAssumeFeaturesKHR; + + + +// VK_KHR_maintenance6 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_maintenance6 1 +#define VK_KHR_MAINTENANCE_6_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE_6_EXTENSION_NAME "VK_KHR_maintenance6" +typedef struct VkPhysicalDeviceMaintenance6FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 maintenance6; +} VkPhysicalDeviceMaintenance6FeaturesKHR; + +typedef struct VkPhysicalDeviceMaintenance6PropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 blockTexelViewCompatibleMultipleLayers; + uint32_t maxCombinedImageSamplerDescriptorCount; + VkBool32 fragmentShadingRateClampCombinerInputs; +} VkPhysicalDeviceMaintenance6PropertiesKHR; + +typedef struct VkBindMemoryStatusKHR { + VkStructureType sType; + const void* pNext; + VkResult* pResult; +} VkBindMemoryStatusKHR; + +typedef struct VkBindDescriptorSetsInfoKHR { + VkStructureType sType; + const void* pNext; + VkShaderStageFlags stageFlags; + VkPipelineLayout layout; + uint32_t firstSet; + uint32_t descriptorSetCount; + const VkDescriptorSet* pDescriptorSets; + uint32_t dynamicOffsetCount; + const uint32_t* pDynamicOffsets; +} VkBindDescriptorSetsInfoKHR; + +typedef struct VkPushConstantsInfoKHR { + VkStructureType sType; + const void* pNext; + VkPipelineLayout layout; + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; + const void* pValues; +} VkPushConstantsInfoKHR; + +typedef struct VkPushDescriptorSetInfoKHR { + VkStructureType sType; + const void* pNext; + VkShaderStageFlags stageFlags; + VkPipelineLayout layout; + uint32_t set; + uint32_t descriptorWriteCount; + const VkWriteDescriptorSet* pDescriptorWrites; +} VkPushDescriptorSetInfoKHR; + +typedef struct VkPushDescriptorSetWithTemplateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDescriptorUpdateTemplate descriptorUpdateTemplate; + VkPipelineLayout layout; + uint32_t set; + const void* pData; +} VkPushDescriptorSetWithTemplateInfoKHR; + +typedef struct VkSetDescriptorBufferOffsetsInfoEXT { + VkStructureType sType; + const void* pNext; + VkShaderStageFlags stageFlags; + VkPipelineLayout layout; + uint32_t firstSet; + uint32_t setCount; + const uint32_t* pBufferIndices; + const VkDeviceSize* pOffsets; +} VkSetDescriptorBufferOffsetsInfoEXT; + +typedef struct VkBindDescriptorBufferEmbeddedSamplersInfoEXT { + VkStructureType sType; + const void* pNext; + VkShaderStageFlags stageFlags; + VkPipelineLayout layout; + uint32_t set; +} VkBindDescriptorBufferEmbeddedSamplersInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets2KHR)(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo); +typedef void (VKAPI_PTR *PFN_vkCmdPushConstants2KHR)(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR* pPushConstantsInfo); +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSet2KHR)(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo); +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplate2KHR)(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo); +typedef void (VKAPI_PTR *PFN_vkCmdSetDescriptorBufferOffsets2EXT)(VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT)(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets2KHR( + VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants2KHR( + VkCommandBuffer commandBuffer, + const VkPushConstantsInfoKHR* pPushConstantsInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsets2EXT( + VkCommandBuffer commandBuffer, + const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, + const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo); +#endif + + // VK_EXT_debug_report is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_debug_report 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) @@ -14027,39 +14892,13 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT( #define VK_EXT_line_rasterization 1 #define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1 #define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization" +typedef VkLineRasterizationModeKHR VkLineRasterizationModeEXT; -typedef enum VkLineRasterizationModeEXT { - VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1, - VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3, - VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkLineRasterizationModeEXT; -typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 rectangularLines; - VkBool32 bresenhamLines; - VkBool32 smoothLines; - VkBool32 stippledRectangularLines; - VkBool32 stippledBresenhamLines; - VkBool32 stippledSmoothLines; -} VkPhysicalDeviceLineRasterizationFeaturesEXT; +typedef VkPhysicalDeviceLineRasterizationFeaturesKHR VkPhysicalDeviceLineRasterizationFeaturesEXT; -typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t lineSubPixelPrecisionBits; -} VkPhysicalDeviceLineRasterizationPropertiesEXT; +typedef VkPhysicalDeviceLineRasterizationPropertiesKHR VkPhysicalDeviceLineRasterizationPropertiesEXT; -typedef struct VkPipelineRasterizationLineStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkLineRasterizationModeEXT lineRasterizationMode; - VkBool32 stippledLineEnable; - uint32_t lineStippleFactor; - uint16_t lineStipplePattern; -} VkPipelineRasterizationLineStateCreateInfoEXT; +typedef VkPipelineRasterizationLineStateCreateInfoKHR VkPipelineRasterizationLineStateCreateInfoEXT; typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); @@ -14115,11 +14954,7 @@ VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT( #define VK_EXT_index_type_uint8 1 #define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1 #define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8" -typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 indexTypeUint8; -} VkPhysicalDeviceIndexTypeUint8FeaturesEXT; +typedef VkPhysicalDeviceIndexTypeUint8FeaturesKHR VkPhysicalDeviceIndexTypeUint8FeaturesEXT; @@ -14709,7 +15544,7 @@ typedef VkPhysicalDeviceTexelBufferAlignmentProperties VkPhysicalDeviceTexelBuff // VK_QCOM_render_pass_transform is a preprocessor guard. Do not pass it to API calls. #define VK_QCOM_render_pass_transform 1 -#define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 3 +#define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 4 #define VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME "VK_QCOM_render_pass_transform" typedef struct VkRenderPassTransformBeginInfoQCOM { VkStructureType sType; @@ -15549,7 +16384,7 @@ typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT { // VK_QCOM_rotated_copy_commands is a preprocessor guard. Do not pass it to API calls. #define VK_QCOM_rotated_copy_commands 1 -#define VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION 1 +#define VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION 2 #define VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME "VK_QCOM_rotated_copy_commands" typedef struct VkCopyCommandTransformInfoQCOM { VkStructureType sType; @@ -16796,10 +17631,10 @@ typedef struct VkRenderPassStripeInfoARM { } VkRenderPassStripeInfoARM; typedef struct VkRenderPassStripeBeginInfoARM { - VkStructureType sType; - const void* pNext; - uint32_t stripeInfoCount; - VkRenderPassStripeInfoARM* pStripeInfos; + VkStructureType sType; + const void* pNext; + uint32_t stripeInfoCount; + const VkRenderPassStripeInfoARM* pStripeInfos; } VkRenderPassStripeBeginInfoARM; typedef struct VkRenderPassStripeSubmitInfoARM { @@ -17144,7 +17979,6 @@ typedef struct VkColorBlendAdvancedEXT { VkBool32 clampResults; } VkColorBlendAdvancedEXT; -typedef void (VKAPI_PTR *PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin); typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable); typedef void (VKAPI_PTR *PFN_vkCmdSetPolygonModeEXT)(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode); typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationSamplesEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples); @@ -17155,6 +17989,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer commandBu typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEnableEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables); typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEquationEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations); typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteMaskEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks); +typedef void (VKAPI_PTR *PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin); typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer commandBuffer, uint32_t rasterizationStream); typedef void (VKAPI_PTR *PFN_vkCmdSetConservativeRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode); typedef void (VKAPI_PTR *PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize); @@ -17177,10 +18012,6 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkComma typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageReductionModeNV)(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode); #ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT( - VkCommandBuffer commandBuffer, - VkTessellationDomainOrigin domainOrigin); - VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClampEnable); @@ -17228,6 +18059,10 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteMaskEXT( uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks); +VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT( + VkCommandBuffer commandBuffer, + VkTessellationDomainOrigin domainOrigin); + VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationStreamEXT( VkCommandBuffer commandBuffer, uint32_t rasterizationStream); @@ -18077,6 +18912,19 @@ typedef struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM { +// VK_NV_per_stage_descriptor_set is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_per_stage_descriptor_set 1 +#define VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION 1 +#define VK_NV_PER_STAGE_DESCRIPTOR_SET_EXTENSION_NAME "VK_NV_per_stage_descriptor_set" +typedef struct VkPhysicalDevicePerStageDescriptorSetFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 perStageDescriptorSet; + VkBool32 dynamicPipelineLayout; +} VkPhysicalDevicePerStageDescriptorSetFeaturesNV; + + + // VK_QCOM_image_processing2 is a preprocessor guard. Do not pass it to API calls. #define VK_QCOM_image_processing2 1 #define VK_QCOM_IMAGE_PROCESSING_2_SPEC_VERSION 1 diff --git a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_directfb.h b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_directfb.h index 1f11a082..f06f80b7 100644 --- a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_directfb.h +++ b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_directfb.h @@ -2,7 +2,7 @@ #define VULKAN_DIRECTFB_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_fuchsia.h b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_fuchsia.h index 76e15648..f60907d1 100644 --- a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_fuchsia.h +++ b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_fuchsia.h @@ -2,7 +2,7 @@ #define VULKAN_FUCHSIA_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_ggp.h b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_ggp.h index 9783aa3b..0a8863a1 100644 --- a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_ggp.h +++ b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_ggp.h @@ -2,7 +2,7 @@ #define VULKAN_GGP_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_ios.h b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_ios.h index 211429ff..22ed2c03 100644 --- a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_ios.h +++ b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_ios.h @@ -2,7 +2,7 @@ #define VULKAN_IOS_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_macos.h b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_macos.h index c6509cc8..a7f5613a 100644 --- a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_macos.h +++ b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_macos.h @@ -2,7 +2,7 @@ #define VULKAN_MACOS_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_metal.h b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_metal.h index 94563a00..e6f7bf7a 100644 --- a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_metal.h +++ b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_metal.h @@ -2,7 +2,7 @@ #define VULKAN_METAL_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_screen.h b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_screen.h index 981738f7..7e84d4d9 100644 --- a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_screen.h +++ b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_screen.h @@ -2,7 +2,7 @@ #define VULKAN_SCREEN_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_vi.h b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_vi.h index c9227e82..c145f4a8 100644 --- a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_vi.h +++ b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_vi.h @@ -2,7 +2,7 @@ #define VULKAN_VI_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_wayland.h b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_wayland.h index c93b2178..ec706a11 100644 --- a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_wayland.h +++ b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_wayland.h @@ -2,7 +2,7 @@ #define VULKAN_WAYLAND_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_win32.h b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_win32.h index fae3b853..d7a0b2ba 100644 --- a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_win32.h +++ b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_win32.h @@ -2,7 +2,7 @@ #define VULKAN_WIN32_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_xcb.h b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_xcb.h index de740552..cdf6b526 100644 --- a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_xcb.h +++ b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_xcb.h @@ -2,7 +2,7 @@ #define VULKAN_XCB_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_xlib.h b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_xlib.h index 1aa632f2..b3c3e27d 100644 --- a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_xlib.h +++ b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_xlib.h @@ -2,7 +2,7 @@ #define VULKAN_XLIB_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_xlib_xrandr.h b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_xlib_xrandr.h index e164ffc9..8e99190b 100644 --- a/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_xlib_xrandr.h +++ b/icd/api/include/khronos/sdk-1.3/vulkan/vulkan_xlib_xrandr.h @@ -2,7 +2,7 @@ #define VULKAN_XLIB_XRANDR_H_ 1 /* -** Copyright 2015-2023 The Khronos Group Inc. +** Copyright 2015-2024 The Khronos Group Inc. ** ** SPDX-License-Identifier: Apache-2.0 */ diff --git a/icd/api/include/khronos/vk_video/vulkan_video_codec_av1std.h b/icd/api/include/khronos/vk_video/vulkan_video_codec_av1std.h new file mode 100644 index 00000000..58feaab7 --- /dev/null +++ b/icd/api/include/khronos/vk_video/vulkan_video_codec_av1std.h @@ -0,0 +1,43 @@ +/* + *********************************************************************************************************************** + * + * Copyright (c) 2024 Advanced Micro Devices, Inc. All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + **********************************************************************************************************************/ +/** + *********************************************************************************************************************** + * @file vulkan_video_codec_av1std.h + * @brief Proxy to the real Khronos Vulkan video header. + *********************************************************************************************************************** + */ + +#ifndef __VULKAN_VIDEO_CODEC_AV1STD_H_PROXY__ +#define __VULKAN_VIDEO_CODEC_AV1STD_H_PROXY__ + +#include "vulkan_video_codecs_common.h" + +#if EXTERNAL_VULKAN_HEADERS +#include "vk_video/vulkan_video_codec_av1std.h" +#else +#include "sdk-1.3/vk_video/vulkan_video_codec_av1std.h" +#endif + +#endif /* __VULKAN_VIDEO_CODEC_AV1STD_H_PROXY__*/ diff --git a/icd/api/include/khronos/vk_video/vulkan_video_codec_av1std_decode.h b/icd/api/include/khronos/vk_video/vulkan_video_codec_av1std_decode.h new file mode 100644 index 00000000..b7ee3f2d --- /dev/null +++ b/icd/api/include/khronos/vk_video/vulkan_video_codec_av1std_decode.h @@ -0,0 +1,41 @@ +/* + *********************************************************************************************************************** + * + * Copyright (c) 2024 Advanced Micro Devices, Inc. All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + **********************************************************************************************************************/ +/** + *********************************************************************************************************************** + * @file vulkan_video_codec_av1std_decode.h + * @brief Proxy to the real Khronos Vulkan video header. + *********************************************************************************************************************** + */ + +#ifndef __VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_PROXY__ +#define __VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_PROXY__ + +#if EXTERNAL_VULKAN_HEADERS +#include "vk_video/vulkan_video_codec_av1std_decode.h" +#else +#include "sdk-1.3/vk_video/vulkan_video_codec_av1std_decode.h" +#endif + +#endif /* __vulkan_video_codec_av1std_decode_H_PROXY__*/ diff --git a/icd/api/include/pipeline_compiler.h b/icd/api/include/pipeline_compiler.h index a4f042f5..5b8a4127 100644 --- a/icd/api/include/pipeline_compiler.h +++ b/icd/api/include/pipeline_compiler.h @@ -54,6 +54,7 @@ class PipelineCompiler; struct PipelineInternalBufferInfo; struct ShaderModuleHandle; struct GraphicsPipelineLibraryInfo; +struct GraphicsPipelineExtStructs; class PipelineBinaryCache; @@ -143,8 +144,6 @@ class PipelineCompiler const VkShaderModuleCreateFlags flags, const VkShaderModuleCreateFlags internalShaderFlags, const Vkgc::BinaryData& shaderBinary, - const bool adaptForFastLink, - bool isInternal, ShaderModuleHandle* pShaderModule); void TryEarlyCompileShaderModule( @@ -169,9 +168,9 @@ class PipelineCompiler VkResult CreateGraphicsShaderBinary( const Device* pDevice, PipelineCache* pPipelineCache, - const ShaderStage stage, + GraphicsLibraryType gplType, GraphicsPipelineBinaryCreateInfo* pCreateInfo, - ShaderModuleHandle* pModule); + GplModuleState* pModuleState); VkResult CreateColorExportShaderLibrary( const Device* pDevice, @@ -185,8 +184,8 @@ class PipelineCompiler const VkAllocationCallbacks* pAllocator, Pal::IShaderLibrary** ppShaderLibrary); - static void FreeGraphicsShaderBinary( - ShaderModuleHandle* pShaderModule); + void FreeGplModuleState( + GplModuleState* pModuleState); VkResult CreateComputePipelineBinary( Device* pDevice, @@ -214,6 +213,7 @@ class PipelineCompiler VkResult ConvertGraphicsPipelineInfo( Device* pDevice, const VkGraphicsPipelineCreateInfo* pIn, + const GraphicsPipelineExtStructs& extStructs, VkPipelineCreateFlags2KHR flags, const GraphicsPipelineShaderStageInfo* pShaderInfo, const PipelineLayout* pPipelineLayout, @@ -224,6 +224,7 @@ class PipelineCompiler VkResult BuildGplFastLinkCreateInfo( Device* pDevice, const VkGraphicsPipelineCreateInfo* pIn, + const GraphicsPipelineExtStructs& extStructs, VkPipelineCreateFlags2KHR flags, const GraphicsPipelineLibraryInfo& libInfo, const PipelineLayout* pPipelineLayout, diff --git a/icd/api/include/vk_cmdbuffer.h b/icd/api/include/vk_cmdbuffer.h index a37f0d5e..913cb380 100644 --- a/icd/api/include/vk_cmdbuffer.h +++ b/icd/api/include/vk_cmdbuffer.h @@ -251,6 +251,7 @@ struct DynamicRenderingInstance DynamicRenderingAttachments colorAttachments[Pal::MaxColorTargets]; DynamicRenderingAttachments depthAttachment; DynamicRenderingAttachments stencilAttachment; + uint32_t colorAttachmentLocations[Pal::MaxColorTargets]; }; // Members of CmdBufferRenderState that are the same for each GPU @@ -404,6 +405,13 @@ class CmdBuffer VkResult Reset(VkCommandBufferResetFlags flags); +#if VKI_RAY_TRACING + VkResult GetScratchVidMem( + gpusize sizeInBytes, + InternalSubAllocPool poolId, + InternalMemory** ppInternalMemory); +#endif + VkResult End(void); void BindPipeline( @@ -698,6 +706,12 @@ class CmdBuffer uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); + void SetRenderingAttachmentLocations( + const VkRenderingAttachmentLocationInfoKHR* pLocationInfo); + + void SetRenderingInputAttachmentIndices( + const VkRenderingInputAttachmentIndexInfoKHR* pLocationInfo); + void SetColorBlendEnable( uint32_t firstAttachment, uint32_t attachmentCount, @@ -1197,15 +1211,13 @@ class CmdBuffer const Pal::Rect* pRects, Pal::uint32 flags); - template void PalCmdResetEvent( - EventContainer_T* pEvent, - Pal::HwPipePoint resetPoint); + Event* pEvent, + Pal::HwPipePoint resetPoint); - template void PalCmdSetEvent( - EventContainer_T* pEvent, - Pal::HwPipePoint resetPoint); + Event* pEvent, + Pal::HwPipePoint resetPoint); void PalCmdResolveImage( const Image& srcImage, @@ -1296,6 +1308,11 @@ class CmdBuffer static PFN_vkCmdPushDescriptorSetKHR GetCmdPushDescriptorSetKHRFunc(const Device* pDevice); static PFN_vkCmdPushDescriptorSetWithTemplateKHR GetCmdPushDescriptorSetWithTemplateKHRFunc(const Device* pDevice); + static PFN_vkCmdBindDescriptorSets2KHR GetCmdBindDescriptorSets2KHRFunc(const Device* pDevice); + + static PFN_vkCmdPushDescriptorSet2KHR GetCmdPushDescriptorSet2KHRFunc(const Device* pDevice); + static PFN_vkCmdPushDescriptorSetWithTemplate2KHR GetCmdPushDescriptorSetWithTemplate2KHRFunc(const Device* pDevice); + #if VKI_RAY_TRACING void BuildAccelerationStructures( uint32 infoCount, @@ -1345,7 +1362,7 @@ class CmdBuffer const RayTracingPipeline* GetBoundRayTracingPipeline() const { return m_allGpuState.pRayTracingPipeline; } - void FreeRayTracingIndirectMemory(); + void FreeRayTracingScratchVidMemory(); void SetRayTracingPipelineStackSize(uint32_t pipelineStackSize); @@ -1409,6 +1426,30 @@ class CmdBuffer bool HasRayTracing() const { return m_flags.hasRayTracing; } #endif + template + void BindDescriptorSets2KHR( + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo); + + void PushConstants2KHR( + const VkPushConstantsInfoKHR* pPushConstantsInfo); + + template + void PushDescriptorSet2KHR( + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo); + + template + void PushDescriptorSetWithTemplate2KHR( + const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo); + + void SetDescriptorBufferOffsets2EXT( + const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo); + + void BindDescriptorBufferEmbeddedSamplers2EXT( + const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo); + DebugPrintf* GetDebugPrintf() { return &m_debugPrintf; @@ -1526,9 +1567,7 @@ class CmdBuffer void RPBindTargets(const RPBindTargetsInfo& targets); void RPSyncPostLoadOpColorClear(); - void BindTargets( - const VkRenderingInfo* pRenderingInfo, - const VkRenderingFragmentShadingRateAttachmentInfoKHR* pRenderingFragmentShadingRateAttachmentInfoKHR); + void BindTargets(); void ResolveImage( VkImageAspectFlags aspectMask, @@ -1659,6 +1698,30 @@ class CmdBuffer uint32_t set, const void* pData); + template + static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2KHR( + VkCommandBuffer cmdBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo); + + template + static PFN_vkCmdBindDescriptorSets2KHR GetCmdBindDescriptorSets2KHRFunc(const Device* pDevice); + + template + static PFN_vkCmdPushDescriptorSet2KHR GetCmdPushDescriptorSet2KHRFunc(const Device* pDevice); + + template + static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo); + + template + static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo); + bool PalPipelineBindingOwnedBy( Pal::PipelineBindPoint palBind, PipelineBindPoint apiBind @@ -1689,6 +1752,7 @@ class CmdBuffer void InitializeVertexBuffer(); void ResetVertexBuffer(); + void ClearVertexBufferBindings(uint32_t watermark); void UpdateVertexBufferStrides(const GraphicsPipeline* pPipeline); void BindAlternatingThreadGroupConstant(); @@ -1788,6 +1852,16 @@ class CmdBuffer const char* pLabelName, bool isBegin); + void BindVertexBuffersUpdateBindingRange( + uint32_t deviceIdx, + Pal::BufferViewInfo* pBinding, + Pal::BufferViewInfo* pEndBinding, + uint32_t inputIdx, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes, + const VkDeviceSize* pStrides); + union CmdBufferFlags { uint32_t u32All; @@ -1862,7 +1936,7 @@ class CmdBuffer DebugPrintf m_debugPrintf; bool m_reverseThreadGroupState; #if VKI_RAY_TRACING - Util::Vector m_rayTracingIndirectList; // Ray-tracing indirect memory + Util::Vector m_scratchVidMemList; // Ray-tracing scratch memory #endif }; @@ -2043,6 +2117,30 @@ VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer2KHR( VkDeviceSize size, VkIndexType indexType); +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets2KHR( + VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants2KHR( + VkCommandBuffer commandBuffer, + const VkPushConstantsInfoKHR* pPushConstantsInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsets2EXT( + VkCommandBuffer commandBuffer, + const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, + const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo); + VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer, uint32_t firstBinding, diff --git a/icd/api/include/vk_device.h b/icd/api/include/vk_device.h index 439bc54b..654dd80e 100644 --- a/icd/api/include/vk_device.h +++ b/icd/api/include/vk_device.h @@ -165,7 +165,9 @@ class Device uint32 assumeDynamicTopologyInLibs : 1; // True if EXT_PRIMITIVES_GENERATED_QUERY is enabled. uint32 primitivesGeneratedQuery : 1; - uint32 reserved : 14; + uint32 reserved1 : 1; + + uint32 reserved : 13; }; uint32 u32All; diff --git a/icd/api/include/vk_extensions.h b/icd/api/include/vk_extensions.h index 8e74da71..b9a0782c 100644 --- a/icd/api/include/vk_extensions.h +++ b/icd/api/include/vk_extensions.h @@ -58,11 +58,15 @@ #define VK_KHR_MAINTENANCE4_SPEC_VERSION VK_KHR_MAINTENANCE_4_SPEC_VERSION #define VK_KHR_MAINTENANCE5_EXTENSION_NAME VK_KHR_MAINTENANCE_5_EXTENSION_NAME #define VK_KHR_MAINTENANCE5_SPEC_VERSION VK_KHR_MAINTENANCE_5_SPEC_VERSION +#define VK_KHR_MAINTENANCE6_EXTENSION_NAME VK_KHR_MAINTENANCE_6_EXTENSION_NAME +#define VK_KHR_MAINTENANCE6_SPEC_VERSION VK_KHR_MAINTENANCE_6_SPEC_VERSION #define VK_KHR_MAP_MEMORY2_SPEC_VERSION VK_KHR_MAP_MEMORY_2_SPEC_VERSION #if VKI_RAY_TRACING #define VK_KHR_RAY_TRACING_MAINTENANCE1_SPEC_VERSION VK_KHR_RAY_TRACING_MAINTENANCE_1_SPEC_VERSION #endif #define VK_KHR_SYNCHRONIZATION2_SPEC_VERSION VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION +#define VK_KHR_SHADER_FLOAT_CONTROLS2_EXTENSION_NAME VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME +#define VK_KHR_SHADER_FLOAT_CONTROLS2_SPEC_VERSION VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION // EXT macros #define VK_EXT_EXTENDED_DYNAMIC_STATE2_SPEC_VERSION VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION @@ -304,11 +308,15 @@ class DeviceExtensions final : public Extensions KHR_IMAGELESS_FRAMEBUFFER, KHR_IMAGE_FORMAT_LIST, KHR_INCREMENTAL_PRESENT, + KHR_INDEX_TYPE_UINT8, + KHR_LINE_RASTERIZATION, + KHR_LOAD_STORE_OP_NONE, KHR_MAINTENANCE1, KHR_MAINTENANCE2, KHR_MAINTENANCE3, KHR_MAINTENANCE4, KHR_MAINTENANCE5, + KHR_MAINTENANCE6, KHR_MAP_MEMORY2, KHR_MULTIVIEW, KHR_PIPELINE_EXECUTABLE_PROPERTIES, @@ -327,11 +335,16 @@ class DeviceExtensions final : public Extensions KHR_SHADER_ATOMIC_INT64, KHR_SHADER_CLOCK, KHR_SHADER_DRAW_PARAMETERS, + KHR_SHADER_EXPECT_ASSUME, KHR_SHADER_FLOAT16_INT8, KHR_SHADER_FLOAT_CONTROLS, + KHR_SHADER_FLOAT_CONTROLS2, KHR_SHADER_INTEGER_DOT_PRODUCT, + KHR_SHADER_MAXIMAL_RECONVERGENCE, KHR_SHADER_NON_SEMANTIC_INFO, + KHR_SHADER_QUAD_CONTROL, KHR_SHADER_SUBGROUP_EXTENDED_TYPES, + KHR_SHADER_SUBGROUP_ROTATE, KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW, KHR_SHADER_TERMINATE_INVOCATION, KHR_SPIRV_1_4, diff --git a/icd/api/include/vk_graphics_pipeline.h b/icd/api/include/vk_graphics_pipeline.h index 2b45e318..c255aaf0 100644 --- a/icd/api/include/vk_graphics_pipeline.h +++ b/icd/api/include/vk_graphics_pipeline.h @@ -58,6 +58,7 @@ struct DeferGraphicsPipelineCreateInfo GraphicsPipelineBinaryCreateInfo binaryCreateInfo; GraphicsPipelineShaderStageInfo shaderStageInfo; GraphicsPipelineObjectCreateInfo objectCreateInfo; + GraphicsPipelineExtStructs extStructs; Util::MetroHash::Hash elfHash; ShaderOptimizerKey shaderOptimizerKeys[ShaderStage::ShaderStageGfxCount]; PipelineOptimizerKey pipelineOptimizerKey; @@ -152,6 +153,7 @@ class GraphicsPipeline final : public GraphicsPipelineCommon, public NonDispatch Device* pDevice, PipelineCache* pPipelineCache, const VkGraphicsPipelineCreateInfo* pCreateInfo, + const GraphicsPipelineExtStructs& extStructs, VkPipelineCreateFlags2KHR flags, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipeline); @@ -166,6 +168,15 @@ class GraphicsPipeline final : public GraphicsPipelineCommon, public NonDispatch void BindToCmdBuffer( CmdBuffer* pCmdBuffer) const; + const Pal::IDepthStencilState* GetDynamicDepthStencil(uint32_t deviceIdx) const + { return m_pPalDepthStencil[deviceIdx]; } + + const Pal::IMsaaState* GetMsaa(uint32_t deviceIdx) const + { return m_pPalMsaa[deviceIdx]; } + + const Pal::IColorBlendState* GetColorBlendState(uint32_t deviceIdx) const + { return m_pPalColorBlend[deviceIdx]; } + const Pal::IPipeline* GetPalPipeline(uint32_t deviceIdx) const { return UseOptimizedPipeline() ? m_pOptimizedPipeline[deviceIdx] : m_pPalPipeline[deviceIdx]; } @@ -174,6 +185,8 @@ class GraphicsPipeline final : public GraphicsPipelineCommon, public NonDispatch const Pal::DynamicGraphicsShaderInfos& GetBindInfo() const { return m_info.graphicsShaderInfos; } + const GraphicsPipelineObjectImmedInfo& GetGraphicsPipelineImmedInfo() const { return m_info; } + const Pal::IMsaaState* const* GetMsaaStates() const { return m_pPalMsaa; } const Pal::MsaaQuadSamplePattern* GetSampleLocations() const @@ -226,6 +239,7 @@ class GraphicsPipeline final : public GraphicsPipelineCommon, public NonDispatch static VkResult CreatePipelineBinaries( Device* pDevice, const VkGraphicsPipelineCreateInfo* pCreateInfo, + const GraphicsPipelineExtStructs& extStructs, VkPipelineCreateFlags2KHR flags, const GraphicsPipelineShaderStageInfo* pShaderInfo, const PipelineLayout* pPipelineLayout, @@ -263,6 +277,7 @@ class GraphicsPipeline final : public GraphicsPipelineCommon, public NonDispatch GraphicsPipelineBinaryCreateInfo* pBinaryCreateInfo, GraphicsPipelineShaderStageInfo* pShaderStageInfo, GraphicsPipelineObjectCreateInfo* pObjectCreateInfo, + const GraphicsPipelineExtStructs& extStructs, Util::MetroHash::Hash* pElfHash); static VkResult CreatePalPipelineObjects( @@ -292,6 +307,7 @@ class GraphicsPipeline final : public GraphicsPipelineCommon, public NonDispatch GraphicsPipelineBinaryCreateInfo* pBinaryCreateInfo, GraphicsPipelineShaderStageInfo* pShaderStageInfo, GraphicsPipelineObjectCreateInfo* pObjectCreateInfo, + const GraphicsPipelineExtStructs& extStructs, Util::MetroHash::Hash* pElfHash); static void ExecuteDeferCreateOptimizedPipeline(void* pPayload); diff --git a/icd/api/include/vk_graphics_pipeline_library.h b/icd/api/include/vk_graphics_pipeline_library.h index e7019287..accfcd9c 100644 --- a/icd/api/include/vk_graphics_pipeline_library.h +++ b/icd/api/include/vk_graphics_pipeline_library.h @@ -41,6 +41,7 @@ class GraphicsPipelineLibrary final : public GraphicsPipelineCommon, public NonD Device* pDevice, PipelineCache* pPipelineCache, const VkGraphicsPipelineCreateInfo* pCreateInfo, + const GraphicsPipelineExtStructs& extStructs, VkPipelineCreateFlags2KHR flags, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipeline); @@ -61,8 +62,6 @@ class GraphicsPipelineLibrary final : public GraphicsPipelineCommon, public NonD uint64_t GetDynamicStates() const { return m_objectCreateInfo.dynamicStates; } - const ShaderModuleHandle* GetShaderModuleHandle(const ShaderStage stage) const; - const Util::MetroHash::Hash* GetElfHash() const { return &m_elfHash; } @@ -70,12 +69,6 @@ class GraphicsPipelineLibrary final : public GraphicsPipelineCommon, public NonD private: PAL_DISALLOW_COPY_AND_ASSIGN(GraphicsPipelineLibrary); - struct TempModuleState - { - ShaderStage stage; - bool freeBinaryOnly; - }; - GraphicsPipelineLibrary( Device* pDevice, const GraphicsPipelineObjectCreateInfo& objectInfo, @@ -83,8 +76,7 @@ class GraphicsPipelineLibrary final : public GraphicsPipelineCommon, public NonD const GraphicsPipelineLibraryInfo& libInfo, const Util::MetroHash::Hash& elfHash, const uint64_t apiHash, - const ShaderModuleHandle* pTempModules, - const TempModuleState* pTempModuleStates, + const GplModuleState* pGplModuleStates, const PipelineLayout* pPipelineLayout); static VkResult CreatePartialPipelineBinary( @@ -95,14 +87,12 @@ class GraphicsPipelineLibrary final : public GraphicsPipelineCommon, public NonD const GraphicsPipelineShaderStageInfo* pShaderStageInfo, GraphicsPipelineBinaryCreateInfo* pBinaryCreateInfo, const VkAllocationCallbacks* pAllocator, - ShaderModuleHandle* pTempModules, - TempModuleState* pTempModuleStages); + GplModuleState* pTempModuleStages); const GraphicsPipelineObjectCreateInfo m_objectCreateInfo; const GraphicsPipelineBinaryCreateInfo* m_pBinaryCreateInfo; const GraphicsPipelineLibraryInfo m_libInfo; - ShaderModuleHandle m_tempModules[ShaderStage::ShaderStageGfxCount]; - TempModuleState m_tempModuleStates[ShaderStage::ShaderStageGfxCount]; + GplModuleState m_gplModuleStates[ShaderStage::ShaderStageGfxCount]; const Util::MetroHash::Hash m_elfHash; }; diff --git a/icd/api/include/vk_memory.h b/icd/api/include/vk_memory.h index 8d1837c1..b4f7d4bc 100644 --- a/icd/api/include/vk_memory.h +++ b/icd/api/include/vk_memory.h @@ -121,6 +121,7 @@ class Memory final : public NonDispatchable Pal::IGpuMemory** pPalMemory); VkResult Map( + Device* pDevice, VkFlags flags, VkDeviceSize offset, VkDeviceSize size, @@ -223,6 +224,8 @@ class Memory final : public NonDispatchable MemoryPriority m_priority; uint32_t m_sizeAccountedForDeviceMask; uint32_t m_primaryDeviceIndex; + // This will be non-null only when we are skipping the unmap + void* m_mappedPointer; union { diff --git a/icd/api/include/vk_pipeline.h b/icd/api/include/vk_pipeline.h index 69ddb246..bd16e83d 100644 --- a/icd/api/include/vk_pipeline.h +++ b/icd/api/include/vk_pipeline.h @@ -68,8 +68,7 @@ struct ShaderModuleHandle; // Structure containing information about a retrievable pipeline binary. struct PipelineBinaryInfo { - size_t binaryByteSize; - const void* pBinary; + Vkgc::BinaryData pipelineBinary; Util::MetroHash::Hash binaryHash; }; @@ -271,7 +270,6 @@ class Pipeline const Device* pDevice, const uint32_t stageCount, const VkPipelineShaderStageCreateInfo* pStages, - const bool isLibrary, uint32_t (*pfnGetOutputIdx)(const uint32_t inputIdx, const uint32_t stageIdx), ShaderStageInfo* pShaderStageInfo, diff --git a/icd/api/include/vk_shader.h b/icd/api/include/vk_shader.h index 384a3cde..1f39ab5f 100644 --- a/icd/api/include/vk_shader.h +++ b/icd/api/include/vk_shader.h @@ -38,7 +38,12 @@ namespace Pal { enum class ResourceMappingNodeType : Pal::uint32; } #define VK_INTERNAL_SHADER_FLAGS_RAY_TRACING_INTERNAL_SHADER_BIT 0x80000000u #endif -#define VK_INTERNAL_SHADER_FLAGS_FORCE_UNCACHED_BIT 0x20000000u +// To support delayed conversion using this flag, DelayedBuildShaderModule must be called for each shader module +// after pipeline cache lookup and if missed, before pipeline creation. +#define VK_INTERNAL_SHADER_FLAGS_ALLOW_DELAY_CONVERSION_BIT 0x40000000u + +#define VK_INTERNAL_SHADER_FLAGS_INTERNAL_SHADER_BIT 0x20000000u +#define VK_INTERNAL_SHADER_FLAGS_FORCE_UNCACHED_BIT 0x10000000u namespace vk { diff --git a/icd/api/include/vk_utils.h b/icd/api/include/vk_utils.h index 5ed6b4e1..8c048313 100644 --- a/icd/api/include/vk_utils.h +++ b/icd/api/include/vk_utils.h @@ -237,6 +237,25 @@ inline void GetExecutableNameAndPath(char* pExecutableName, char* pExecutablePat pExecutableName[executableNameLength] = '\0'; } +// ===================================================================================================================== +inline Util::Result MkDirRecursively(const char* pPathName) +{ + char pathBuffer[PATH_MAX]; + + // The PAL function expects / on Linux and \ on Windows for identifying directories + size_t i = 0; + while ((pPathName[i] != '\0') && (i < (PATH_MAX - 1))) + { + constexpr char FindChar = '\\'; + constexpr char ReplaceChar = '/'; + pathBuffer[i] = (pPathName[i] == FindChar) ? ReplaceChar : pPathName[i]; + i++; + } + pathBuffer[i] = '\0'; + + return Util::MkDirRecursively(pathBuffer); +} + // ===================================================================================================================== inline int StrCmpCaseInsensitive( const char* a, diff --git a/icd/api/pipeline_compiler.cpp b/icd/api/pipeline_compiler.cpp index 8cbab378..8c173a5e 100644 --- a/icd/api/pipeline_compiler.cpp +++ b/icd/api/pipeline_compiler.cpp @@ -623,8 +623,6 @@ VkResult PipelineCompiler::BuildShaderModule( const VkShaderModuleCreateFlags flags, const VkShaderModuleCreateFlags internalShaderFlags, const Vkgc::BinaryData& shaderBinary, - const bool adaptForFastLink, - bool isInternal, ShaderModuleHandle* pShaderModule) { const RuntimeSettings* pSettings = &m_pPhysicalDevice->GetRuntimeSettings(); @@ -637,8 +635,6 @@ VkResult PipelineCompiler::BuildShaderModule( Util::MetroHash64 hasher; hasher.Update(reinterpret_cast(shaderBinary.pCode), shaderBinary.codeSize); hasher.Finalize(stableHash.bytes); - - hasher.Update(adaptForFastLink); hasher.Finalize(uniqueHash.bytes); bool findReplaceShader = false; @@ -670,8 +666,6 @@ VkResult PipelineCompiler::BuildShaderModule( flags, internalShaderFlags, finalData, - adaptForFastLink, - isInternal, pShaderModule, PipelineOptimizerKey{}); @@ -713,9 +707,10 @@ bool PipelineCompiler::IsValidShaderModule( const ShaderModuleHandle* pShaderModule) const { bool isValid = false; - - isValid |= (pShaderModule->pLlpcShaderModule != nullptr); - + if (pShaderModule != nullptr) + { + isValid |= (pShaderModule->pLlpcShaderModule != nullptr); + } return isValid; } @@ -735,21 +730,12 @@ void PipelineCompiler::FreeShaderModule( { m_compilerSolutionLlpc.FreeShaderModule(pShaderModule); auto pInstance = m_pPhysicalDevice->Manager()->VkInstance(); - if (pShaderModule->elfPackage.codeSize > 0) - { - pInstance->FreeMem(const_cast(pShaderModule->elfPackage.pCode)); - } pInstance->FreeMem(pShaderModule->pRefCount); } } else { m_compilerSolutionLlpc.FreeShaderModule(pShaderModule); - auto pInstance = m_pPhysicalDevice->Manager()->VkInstance(); - if (pShaderModule->elfPackage.codeSize > 0) - { - pInstance->FreeMem(const_cast(pShaderModule->elfPackage.pCode)); - } } } @@ -816,7 +802,7 @@ bool PipelineCompiler::ReplacePipelineShaderModule( if (LoadReplaceShaderBinary(hash64, &shaderBinary)) { VkResult result = - BuildShaderModule(pDevice, 0, 0, shaderBinary, false, false, pShaderModule); + BuildShaderModule(pDevice, 0, 0, shaderBinary, pShaderModule); if (result == VK_SUCCESS) { @@ -1217,15 +1203,16 @@ VkResult PipelineCompiler::CreateGraphicsPipelineBinary( VkResult PipelineCompiler::CreateGraphicsShaderBinary( const Device* pDevice, PipelineCache* pPipelineCache, - const ShaderStage stage, + GraphicsLibraryType gplType, GraphicsPipelineBinaryCreateInfo* pCreateInfo, - ShaderModuleHandle* pModule) + GplModuleState* pModuleState) { VkResult result = VK_SUCCESS; const RuntimeSettings& settings = m_pPhysicalDevice->GetRuntimeSettings(); - GraphicsLibraryType gplType = GetGraphicsLibraryType(stage); - uint64_t libraryHash = Vkgc::IPipelineDumper::GetGraphicsShaderBinaryHash(&pCreateInfo->pipelineInfo, stage); + uint64_t libraryHash = Vkgc::IPipelineDumper::GetGraphicsShaderBinaryHash( + &pCreateInfo->pipelineInfo, + (gplType == GraphicsLibraryPreRaster) ? ShaderStageVertex : ShaderStageFragment); VK_ASSERT(pCreateInfo->libraryHash[gplType] == libraryHash || pCreateInfo->libraryHash[gplType] == 0); pCreateInfo->libraryHash[gplType] = libraryHash; @@ -1250,10 +1237,10 @@ VkResult PipelineCompiler::CreateGraphicsShaderBinary( result = GetSolution(pCreateInfo->compilerType)->CreateGraphicsShaderBinary( pDevice, pPipelineCache, - stage, + gplType, pCreateInfo, pPipelineDumpHandle, - pModule); + pModuleState); if (pPipelineDumpHandle != nullptr) { @@ -1278,6 +1265,7 @@ VkResult PipelineCompiler::CreateColorExportShaderLibrary( bool cacheHit = false; Util::MetroHash::Hash cacheId = {}; GetColorExportShaderCacheId(pCreateInfo, &cacheId); + pCreateInfo->libraryHash[GraphicsLibraryColorExport] = MetroHash::Compact64(&cacheId); // Look up cache with respect to the hash { @@ -1419,10 +1407,25 @@ VkResult PipelineCompiler::CreateGraphicsShaderLibrary( } // ===================================================================================================================== -// Free and only free early compiled shader in ShaderModuleHandle -void PipelineCompiler::FreeGraphicsShaderBinary( - ShaderModuleHandle* pShaderModule) +// Free variables in GplModuleState +void PipelineCompiler::FreeGplModuleState( + GplModuleState* pModuleState) { + if (IsValidShaderModule(&pModuleState->moduleHandle)) + { + FreeShaderModule(&pModuleState->moduleHandle); + } + + if (pModuleState->elfPackage.pCode != nullptr) + { + m_pPhysicalDevice->VkInstance()->FreeMem(const_cast(pModuleState->elfPackage.pCode)); + } + + if (pModuleState->pFsOutputMetaData != nullptr) + { + m_pPhysicalDevice->VkInstance()->FreeMem(pModuleState->pFsOutputMetaData); + } + } // ===================================================================================================================== @@ -1841,7 +1844,6 @@ static void MergePipelineOptions( pDst->robustBufferAccess |= src.robustBufferAccess; pDst->enableRelocatableShaderElf |= src.enableRelocatableShaderElf; pDst->disableImageResourceCheck |= src.disableImageResourceCheck; - pDst->enableScratchAccessBoundsChecks |= src.enableScratchAccessBoundsChecks; pDst->extendedRobustness.nullDescriptor |= src.extendedRobustness.nullDescriptor; pDst->extendedRobustness.robustBufferAccess |= src.extendedRobustness.robustBufferAccess; pDst->extendedRobustness.robustImageAccess |= src.extendedRobustness.robustImageAccess; @@ -2383,9 +2385,6 @@ static void BuildPipelineShadersInfo( // Uber fetch shader is actually used in the following scenes: // * enableUberFetchShader or enableEarlyCompile is set as TRUE in panel. - // * When creating shader module, adaptForFastLink parameter of PipelineCompiler::BuildShaderModule() is set as - // TRUE. This may happen when shader is created during pipeline creation, and that pipeline is a library, not - // executable. More details can be found in Pipeline::BuildShaderStageInfo(). // * When creating pipeline, GraphicsPipelineBuildInfo::enableUberFetchShader controls the actual enablement. It is // only set when Vertex Input Interface section (VII) is not available and Pre-Rasterization Shader (PRS) is // available, or inherits from its PRS parent (referenced library). However, enableUberFetchShader would also be @@ -2410,6 +2409,7 @@ static void BuildPipelineShadersInfo( static void BuildColorBlendState( const Device* pDevice, const VkPipelineColorBlendStateCreateInfo* pCb, + const GraphicsPipelineExtStructs& extStructs, const VkPipelineRenderingCreateInfo* pRendering, uint64_t dynamicStateFlags, const RenderPass* pRenderPass, @@ -2433,13 +2433,13 @@ static void BuildColorBlendState( else if (pCb != nullptr) { pCreateInfo->pipelineInfo.cbState.dualSourceBlendEnable = - GraphicsPipelineCommon::GetDualSourceBlendEnableState(pDevice, pCb); + GraphicsPipelineCommon::GetDualSourceBlendEnableState(pDevice, pCb, extStructs); } for (uint32_t i = 0; i < numColorTargets; ++i) { - - auto pLlpcCbDst = &pCreateInfo->pipelineInfo.cbState.target[i]; + uint32_t location = i; + auto pLlpcCbDst = &pCreateInfo->pipelineInfo.cbState.target[location]; VkFormat cbFormat = VK_FORMAT_UNDEFINED; @@ -2688,6 +2688,7 @@ static void BuildFragmentShaderState( static void BuildFragmentOutputInterfaceState( const Device* pDevice, const VkGraphicsPipelineCreateInfo* pIn, + const GraphicsPipelineExtStructs& extStructs, uint64_t dynamicStateFlags, GraphicsPipelineBinaryCreateInfo* pCreateInfo) { @@ -2706,6 +2707,7 @@ static void BuildFragmentOutputInterfaceState( BuildColorBlendState(pDevice, pIn->pColorBlendState, + extStructs, pPipelineRenderingCreateInfoKHR, dynamicStateFlags, pRenderPass, pIn->subpass, pCreateInfo @@ -2910,6 +2912,7 @@ VkResult PipelineCompiler::UploadInternalBufferData( VkResult PipelineCompiler::ConvertGraphicsPipelineInfo( Device* pDevice, const VkGraphicsPipelineCreateInfo* pIn, + const GraphicsPipelineExtStructs& extStructs, VkPipelineCreateFlags2KHR flags, const GraphicsPipelineShaderStageInfo* pShaderInfo, const PipelineLayout* pPipelineLayout, @@ -2997,7 +3000,7 @@ VkResult PipelineCompiler::ConvertGraphicsPipelineInfo( if (libInfo.libFlags & VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT) { - BuildFragmentOutputInterfaceState(pDevice, pIn, dynamicStateFlags, pCreateInfo); + BuildFragmentOutputInterfaceState(pDevice, pIn, extStructs, dynamicStateFlags, pCreateInfo); } else if (libInfo.pFragmentOutputInterfaceLib != nullptr) { @@ -3085,6 +3088,7 @@ VkResult PipelineCompiler::ConvertGraphicsPipelineInfo( VkResult PipelineCompiler::BuildGplFastLinkCreateInfo( Device* pDevice, const VkGraphicsPipelineCreateInfo* pIn, + const GraphicsPipelineExtStructs& extStructs, VkPipelineCreateFlags2KHR flags, const GraphicsPipelineLibraryInfo& libInfo, const PipelineLayout* pPipelineLayout, @@ -3092,6 +3096,9 @@ VkResult PipelineCompiler::BuildGplFastLinkCreateInfo( GraphicsPipelineBinaryCreateInfo* pCreateInfo) { VK_ASSERT(pIn != nullptr); + VK_ASSERT(libInfo.pPreRasterizationShaderLib != nullptr); + VK_ASSERT(libInfo.pFragmentShaderLib != nullptr); + VkResult result = VK_SUCCESS; pCreateInfo->pBinaryMetadata = pBinaryMetadata; @@ -3100,10 +3107,8 @@ VkResult PipelineCompiler::BuildGplFastLinkCreateInfo( 0 : VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT; pCreateInfo->libFlags |= (libInfo.pPreRasterizationShaderLib == nullptr) ? 0 : VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT; - pCreateInfo->libFlags |= (libInfo.pFragmentShaderLib == nullptr) ? - 0 : VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT; - pCreateInfo->libFlags |= (libInfo.pFragmentOutputInterfaceLib == nullptr) ? - 0 : VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT; + pCreateInfo->libFlags |= VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT; + pCreateInfo->libFlags |= VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT; VkShaderStageFlagBits activeStages = GraphicsPipelineCommon::GetActiveShaderStages(pIn, &libInfo); uint64_t dynamicStateFlags = GraphicsPipelineCommon::GetDynamicStateFlags(pIn->pDynamicState, &libInfo); @@ -3139,7 +3144,7 @@ VkResult PipelineCompiler::BuildGplFastLinkCreateInfo( { if (libInfo.libFlags & VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT) { - BuildFragmentOutputInterfaceState(pDevice, pIn, dynamicStateFlags, pCreateInfo); + BuildFragmentOutputInterfaceState(pDevice, pIn, extStructs, dynamicStateFlags, pCreateInfo); } else if (libInfo.pFragmentOutputInterfaceLib != nullptr) { @@ -3160,7 +3165,7 @@ VkResult PipelineCompiler::BuildGplFastLinkCreateInfo( for (uint32_t deviceIdx = 0; deviceIdx < numPalDevices; deviceIdx++) { shouldCompile |= (GetSolution(pCreateInfo->compilerType)-> - IsGplFastLinkCompatible(pDevice, deviceIdx, pCreateInfo) == false); + IsGplFastLinkCompatible(pDevice, deviceIdx, pCreateInfo, libInfo) == false); } if (shouldCompile) @@ -4400,7 +4405,30 @@ void PipelineCompiler::SetRayTracingState( } #endif - switch (deviceProp.gfxipProperties.rayTracingIp) + Pal::RayTracingIpLevel rayTracingIp = + pDevice->VkPhysicalDevice(DefaultDeviceIndex)->PalProperties().gfxipProperties.rayTracingIp; + + // Optionally, override RTIP level based on software emulation setting + switch (settings.emulatedRtIpLevel) + { + case EmulatedRtIpLevelNone: + break; + case HardwareRtIpLevel1_1: + case EmulatedRtIpLevel1_1: + rayTracingIp = Pal::RayTracingIpLevel::RtIp1_1; + break; +#if VKI_BUILD_GFX11 + case EmulatedRtIpLevel2_0: + rayTracingIp = Pal::RayTracingIpLevel::RtIp2_0; + break; +#endif + default: + VK_ASSERT(false); + break; + } + + // Set frontend compiler version from rayTracingIp + switch (rayTracingIp) { case Pal::RayTracingIpLevel::RtIp1_0: pRtState->rtIpVersion = Vkgc::RtIpVersion({ 1, 0 }); @@ -4426,7 +4454,7 @@ void PipelineCompiler::SetRayTracingState( pRtState->gpurtShaderLibrary.pCode = codePatch.pSpvCode; pRtState->gpurtShaderLibrary.codeSize = codePatch.spvSize; - CompilerSolution::UpdateRayTracingFunctionNames(pDevice, pRtState); + CompilerSolution::UpdateRayTracingFunctionNames(pDevice, rayTracingIp, pRtState); pRtState->rtIpOverride = settings.emulatedRtIpLevel != EmulatedRtIpLevelNone; diff --git a/icd/api/raytrace/ray_tracing_device.cpp b/icd/api/raytrace/ray_tracing_device.cpp index b5c189ca..ba42eb06 100644 --- a/icd/api/raytrace/ray_tracing_device.cpp +++ b/icd/api/raytrace/ray_tracing_device.cpp @@ -99,6 +99,7 @@ VkResult RayTracingDevice::Init() initInfo.pAccelStructTracker = GetAccelStructTracker(deviceIdx); initInfo.accelStructTrackerGpuAddr = GetAccelStructTrackerGpuVa(deviceIdx); + initInfo.deviceSettings.gpuDebugFlags = m_pDevice->GetRuntimeSettings().rtGpuDebugFlags; initInfo.deviceSettings.emulatedRtIpLevel = Pal::RayTracingIpLevel::None; switch (m_pDevice->GetRuntimeSettings().emulatedRtIpLevel) { @@ -236,10 +237,18 @@ void RayTracingDevice::CreateGpuRtDeviceSettings( // Enable AS stats based on panel setting pDeviceSettings->enableBuildAccelStructStats = settings.rtEnableBuildAccelStructStats; + // Number of Rebraid Iterations and rebraid Quality Heuristics + pDeviceSettings->numRebraidIterations = settings.numRebraidIterations; + pDeviceSettings->rebraidQualityHeuristic = settings.rebraidQualityHeuristicType; + + pDeviceSettings->enableEarlyPairCompression = false; pDeviceSettings->rgpBarrierReason = RgpBarrierInternalRayTracingSync; m_profileRayFlags = TraceRayProfileFlagsToRayFlag(settings); m_profileMaxIterations = TraceRayProfileMaxIterationsToMaxIterations(settings); + + pDeviceSettings->enableEarlyPairCompression = settings.enableEarlyPairCompression; + pDeviceSettings->trianglePairingSearchRadius = settings.trianglePairingSearchRadius; } // ===================================================================================================================== @@ -291,16 +300,27 @@ void RayTracingDevice::Destroy() // ===================================================================================================================== bool RayTracingDevice::AccelStructTrackerEnabled( - uint32_t deviceIdx) const + uint32_t deviceIdx + ) const { return (GetAccelStructTracker(deviceIdx) != nullptr) && (m_pDevice->GetRuntimeSettings().enableTraceRayAccelStructTracking || m_pGpuRtDevice[deviceIdx]->AccelStructTraceEnabled()); } +// ===================================================================================================================== +bool RayTracingDevice::RayHistoryTraceActive( + uint32_t deviceIdx + ) const +{ + return (m_pGpuRtDevice[deviceIdx]->RayHistoryTraceActive() || + (m_pDevice->GetRuntimeSettings().rtTraceRayCounterMode != TraceRayCounterDisable)); +} + // ===================================================================================================================== GpuRt::TraceRayCounterMode RayTracingDevice::TraceRayCounterMode( - uint32_t deviceIdx) const + uint32_t deviceIdx + ) const { // If the PAL trace path is enabled, then force RayHistoryLight return m_pGpuRtDevice[deviceIdx]->RayHistoryTraceAvailable() ? @@ -310,7 +330,8 @@ GpuRt::TraceRayCounterMode RayTracingDevice::TraceRayCounterMode( // ===================================================================================================================== GpuRt::AccelStructTracker* RayTracingDevice::GetAccelStructTracker( - uint32_t deviceIdx) const + uint32_t deviceIdx + ) const { GpuRt::AccelStructTracker* pTracker = nullptr; auto* pResources = &m_accelStructTrackerResources[deviceIdx]; @@ -325,7 +346,8 @@ GpuRt::AccelStructTracker* RayTracingDevice::GetAccelStructTracker( // ===================================================================================================================== Pal::gpusize RayTracingDevice::GetAccelStructTrackerGpuVa( - uint32_t deviceIdx) const + uint32_t deviceIdx + ) const { Pal::gpusize gpuAddr = 0; auto* pResources = &m_accelStructTrackerResources[deviceIdx]; @@ -612,7 +634,7 @@ void RayTracingDevice::SetDispatchInfo( // ===================================================================================================================== void RayTracingDevice::TraceDispatch( uint32_t deviceIdx, - Pal::ICmdBuffer* pPalCmdBuffer, + CmdBuffer* pCmdBuffer, GpuRt::RtPipelineType pipelineType, uint32_t width, uint32_t height, @@ -638,11 +660,12 @@ void RayTracingDevice::TraceDispatch( pHitSbt, &dispatchInfo); - m_pGpuRtDevice[deviceIdx]->TraceRtDispatch(pPalCmdBuffer, + m_pGpuRtDevice[deviceIdx]->TraceRtDispatch(pCmdBuffer->PalCmdBuffer(deviceIdx), pipelineType, dispatchInfo, pConstants); } + } // ===================================================================================================================== diff --git a/icd/api/raytrace/ray_tracing_device.h b/icd/api/raytrace/ray_tracing_device.h index 3c158ca7..e8e53a2e 100644 --- a/icd/api/raytrace/ray_tracing_device.h +++ b/icd/api/raytrace/ray_tracing_device.h @@ -38,6 +38,7 @@ namespace vk class Device; class Queue; class InternalMemory; +class CmdBuffer; // Device-level structure for managing state related to ray-tracing. Instantiated as part of a VkDevice. class RayTracingDevice @@ -75,6 +76,7 @@ class RayTracingDevice VkResult InitAccelStructTracker(); bool AccelStructTrackerEnabled(uint32_t deviceIdx) const; + bool RayHistoryTraceActive(uint32_t deviceIdx) const; GpuRt::AccelStructTracker* GetAccelStructTracker(uint32_t deviceIdx) const; Pal::gpusize GetAccelStructTrackerGpuVa(uint32_t deviceIdx) const; const uint32_t* GetAccelStructTrackerSrd(uint32_t deviceIdx) const @@ -87,12 +89,9 @@ class RayTracingDevice GpuRt::TraceRayCounterMode TraceRayCounterMode(uint32_t deviceIdx) const; - bool RayHistoryTraceActive(uint32_t deviceIdx) const - { return m_pGpuRtDevice[deviceIdx]->RayHistoryTraceActive(); } - void TraceDispatch( uint32_t deviceIdx, - Pal::ICmdBuffer* pPalCmdBuffer, + CmdBuffer* pCmdBuffer, GpuRt::RtPipelineType pipelineType, uint32_t width, uint32_t height, diff --git a/icd/api/raytrace/vk_acceleration_structure.cpp b/icd/api/raytrace/vk_acceleration_structure.cpp index d85e8281..7930c3b1 100644 --- a/icd/api/raytrace/vk_acceleration_structure.cpp +++ b/icd/api/raytrace/vk_acceleration_structure.cpp @@ -207,7 +207,8 @@ VkResult AccelerationStructure::ConvertBuildInputsKHR( GpuRt::InputElementLayout::ArrayOfPointers : GpuRt::InputElementLayout::Array; - pInputs->instances.gpu = pInstanceGeom->geometry.instances.data.deviceAddress; + pInputs->instances.gpu = pInstanceGeom->geometry.instances.data.deviceAddress + + ((pBuildRangeInfos != nullptr) ? pBuildRangeInfos->primitiveOffset : 0); if (info.ppGeometries != nullptr) { diff --git a/icd/api/raytrace/vk_ray_tracing_pipeline.cpp b/icd/api/raytrace/vk_ray_tracing_pipeline.cpp index 86528fd8..026d3e61 100644 --- a/icd/api/raytrace/vk_ray_tracing_pipeline.cpp +++ b/icd/api/raytrace/vk_ray_tracing_pipeline.cpp @@ -527,7 +527,6 @@ VkResult RayTracingPipeline::CreateImpl( result = BuildShaderStageInfo(m_pDevice, nativeShaderCount, pCreateInfo->pStages, - false, [](const uint32_t inputIdx, const uint32_t stageIdx) { return inputIdx; @@ -631,20 +630,22 @@ VkResult RayTracingPipeline::CreateImpl( { result = VK_ERROR_OUT_OF_HOST_MEMORY; } - - if (pipelineCreateInfo.groupCount > 0) - { - pipelineBinary[0].shaderGroupHandle.shaderHandles = pShaderGroups[0]; - pipelineBinary[0].shaderGroupHandle.shaderHandleCount = pipelineCreateInfo.groupCount; - } - - for (uint32_t deviceIdx = 1; deviceIdx < m_pDevice->NumPalDevices(); ++deviceIdx) + else { - pShaderGroups[deviceIdx] = pShaderGroups[deviceIdx - 1] + totalGroupCount; if (pipelineCreateInfo.groupCount > 0) { - pipelineBinary[deviceIdx].shaderGroupHandle.shaderHandles = pShaderGroups[deviceIdx]; - pipelineBinary[deviceIdx].shaderGroupHandle.shaderHandleCount = pipelineCreateInfo.groupCount; + pipelineBinary[0].shaderGroupHandle.shaderHandles = pShaderGroups[0]; + pipelineBinary[0].shaderGroupHandle.shaderHandleCount = pipelineCreateInfo.groupCount; + } + + for (uint32_t deviceIdx = 1; deviceIdx < m_pDevice->NumPalDevices(); ++deviceIdx) + { + pShaderGroups[deviceIdx] = pShaderGroups[deviceIdx - 1] + totalGroupCount; + if (pipelineCreateInfo.groupCount > 0) + { + pipelineBinary[deviceIdx].shaderGroupHandle.shaderHandles = pShaderGroups[deviceIdx]; + pipelineBinary[deviceIdx].shaderGroupHandle.shaderHandleCount = pipelineCreateInfo.groupCount; + } } } } @@ -656,6 +657,7 @@ VkResult RayTracingPipeline::CreateImpl( bool* pTraceRayUsage = nullptr; void* pTempBuffer = nullptr; + if (result == VK_SUCCESS) { // Allocate temp buffer for shader name and indirect functions const uint32_t maxPipelineBinaryCount = maxFunctionCount + 1; @@ -808,14 +810,17 @@ VkResult RayTracingPipeline::CreateImpl( } } - // Copy shader groups if compiler doesn't use pre-allocated buffer. - const auto& groupHandle = pipelineBinary[deviceIdx].shaderGroupHandle; - if (groupHandle.shaderHandles != pShaderGroups[deviceIdx]) + if (totalGroupCount > 0) { - memcpy( - pShaderGroups[deviceIdx], - groupHandle.shaderHandles, - sizeof(Vkgc::RayTracingShaderIdentifier) * groupHandle.shaderHandleCount); + // Copy shader groups if compiler doesn't use pre-allocated buffer. + const auto& groupHandle = pipelineBinary[deviceIdx].shaderGroupHandle; + if (groupHandle.shaderHandles != pShaderGroups[deviceIdx]) + { + memcpy( + pShaderGroups[deviceIdx], + groupHandle.shaderHandles, + sizeof(Vkgc::RayTracingShaderIdentifier) * groupHandle.shaderHandleCount); + } } } diff --git a/icd/api/sqtt/sqtt_layer.cpp b/icd/api/sqtt/sqtt_layer.cpp index 6f3de3b3..347ef2a3 100644 --- a/icd/api/sqtt/sqtt_layer.cpp +++ b/icd/api/sqtt/sqtt_layer.cpp @@ -580,6 +580,8 @@ void SqttCmdBufferState::RgdAnnotateDispatch( #if VKI_RAY_TRACING || (type == RgpSqttMarkerEventType::CmdTraceRaysKHR) || (type == RgpSqttMarkerEventType::CmdTraceRaysIndirectKHR) + || (type == RgpSqttMarkerEventType::CmdBuildAccelerationStructuresKHR) + || (type == RgpSqttMarkerEventType::CmdBuildAccelerationStructuresIndirectKHR) #endif ) { @@ -637,6 +639,7 @@ void SqttCmdBufferState::RgdInsertBarrierBeginMarker( { Pal::RgdMarkerInfoBarrierBeginData info = {}; info.header.infoType = Pal::RgdMarkerInfoTypeBarrierBegin; + info.isInternal = false; info.type = type; info.reason = reason; diff --git a/icd/api/strings/entry_points.txt b/icd/api/strings/entry_points.txt index 6f7fbf8b..85be21db 100644 --- a/icd/api/strings/entry_points.txt +++ b/icd/api/strings/entry_points.txt @@ -414,6 +414,7 @@ vkGetPipelineExecutableStatisticsKHR @device @dext(KHR_pipe vkGetPipelineExecutableInternalRepresentationsKHR @device @dext(KHR_pipeline_executable_properties) vkCmdSetLineStippleEXT @device @dext(EXT_line_rasterization) +vkCmdSetLineStippleKHR @device @dext(KHR_line_rasterization) vkSetDeviceMemoryPriorityEXT @device @dext(EXT_pageable_device_local_memory) @@ -561,3 +562,10 @@ vkGetImageSubresourceLayout2KHR @device @dext(KHR_main vkGetRenderingAreaGranularityKHR @device @dext(KHR_maintenance5) vkCmdBindIndexBuffer2KHR @device @dext(KHR_maintenance5) +vkCmdBindDescriptorSets2KHR @device @dext(KHR_maintenance6) +vkCmdPushConstants2KHR @device @dext(KHR_maintenance6) +vkCmdPushDescriptorSet2KHR @device @dext(KHR_maintenance6) +vkCmdPushDescriptorSetWithTemplate2KHR @device @dext(KHR_maintenance6) +vkCmdSetDescriptorBufferOffsets2EXT @device @dext(KHR_maintenance6) +vkCmdBindDescriptorBufferEmbeddedSamplers2EXT @device @dext(KHR_maintenance6) + diff --git a/icd/api/strings/extensions.txt b/icd/api/strings/extensions.txt index dc71915f..36c21903 100644 --- a/icd/api/strings/extensions.txt +++ b/icd/api/strings/extensions.txt @@ -36,6 +36,7 @@ VK_KHR_external_semaphore VK_KHR_external_semaphore_fd VK_KHR_external_fence VK_KHR_external_fence_fd +VK_KHR_line_rasterization VK_KHR_maintenance1 VK_KHR_maintenance2 VK_KHR_push_descriptor @@ -43,6 +44,7 @@ VK_KHR_relaxed_block_layout VK_KHR_sampler_mirror_clamp_to_edge VK_KHR_shader_draw_parameters VK_KHR_shader_float_controls +VK_KHR_shader_float_controls2 VK_KHR_swapchain VK_KHR_image_format_list VK_KHR_swapchain_mutable_format @@ -151,6 +153,8 @@ VK_KHR_pipeline_library VK_KHR_shader_non_semantic_info VK_GOOGLE_user_type VK_KHR_incremental_present +VK_KHR_index_type_uint8 +VK_KHR_load_store_op_none VK_EXT_device_memory_report VK_EXT_robustness2 VK_EXT_extended_dynamic_state @@ -176,6 +180,7 @@ VK_KHR_zero_initialize_workgroup_memory VK_EXT_load_store_op_none VK_KHR_maintenance4 VK_KHR_maintenance5 +VK_KHR_maintenance6 VK_AMD_shader_early_and_late_fragment_tests VK_EXT_mesh_shader VK_EXT_image_view_min_lod @@ -191,6 +196,7 @@ VK_EXT_depth_clamp_zero_one VK_EXT_primitives_generated_query VK_EXT_non_seamless_cube_map VK_EXT_image_sliced_view_of_3d +VK_KHR_shader_maximal_reconvergence VK_EXT_shader_module_identifier VK_EXT_extended_dynamic_state3 VK_KHR_map_memory2 @@ -202,6 +208,9 @@ VK_EXT_physical_device_drm VK_KHR_cooperative_matrix VK_EXT_texture_compression_astc_hdr VK_EXT_image_drm_format_modifier +VK_KHR_shader_expect_assume +VK_KHR_shader_subgroup_rotate +VK_KHR_shader_quad_control VK_KHR_vertex_attribute_divisor VK_EXT_frame_boundary VK_EXT_image_compression_control diff --git a/icd/api/vk_cmdbuffer.cpp b/icd/api/vk_cmdbuffer.cpp index d12c7cc3..2124e68a 100644 --- a/icd/api/vk_cmdbuffer.cpp +++ b/icd/api/vk_cmdbuffer.cpp @@ -78,6 +78,15 @@ namespace vk { namespace { + constexpr Pal::BufferViewInfo EmptyVertexBufferBinding = + { + 0, // gpuAddr; + 0, // range; + 0, // stride; + Pal::UndefinedSwizzledFormat, + 0, // flags + }; + // ===================================================================================================================== // Creates a compatible PAL "clear box" structure from attachment + render area for a renderpass clear. Pal::Box BuildClearBox( @@ -589,7 +598,7 @@ CmdBuffer::CmdBuffer( m_debugPrintf(pDevice->VkInstance()->Allocator()), m_reverseThreadGroupState(false) #if VKI_RAY_TRACING - , m_rayTracingIndirectList(pDevice->VkInstance()->Allocator()) + , m_scratchVidMemList(pDevice->VkInstance()->Allocator()) #endif { m_flags.wasBegun = false; @@ -792,6 +801,7 @@ VkResult CmdBuffer::Initialize( VK_ASSERT(palSize == pPalDevice->GetCmdBufferSize(groupCreateInfo, &result)); VK_ASSERT(result == Pal::Result::Success); } + } if (result == Pal::Result::Success) @@ -1299,7 +1309,7 @@ VkResult CmdBuffer::Begin( ResetState(); #if VKI_RAY_TRACING - FreeRayTracingIndirectMemory(); + FreeRayTracingScratchVidMemory(); #endif const PhysicalDevice* pPhysicalDevice = m_pDevice->VkPhysicalDevice(DefaultDeviceIndex); @@ -1828,7 +1838,7 @@ VkResult CmdBuffer::Reset(VkCommandBufferResetFlags flags) } #if VKI_RAY_TRACING - FreeRayTracingIndirectMemory(); + FreeRayTracingScratchVidMemory(); #endif result = PalToVkResult(PalCmdBufferReset(releaseResources)); @@ -2069,16 +2079,13 @@ void CmdBuffer::BindPipeline( { case VK_PIPELINE_BIND_POINT_COMPUTE: { - if (m_allGpuState.pComputePipeline != pPipeline) - { - m_allGpuState.pComputePipeline = static_cast(pPipeline); + m_allGpuState.pComputePipeline = static_cast(pPipeline); - if (PalPipelineBindingOwnedBy(Pal::PipelineBindPoint::Compute, PipelineBindCompute)) - { - // Defer the binding by invalidating the current PAL compute binding point. This is because we - // don't know what compute-based binding will be utilized until we see the work command. - m_allGpuState.palToApiPipeline[size_t(Pal::PipelineBindPoint::Compute)] = PipelineBindCount; - } + if (PalPipelineBindingOwnedBy(Pal::PipelineBindPoint::Compute, PipelineBindCompute)) + { + // Defer the binding by invalidating the current PAL compute binding point. This is because we + // don't know what compute-based binding will be utilized until we see the work command. + m_allGpuState.palToApiPipeline[size_t(Pal::PipelineBindPoint::Compute)] = PipelineBindCount; } break; @@ -2086,16 +2093,13 @@ void CmdBuffer::BindPipeline( case VK_PIPELINE_BIND_POINT_GRAPHICS: { - if (m_allGpuState.pGraphicsPipeline != pPipeline) - { - m_allGpuState.pGraphicsPipeline = static_cast(pPipeline); + m_allGpuState.pGraphicsPipeline = static_cast(pPipeline); - // Can bind the graphics pipeline immediately since only API graphics pipelines use the PAL - // graphics pipeline. Note that wave limits may still defer the bind inside RebindPipeline(). - VK_ASSERT(PalPipelineBindingOwnedBy(Pal::PipelineBindPoint::Graphics, PipelineBindGraphics)); + // Can bind the graphics pipeline immediately since only API graphics pipelines use the PAL + // graphics pipeline. Note that wave limits may still defer the bind inside RebindPipeline(). + VK_ASSERT(PalPipelineBindingOwnedBy(Pal::PipelineBindPoint::Graphics, PipelineBindGraphics)); - RebindPipeline(); - } + RebindPipeline(); break; } @@ -2103,16 +2107,13 @@ void CmdBuffer::BindPipeline( #if VKI_RAY_TRACING case VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR: { - if (m_allGpuState.pRayTracingPipeline != pPipeline) - { - m_allGpuState.pRayTracingPipeline = static_cast(pPipeline); + m_allGpuState.pRayTracingPipeline = static_cast(pPipeline); - if (PalPipelineBindingOwnedBy(Pal::PipelineBindPoint::Compute, PipelineBindRayTracing)) - { - // Defer the binding by invalidating the current PAL compute binding point. This is because we - // don't know what compute-based binding will be utilized until we see the work command. - m_allGpuState.palToApiPipeline[size_t(Pal::PipelineBindPoint::Compute)] = PipelineBindCount; - } + if (PalPipelineBindingOwnedBy(Pal::PipelineBindPoint::Compute, PipelineBindRayTracing)) + { + // Defer the binding by invalidating the current PAL compute binding point. This is because we + // don't know what compute-based binding will be utilized until we see the work command. + m_allGpuState.palToApiPipeline[size_t(Pal::PipelineBindPoint::Compute)] = PipelineBindCount; } break; @@ -2320,7 +2321,7 @@ VkResult CmdBuffer::Destroy(void) ReleaseResources(); #if VKI_RAY_TRACING - FreeRayTracingIndirectMemory(); + FreeRayTracingScratchVidMemory(); #endif @@ -2384,6 +2385,7 @@ void CmdBuffer::ReleaseResources() m_pStackAllocator = nullptr; } + } // ===================================================================================================================== @@ -2887,25 +2889,26 @@ void CmdBuffer::BindIndexBuffer( DbgBarrierPostCmd(DbgBarrierBindIndexVertexBuffer); } - // ===================================================================================================================== -// Initializes VB binding manager state. Should be called when the command buffer is being initialized. -void CmdBuffer::InitializeVertexBuffer() +// A helper to set the per-device vertex buffer binding table to an empty descriptor. +void CmdBuffer::ClearVertexBufferBindings( + uint32_t watermark) { - for (uint32 deviceIdx = 0; deviceIdx < m_numPalDevices; deviceIdx++) + for (uint32_t deviceIdx = 0; deviceIdx < m_numPalDevices; deviceIdx++) { - Pal::BufferViewInfo* pBindings = &PerGpuState(deviceIdx)->vbBindings[0]; + std::fill_n( + &PerGpuState(deviceIdx)->vbBindings[0], + watermark, + EmptyVertexBufferBinding); - for (uint32 i = 0; i < Pal::MaxVertexBuffers; ++i) - { - // Format needs to be set to invalid for struct srv SRDs - pBindings[i].swizzledFormat = Pal::UndefinedSwizzledFormat; - pBindings[i].gpuAddr = 0; - pBindings[i].range = 0; - pBindings[i].stride = 0; - pBindings[i].flags.u32All = 0; - } } +} + +// ===================================================================================================================== +// Initializes VB binding manager state. Should be called when the command buffer is being initialized. +void CmdBuffer::InitializeVertexBuffer() +{ + ClearVertexBufferBindings(Pal::MaxVertexBuffers); m_vbWatermark = 0; } @@ -2914,21 +2917,63 @@ void CmdBuffer::InitializeVertexBuffer() // Called to reset the state of the VB manager because the parent command buffer is being reset. void CmdBuffer::ResetVertexBuffer() { - for (uint32 deviceIdx = 0; deviceIdx < m_numPalDevices; deviceIdx++) + ClearVertexBufferBindings(m_vbWatermark); + + m_vbWatermark = 0; + + m_uberFetchShaderInternalDataMap.Reset(); +} + +// ===================================================================================================================== +// A part of vkCmdBindVertexBuffers implementation. +void CmdBuffer::BindVertexBuffersUpdateBindingRange( + uint32_t deviceIdx, + Pal::BufferViewInfo* pBinding, + Pal::BufferViewInfo* pEndBinding, + uint32_t inputIdx, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes, + const VkDeviceSize* pStrides) +{ + while (pBinding != pEndBinding) { - Pal::BufferViewInfo* pBindings = &PerGpuState(deviceIdx)->vbBindings[0]; + const VkBuffer buffer = pBuffers[inputIdx]; + const VkDeviceSize offset = pOffsets[inputIdx]; - for (uint32 i = 0; i < m_vbWatermark; ++i) + if (buffer != VK_NULL_HANDLE) { - pBindings[i].gpuAddr = 0; - pBindings[i].range = 0; - pBindings[i].stride = 0; + const Buffer* pBuffer = Buffer::ObjectFromHandle(buffer); + + pBinding->gpuAddr = pBuffer->GpuVirtAddr(deviceIdx) + offset; + if ((pSizes != nullptr) && (pSizes[inputIdx] != VK_WHOLE_SIZE)) + { + pBinding->range = pSizes[inputIdx]; + } + else + { + pBinding->range = pBuffer->GetSize() - offset; + } + } + else + { + pBinding->gpuAddr = 0; + pBinding->range = 0; } - } - m_vbWatermark = 0; + if (pStrides != nullptr) + { + pBinding->stride = pStrides[inputIdx]; + } - m_uberFetchShaderInternalDataMap.Reset(); + if (m_flags.padVertexBuffers && (pBinding->stride != 0)) + { + pBinding->range = Util::RoundUpToMultiple(pBinding->range, pBinding->stride); + } + + inputIdx++; + pBinding++; + } } // ===================================================================================================================== @@ -2945,62 +2990,39 @@ void CmdBuffer::BindVertexBuffers( { DbgBarrierPreCmd(DbgBarrierBindIndexVertexBuffer); - const bool padVertexBuffers = m_flags.padVertexBuffers; + constexpr uint32_t MaxLowBindings = VK_ARRAY_SIZE(PerGpuRenderState::vbBindings); + + const uint32_t lowBindingCount = + (firstBinding < MaxLowBindings) ? Util::Min(bindingCount, MaxLowBindings - firstBinding) : 0u; utils::IterateMask deviceGroup(GetDeviceMask()); do { const uint32_t deviceIdx = deviceGroup.Index(); - Pal::BufferViewInfo* pBinding = &PerGpuState(deviceIdx)->vbBindings[firstBinding]; - Pal::BufferViewInfo* pEndBinding = pBinding + bindingCount; - uint32_t inputIdx = 0; - - while (pBinding != pEndBinding) + if (lowBindingCount > 0) { - const VkBuffer buffer = pBuffers[inputIdx]; - const VkDeviceSize offset = pOffsets[inputIdx]; + Pal::BufferViewInfo* const pBinding = &PerGpuState(deviceIdx)->vbBindings[firstBinding]; - if (buffer != VK_NULL_HANDLE) - { - const Buffer* pBuffer = Buffer::ObjectFromHandle(buffer); - - pBinding->gpuAddr = pBuffer->GpuVirtAddr(deviceIdx) + offset; - if ((pSizes != nullptr) && (pSizes[inputIdx] != VK_WHOLE_SIZE)) - { - pBinding->range = pSizes[inputIdx]; - } - else - { - pBinding->range = pBuffer->GetSize() - offset; - } - } - else - { - pBinding->gpuAddr = 0; - pBinding->range = 0; - } - - if (pStrides != nullptr) - { - pBinding->stride = pStrides[inputIdx]; - } - - if (padVertexBuffers && (pBinding->stride != 0)) - { - pBinding->range = Util::RoundUpToMultiple(pBinding->range, pBinding->stride); - } + BindVertexBuffersUpdateBindingRange( + deviceIdx, + pBinding, + pBinding + lowBindingCount, + 0, + pBuffers, + pOffsets, + pSizes, + pStrides); - inputIdx++; - pBinding++; + PalCmdBuffer(deviceIdx)->CmdSetVertexBuffers(firstBinding, lowBindingCount, pBinding); } - PalCmdBuffer(deviceIdx)->CmdSetVertexBuffers( - firstBinding, bindingCount, &PerGpuState(deviceIdx)->vbBindings[firstBinding]); } while (deviceGroup.IterateNext()); - m_vbWatermark = Util::Max(m_vbWatermark, firstBinding + bindingCount); + m_vbWatermark = Util::Max( + m_vbWatermark, + Util::Min(firstBinding + bindingCount, MaxLowBindings)); DbgBarrierPostCmd(DbgBarrierBindIndexVertexBuffer); } @@ -3318,11 +3340,12 @@ void CmdBuffer::ClearColorImage( { PalCmdSuspendPredication(true); - const Image* pImage = Image::ObjectFromHandle(image); + const Image* pImage = Image::ObjectFromHandle(image); + const RuntimeSettings& settings = m_pDevice->GetRuntimeSettings(); VkFormat format = pImage->TreatAsSrgb() ? pImage->GetSrgbFormat() : pImage->GetFormat(); - const Pal::SwizzledFormat palFormat = VkToPalFormat(format, m_pDevice->GetRuntimeSettings()); + const Pal::SwizzledFormat palFormat = VkToPalFormat(format, settings); if (Pal::Formats::IsBlockCompressed(palFormat.format)) { @@ -3358,7 +3381,7 @@ void CmdBuffer::ClearColorImage( pImage->GetArraySize(), pPalRanges, &palRangeCount, - m_pDevice->GetRuntimeSettings()); + settings); ++rangeIdx; } @@ -3372,7 +3395,7 @@ void CmdBuffer::ClearColorImage( pPalRanges, 0, nullptr, - 0); + settings.enableColorClearAutoSync ? Pal::ColorClearAutoSync : 0); } virtStackFrame.FreeArray(pPalRanges); @@ -3984,10 +4007,9 @@ void CmdBuffer::PalCmdClearDepthStencil( } // ===================================================================================================================== -template void CmdBuffer::PalCmdResetEvent( - EventContainer_T* pEvent, - Pal::HwPipePoint resetPoint) + Event* pEvent, + Pal::HwPipePoint resetPoint) { utils::IterateMask deviceGroup(m_curDeviceMask); do @@ -4000,10 +4022,9 @@ void CmdBuffer::PalCmdResetEvent( } // ===================================================================================================================== -template void CmdBuffer::PalCmdSetEvent( - EventContainer_T* pEvent, - Pal::HwPipePoint setPoint) + Event* pEvent, + Pal::HwPipePoint setPoint) { utils::IterateMask deviceGroup(m_curDeviceMask); do @@ -4599,6 +4620,50 @@ void CmdBuffer::BeginRendering( bool skipEverything = isResuming && m_flags.isRenderingSuspended; bool skipClears = isResuming && (m_flags.isRenderingSuspended == false); + m_allGpuState.dynamicRenderingInstance.viewMask = pRenderingInfo->viewMask; + m_allGpuState.dynamicRenderingInstance.colorAttachmentCount = pRenderingInfo->colorAttachmentCount; + m_allGpuState.dynamicRenderingInstance.enableResolveTarget = false; + + for (uint32_t i = 0; i < pRenderingInfo->colorAttachmentCount; ++i) + { + const VkRenderingAttachmentInfo& colorAttachmentInfo = pRenderingInfo->pColorAttachments[i]; + + m_allGpuState.dynamicRenderingInstance.enableResolveTarget |= + (colorAttachmentInfo.resolveImageView != VK_NULL_HANDLE); + + StoreAttachmentInfo( + colorAttachmentInfo, + &m_allGpuState.dynamicRenderingInstance.colorAttachments[i]); + + m_allGpuState.dynamicRenderingInstance.colorAttachmentLocations[i] = i; + } + + if (pRenderingInfo->pDepthAttachment != nullptr) + { + const VkRenderingAttachmentInfo& depthAttachmentInfo = *pRenderingInfo->pDepthAttachment; + + m_allGpuState.dynamicRenderingInstance.enableResolveTarget |= + (depthAttachmentInfo.resolveImageView != VK_NULL_HANDLE); + + StoreAttachmentInfo( + depthAttachmentInfo, + &m_allGpuState.dynamicRenderingInstance.depthAttachment); + } + + if (pRenderingInfo->pStencilAttachment != nullptr) + { + const VkRenderingAttachmentInfo& stencilAttachmentInfo = *pRenderingInfo->pStencilAttachment; + + m_allGpuState.dynamicRenderingInstance.enableResolveTarget |= + (stencilAttachmentInfo.resolveImageView != VK_NULL_HANDLE); + + StoreAttachmentInfo( + stencilAttachmentInfo, + &m_allGpuState.dynamicRenderingInstance.stencilAttachment); + } + + m_flags.isRenderingSuspended = isSuspended; + if (!skipEverything) { EXTRACT_VK_STRUCTURES_2( @@ -4685,57 +4750,32 @@ void CmdBuffer::BeginRendering( PalCmdSuspendPredication(false); } - BindTargets( - pRenderingInfo, - pRenderingFragmentShadingRateAttachmentInfoKHR); - - uint32_t numMultiViews = Util::CountSetBits(pRenderingInfo->viewMask); - uint32_t viewInstanceMask = (numMultiViews > 0) ? pRenderingInfo->viewMask : GetDeviceMask(); - PalCmdBuffer(DefaultDeviceIndex)->CmdSetViewInstanceMask(viewInstanceMask); - } - - m_allGpuState.dynamicRenderingInstance.viewMask = pRenderingInfo->viewMask; - m_allGpuState.dynamicRenderingInstance.colorAttachmentCount = pRenderingInfo->colorAttachmentCount; - m_allGpuState.dynamicRenderingInstance.enableResolveTarget = false; + BindTargets(); - for (uint32_t i = 0; i < pRenderingInfo->colorAttachmentCount; ++i) - { - const VkRenderingAttachmentInfo& colorAttachmentInfo = pRenderingInfo->pColorAttachments[i]; - - m_allGpuState.dynamicRenderingInstance.enableResolveTarget |= - (colorAttachmentInfo.resolveImageView != VK_NULL_HANDLE); - - StoreAttachmentInfo( - colorAttachmentInfo, - &m_allGpuState.dynamicRenderingInstance.colorAttachments[i]); - } - - if (pRenderingInfo->pDepthAttachment != nullptr) - { - const VkRenderingAttachmentInfo& depthAttachmentInfo = *pRenderingInfo->pDepthAttachment; - - m_allGpuState.dynamicRenderingInstance.enableResolveTarget |= - (depthAttachmentInfo.resolveImageView != VK_NULL_HANDLE); - - StoreAttachmentInfo( - depthAttachmentInfo, - &m_allGpuState.dynamicRenderingInstance.depthAttachment); - } + if ((pRenderingFragmentShadingRateAttachmentInfoKHR != nullptr) && + (pRenderingFragmentShadingRateAttachmentInfoKHR->imageView != VK_NULL_HANDLE)) + { + // Get the image view from the attachment info + const ImageView* const pImageView = + ImageView::ObjectFromHandle(pRenderingFragmentShadingRateAttachmentInfoKHR->imageView); - if (pRenderingInfo->pStencilAttachment != nullptr) - { - const VkRenderingAttachmentInfo& stencilAttachmentInfo = *pRenderingInfo->pStencilAttachment; + // Get the attachment image + const Image* pImage = pImageView->GetImage(); - m_allGpuState.dynamicRenderingInstance.enableResolveTarget |= - (stencilAttachmentInfo.resolveImageView != VK_NULL_HANDLE); + utils::IterateMask deviceGroup(GetDeviceMask()); + do + { + const uint32_t deviceIdx = deviceGroup.Index(); + PalCmdBuffer(deviceIdx)->CmdBindSampleRateImage(pImage->PalImage(deviceIdx)); + } + while (deviceGroup.IterateNext()); + } - StoreAttachmentInfo( - stencilAttachmentInfo, - &m_allGpuState.dynamicRenderingInstance.stencilAttachment); + uint32_t numMultiViews = Util::CountSetBits(pRenderingInfo->viewMask); + uint32_t viewInstanceMask = (numMultiViews > 0) ? pRenderingInfo->viewMask : GetDeviceMask(); + PalCmdBuffer(DefaultDeviceIndex)->CmdSetViewInstanceMask(viewInstanceMask); } - m_flags.isRenderingSuspended = isSuspended; - DbgBarrierPostCmd(DbgBarrierBeginRendering); } @@ -4899,16 +4939,7 @@ void CmdBuffer::ResetEvent( } else { - const Pal::HwPipePoint pipePoint = VkToPalSrcPipePoint(stageMask); - - utils::IterateMask deviceGroup(m_curDeviceMask); - do - { - const uint32_t deviceIdx = deviceGroup.Index(); - - PalCmdBuffer(deviceIdx)->CmdResetEvent(*pEvent->PalEvent(deviceIdx), pipePoint); - } - while (deviceGroup.IterateNext()); + PalCmdResetEvent(pEvent, VkToPalSrcPipePoint(stageMask)); } DbgBarrierPostCmd(DbgBarrierSetResetEvent); @@ -8537,15 +8568,11 @@ void CmdBuffer::GetImageLayout( // ===================================================================================================================== // Binds color/depth targets for VK_KHR_dynamic_rendering -void CmdBuffer::BindTargets( - const VkRenderingInfo* pRenderingInfo, - const VkRenderingFragmentShadingRateAttachmentInfoKHR* pRenderingFragmentShadingRateAttachmentInfoKHR) +void CmdBuffer::BindTargets() { Pal::BindTargetParams params = {}; - params.colorTargetCount = pRenderingInfo->colorAttachmentCount; - - static constexpr Pal::ImageLayout NullLayout = {}; + params.colorTargetCount = m_allGpuState.dynamicRenderingInstance.colorAttachmentCount; utils::IterateMask deviceGroup(GetDeviceMask()); do @@ -8554,98 +8581,44 @@ void CmdBuffer::BindTargets( for (uint32_t i = 0; i < params.colorTargetCount; ++i) { - const VkRenderingAttachmentInfo& renderingAttachmentInfo = pRenderingInfo->pColorAttachments[i]; + const uint32_t location = m_allGpuState.dynamicRenderingInstance.colorAttachmentLocations[i]; - if (renderingAttachmentInfo.imageView != VK_NULL_HANDLE) + if (location != VK_ATTACHMENT_UNUSED) { - // Get the image view from the attachment info - const ImageView* const pImageView = ImageView::ObjectFromHandle(renderingAttachmentInfo.imageView); + const DynamicRenderingAttachments& renderingAttachmentInfo = + m_allGpuState.dynamicRenderingInstance.colorAttachments[i]; - // Get the attachment image - const Image* pImage = pImageView->GetImage(); - - params.colorTargets[i].pColorTargetView = pImageView->PalColorTargetView(deviceIdx); - - RPImageLayout imageLayout = + if (renderingAttachmentInfo.pImageView != VK_NULL_HANDLE) { - renderingAttachmentInfo.imageLayout, - 0 - }; - - params.colorTargets[i].imageLayout = - pImage->GetAttachmentLayout( - imageLayout, - 0, - this); + params.colorTargets[location].pColorTargetView = + renderingAttachmentInfo.pImageView->PalColorTargetView(deviceIdx); - } - else - { - params.colorTargets[i].pColorTargetView = nullptr; - params.colorTargets[i].imageLayout = NullLayout; + params.colorTargets[location].imageLayout = renderingAttachmentInfo.imageLayout; + } } } - const VkRenderingAttachmentInfo* pStencilAttachmentInfo = pRenderingInfo->pStencilAttachment; + const DynamicRenderingAttachments& stencilAttachmentInfo = + m_allGpuState.dynamicRenderingInstance.stencilAttachment; - if ((pStencilAttachmentInfo != nullptr) && - (pStencilAttachmentInfo->imageView != VK_NULL_HANDLE)) + if (stencilAttachmentInfo.pImageView != VK_NULL_HANDLE) { - const ImageView* const pStencilImageView = - ImageView::ObjectFromHandle(pStencilAttachmentInfo->imageView); - - Pal::SubresRange subresRange = {}; - Pal::ImageLayout stencilLayout = {}; - - GetImageLayout( - pStencilAttachmentInfo->imageView, - pStencilAttachmentInfo->imageLayout, - VK_IMAGE_ASPECT_STENCIL_BIT, - &subresRange, - &stencilLayout); - - params.depthTarget.pDepthStencilView = pStencilImageView->PalDepthStencilView(deviceIdx); - params.depthTarget.stencilLayout = stencilLayout; + params.depthTarget.pDepthStencilView = stencilAttachmentInfo.pImageView->PalDepthStencilView(deviceIdx); + params.depthTarget.stencilLayout = stencilAttachmentInfo.imageLayout; } - const VkRenderingAttachmentInfo* pDepthAttachmentInfo = pRenderingInfo->pDepthAttachment; + const DynamicRenderingAttachments& depthAttachmentInfo = + m_allGpuState.dynamicRenderingInstance.depthAttachment; - if ((pDepthAttachmentInfo != nullptr) && - (pDepthAttachmentInfo->imageView != VK_NULL_HANDLE)) + if (depthAttachmentInfo.pImageView != VK_NULL_HANDLE) { - const ImageView* const pDepthImageView = - ImageView::ObjectFromHandle(pDepthAttachmentInfo->imageView); - - Pal::SubresRange subresRange = {}; - Pal::ImageLayout depthLayout = {}; - - GetImageLayout( - pDepthAttachmentInfo->imageView, - pDepthAttachmentInfo->imageLayout, - VK_IMAGE_ASPECT_DEPTH_BIT, - &subresRange, - &depthLayout); - - params.depthTarget.pDepthStencilView = pDepthImageView->PalDepthStencilView(deviceIdx); - params.depthTarget.depthLayout = depthLayout; + params.depthTarget.pDepthStencilView = depthAttachmentInfo.pImageView->PalDepthStencilView(deviceIdx); + params.depthTarget.depthLayout = depthAttachmentInfo.imageLayout; } PalCmdBuffer(deviceIdx)->CmdBindTargets(params); - if ((pRenderingFragmentShadingRateAttachmentInfoKHR != nullptr) && - (pRenderingFragmentShadingRateAttachmentInfoKHR->imageView != VK_NULL_HANDLE)) - { - // Get the image view from the attachment info - const ImageView* const pImageView = - ImageView::ObjectFromHandle(pRenderingFragmentShadingRateAttachmentInfoKHR->imageView); - - // Get the attachment image - const Image* pImage = pImageView->GetImage(); - - PalCmdBuffer(deviceIdx)->CmdBindSampleRateImage(pImage->PalImage(deviceIdx)); - } - } while (deviceGroup.IterateNext()); } @@ -9739,6 +9712,30 @@ void CmdBuffer::SetVertexInput( } } +// ===================================================================================================================== +void CmdBuffer::SetRenderingAttachmentLocations( + const VkRenderingAttachmentLocationInfoKHR* pLocationInfo) +{ + if ((pLocationInfo != nullptr) && + (pLocationInfo->pColorAttachmentLocations != nullptr)) + { + for (uint32_t i = 0; i < pLocationInfo->colorAttachmentCount; ++i) + { + m_allGpuState.dynamicRenderingInstance.colorAttachmentLocations[i] = + pLocationInfo->pColorAttachmentLocations[i]; + } + + BindTargets(); + } +} + +// ===================================================================================================================== +void CmdBuffer::SetRenderingInputAttachmentIndices( + const VkRenderingInputAttachmentIndexInfoKHR* pLocationInfo) +{ + +} + #if VK_ENABLE_DEBUG_BARRIERS // ===================================================================================================================== // This function inserts a command before or after a particular Vulkan command if the given runtime settings are asking @@ -10507,9 +10504,8 @@ void CmdBuffer::GetRayTracingDispatchArgs( if (width > 0) { - // Populate internalUavBufferSrd only for direct dispatches (where width, height, and depth are known) m_pDevice->RayTrace()->TraceDispatch(deviceIdx, - PalCmdBuffer(deviceIdx), + this, GpuRt::RtPipelineType::RayTracing, width, height, @@ -10521,7 +10517,6 @@ void CmdBuffer::GetRayTracingDispatchArgs( &hitSbt, pConstants); } - } // ===================================================================================================================== @@ -10716,8 +10711,6 @@ void CmdBuffer::TraceRaysIndirectPerDevice( VK_ASSERT(result == VK_SUCCESS); - m_rayTracingIndirectList.PushBack(pScratchMemory); - auto* pInitConstants = reinterpret_cast( PalCmdBuffer(deviceIdx)->CmdAllocateEmbeddedData(GpuRt::InitExecuteIndirectConstantsDw, 2, @@ -10811,12 +10804,13 @@ void CmdBuffer::TraceRaysIndirectPerDevice( } // ===================================================================================================================== -// Alloacates GPU video memory according for TraceRaysIndirect -VkResult CmdBuffer::GetRayTracingIndirectMemory( - gpusize size, - InternalMemory** ppInternalMemory) +// Allocates gpu video memory. +VkResult CmdBuffer::GetScratchVidMem( + gpusize sizeInBytes, + InternalSubAllocPool poolId, + InternalMemory** ppInternalMemory) { - VkResult result = VK_SUCCESS; + VkResult result = VK_ERROR_OUT_OF_HOST_MEMORY; *ppInternalMemory = nullptr; @@ -10837,11 +10831,11 @@ VkResult CmdBuffer::GetRayTracingIndirectMemory( { InternalMemCreateInfo allocInfo = {}; - allocInfo.pal.size = size; + allocInfo.pal.size = sizeInBytes; allocInfo.pal.alignment = 16; allocInfo.pal.priority = Pal::GpuMemPriority::Normal; - m_pDevice->MemMgr()->GetCommonPool(InternalPoolGpuAccess, &allocInfo); + m_pDevice->MemMgr()->GetCommonPool(poolId, &allocInfo); result = m_pDevice->MemMgr()->AllocGpuMem( allocInfo, @@ -10855,6 +10849,7 @@ VkResult CmdBuffer::GetRayTracingIndirectMemory( if (result == VK_SUCCESS) { *ppInternalMemory = pInternalMemory; + m_scratchVidMemList.PushBack(pInternalMemory); } } @@ -10872,28 +10867,37 @@ VkResult CmdBuffer::GetRayTracingIndirectMemory( return result; } +// ===================================================================================================================== +// Alloacates GPU video memory according for TraceRaysIndirect +VkResult CmdBuffer::GetRayTracingIndirectMemory( + gpusize size, + InternalMemory** ppInternalMemory) +{ + return GetScratchVidMem(size, InternalPoolGpuAccess, ppInternalMemory); +} + // ===================================================================================================================== // Free GPU video memory according for TraceRaysIndirect -void CmdBuffer::FreeRayTracingIndirectMemory() +void CmdBuffer::FreeRayTracingScratchVidMemory() { // This data could be farily large and consumes framebuffer memory. // // This should always be done when vkResetCommandBuffer() is called to handle the case // where an app resets a command buffer but doesn't call vkBeginCommandBuffer right away. - for (uint32_t i = 0; i < m_rayTracingIndirectList.NumElements(); ++i) + for (uint32_t i = 0; i < m_scratchVidMemList.NumElements(); ++i) { // Dump entry data - InternalMemory* indirectMemory = m_rayTracingIndirectList.At(i); + InternalMemory* pVidMemory = m_scratchVidMemList.At(i); // Free memory - m_pDevice->MemMgr()->FreeGpuMem(indirectMemory); + m_pDevice->MemMgr()->FreeGpuMem(pVidMemory); - Util::Destructor(indirectMemory); - m_pDevice->VkInstance()->FreeMem(indirectMemory); + Util::Destructor(pVidMemory); + m_pDevice->VkInstance()->FreeMem(pVidMemory); } // Clear list - m_rayTracingIndirectList.Clear(); + m_scratchVidMemList.Clear(); } // ===================================================================================================================== @@ -10986,7 +10990,7 @@ void CmdBuffer::BindRayQueryConstants( constants.constData.rayDispatchDepth = depth * pOrigThreadgroupDims[2]; m_pDevice->RayTrace()->TraceDispatch(deviceIdx, - PalCmdBuffer(deviceIdx), + this, GpuRt::RtPipelineType::Compute, width * pOrigThreadgroupDims[0], height * pOrigThreadgroupDims[1], @@ -11238,7 +11242,19 @@ void CmdBuffer::ValidateGraphicsStates() { DynamicColorBlend colorBlend = {}; - pRSCache->CreateColorBlendState(m_allGpuState.colorBlendCreateInfo, + Pal::ColorBlendStateCreateInfo colorBlendCreateInfo = m_allGpuState.colorBlendCreateInfo; + + for (uint32_t i = 0; i < m_allGpuState.dynamicRenderingInstance.colorAttachmentCount; ++i) + { + const uint32_t location = m_allGpuState.dynamicRenderingInstance.colorAttachmentLocations[i]; + + if (location != VK_ATTACHMENT_UNUSED) + { + colorBlendCreateInfo.targets[location] = m_allGpuState.colorBlendCreateInfo.targets[i]; + } + } + + pRSCache->CreateColorBlendState(colorBlendCreateInfo, m_pDevice->VkInstance()->GetAllocCallbacks(), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT, colorBlend.pPalColorBlend); @@ -12189,6 +12205,369 @@ RenderPassInstanceState::RenderPassInstanceState( memset(&renderArea[0], 0, sizeof(renderArea)); } +// ===================================================================================================================== +template +VKAPI_ATTR void VKAPI_CALL CmdBuffer::CmdBindDescriptorSets2KHR( + VkCommandBuffer cmdBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo) +{ + ApiCmdBuffer::ObjectFromHandle(cmdBuffer)->BindDescriptorSets2KHR( + pBindDescriptorSetsInfo); +} + +// ===================================================================================================================== +template +void CmdBuffer::BindDescriptorSets2KHR( + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo) +{ + if ((pBindDescriptorSetsInfo->stageFlags & ShaderStageAllGraphics) != 0) + { + BindDescriptorSets( + VK_PIPELINE_BIND_POINT_GRAPHICS, + pBindDescriptorSetsInfo->layout, + pBindDescriptorSetsInfo->firstSet, + pBindDescriptorSetsInfo->descriptorSetCount, + pBindDescriptorSetsInfo->pDescriptorSets, + pBindDescriptorSetsInfo->dynamicOffsetCount, + pBindDescriptorSetsInfo->pDynamicOffsets); + } + if ((pBindDescriptorSetsInfo->stageFlags & VK_SHADER_STAGE_COMPUTE_BIT) != 0) + { + BindDescriptorSets( + VK_PIPELINE_BIND_POINT_COMPUTE, + pBindDescriptorSetsInfo->layout, + pBindDescriptorSetsInfo->firstSet, + pBindDescriptorSetsInfo->descriptorSetCount, + pBindDescriptorSetsInfo->pDescriptorSets, + pBindDescriptorSetsInfo->dynamicOffsetCount, + pBindDescriptorSetsInfo->pDynamicOffsets); + + } +#if VKI_RAY_TRACING + if ((pBindDescriptorSetsInfo->stageFlags & ShaderStageAllRayTracing) != 0) + { + BindDescriptorSets( + VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, + pBindDescriptorSetsInfo->layout, + pBindDescriptorSetsInfo->firstSet, + pBindDescriptorSetsInfo->descriptorSetCount, + pBindDescriptorSetsInfo->pDescriptorSets, + pBindDescriptorSetsInfo->dynamicOffsetCount, + pBindDescriptorSetsInfo->pDynamicOffsets); + } +#endif +} + +// ===================================================================================================================== +void CmdBuffer::PushConstants2KHR( + const VkPushConstantsInfoKHR* pPushConstantsInfo) +{ + PushConstants(pPushConstantsInfo->layout, + pPushConstantsInfo->stageFlags, + pPushConstantsInfo->offset, + pPushConstantsInfo->size, + pPushConstantsInfo->pValues); +} + +// ===================================================================================================================== +template +VKAPI_ATTR void VKAPI_CALL CmdBuffer::CmdPushDescriptorSet2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo) +{ + CmdBuffer* pCmdBuffer = ApiCmdBuffer::ObjectFromHandle(commandBuffer); + + pCmdBuffer->PushDescriptorSet2KHR( + pPushDescriptorSetInfo); +} + +// ===================================================================================================================== +template +void CmdBuffer::PushDescriptorSet2KHR( + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo) +{ + if ((pPushDescriptorSetInfo->stageFlags & ShaderStageAllGraphics) != 0) + { + PushDescriptorSetKHR( + VK_PIPELINE_BIND_POINT_GRAPHICS, + pPushDescriptorSetInfo->layout, + pPushDescriptorSetInfo->set, + pPushDescriptorSetInfo->descriptorWriteCount, + pPushDescriptorSetInfo->pDescriptorWrites); + } + + if ((pPushDescriptorSetInfo->stageFlags & VK_SHADER_STAGE_COMPUTE_BIT) != 0) + { + PushDescriptorSetKHR( + VK_PIPELINE_BIND_POINT_COMPUTE, + pPushDescriptorSetInfo->layout, + pPushDescriptorSetInfo->set, + pPushDescriptorSetInfo->descriptorWriteCount, + pPushDescriptorSetInfo->pDescriptorWrites); + } +#if VKI_RAY_TRACING + if ((pPushDescriptorSetInfo->stageFlags & ShaderStageAllRayTracing) != 0) + { + PushDescriptorSetKHR( + VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, + pPushDescriptorSetInfo->layout, + pPushDescriptorSetInfo->set, + pPushDescriptorSetInfo->descriptorWriteCount, + pPushDescriptorSetInfo->pDescriptorWrites); + } +#endif +} + +// ===================================================================================================================== +template +VKAPI_ATTR void VKAPI_CALL CmdBuffer::CmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo) +{ + CmdBuffer* pCmdBuffer = ApiCmdBuffer::ObjectFromHandle(commandBuffer); + + pCmdBuffer->PushDescriptorSetWithTemplate2KHR( + pPushDescriptorSetWithTemplateInfo); +} + +// ===================================================================================================================== +template +void CmdBuffer::PushDescriptorSetWithTemplate2KHR( + const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo) +{ + PushDescriptorSetWithTemplateKHR( + pPushDescriptorSetWithTemplateInfo->descriptorUpdateTemplate, + pPushDescriptorSetWithTemplateInfo->layout, + pPushDescriptorSetWithTemplateInfo->set, + pPushDescriptorSetWithTemplateInfo->pData); +} + +// ===================================================================================================================== +void CmdBuffer::SetDescriptorBufferOffsets2EXT( + const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) +{ + if ((pSetDescriptorBufferOffsetsInfo->stageFlags & ShaderStageAllGraphics) != 0) + { + SetDescriptorBufferOffsets( + VK_PIPELINE_BIND_POINT_GRAPHICS, + pSetDescriptorBufferOffsetsInfo->layout, + pSetDescriptorBufferOffsetsInfo->firstSet, + pSetDescriptorBufferOffsetsInfo->setCount, + pSetDescriptorBufferOffsetsInfo->pBufferIndices, + pSetDescriptorBufferOffsetsInfo->pOffsets); + } + + if ((pSetDescriptorBufferOffsetsInfo->stageFlags & VK_SHADER_STAGE_COMPUTE_BIT) != 0) + { + SetDescriptorBufferOffsets( + VK_PIPELINE_BIND_POINT_COMPUTE, + pSetDescriptorBufferOffsetsInfo->layout, + pSetDescriptorBufferOffsetsInfo->firstSet, + pSetDescriptorBufferOffsetsInfo->setCount, + pSetDescriptorBufferOffsetsInfo->pBufferIndices, + pSetDescriptorBufferOffsetsInfo->pOffsets); + } +#if VKI_RAY_TRACING + if ((pSetDescriptorBufferOffsetsInfo->stageFlags & ShaderStageAllRayTracing) != 0) + { + SetDescriptorBufferOffsets( + VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, + pSetDescriptorBufferOffsetsInfo->layout, + pSetDescriptorBufferOffsetsInfo->firstSet, + pSetDescriptorBufferOffsetsInfo->setCount, + pSetDescriptorBufferOffsetsInfo->pBufferIndices, + pSetDescriptorBufferOffsetsInfo->pOffsets); + } +#endif +} + +// ===================================================================================================================== +void CmdBuffer::BindDescriptorBufferEmbeddedSamplers2EXT( + const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) +{ + if ((pBindDescriptorBufferEmbeddedSamplersInfo->stageFlags & ShaderStageAllGraphics) != 0) + { + BindDescriptorBufferEmbeddedSamplers( + VK_PIPELINE_BIND_POINT_GRAPHICS, + pBindDescriptorBufferEmbeddedSamplersInfo->layout, + pBindDescriptorBufferEmbeddedSamplersInfo->set); + } + + if ((pBindDescriptorBufferEmbeddedSamplersInfo->stageFlags & VK_SHADER_STAGE_COMPUTE_BIT) != 0) + { + BindDescriptorBufferEmbeddedSamplers( + VK_PIPELINE_BIND_POINT_COMPUTE, + pBindDescriptorBufferEmbeddedSamplersInfo->layout, + pBindDescriptorBufferEmbeddedSamplersInfo->set); + } +#if VKI_RAY_TRACING + if ((pBindDescriptorBufferEmbeddedSamplersInfo->stageFlags & ShaderStageAllRayTracing) != 0) + { + BindDescriptorBufferEmbeddedSamplers( + VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, + pBindDescriptorBufferEmbeddedSamplersInfo->layout, + pBindDescriptorBufferEmbeddedSamplersInfo->set); + } +#endif +} + +// ===================================================================================================================== +PFN_vkCmdBindDescriptorSets2KHR CmdBuffer::GetCmdBindDescriptorSets2KHRFunc( + const Device* pDevice) +{ + PFN_vkCmdBindDescriptorSets2KHR pFunc = nullptr; + + switch (pDevice->NumPalDevices()) + { + case 1: + pFunc = GetCmdBindDescriptorSets2KHRFunc<1>(pDevice); + break; +#if (VKI_BUILD_MAX_NUM_GPUS > 1) + case 2: + pFunc = GetCmdBindDescriptorSets2KHRFunc<2>(pDevice); + break; +#endif +#if (VKI_BUILD_MAX_NUM_GPUS > 2) + case 3: + pFunc = GetCmdBindDescriptorSets2KHRFunc<3>(pDevice); + break; +#endif +#if (VKI_BUILD_MAX_NUM_GPUS > 3) + case 4: + pFunc = GetCmdBindDescriptorSets2KHRFunc<4>(pDevice); + break; +#endif + default: + pFunc = nullptr; + VK_NEVER_CALLED(); + break; + } + + return pFunc; +} + +// ===================================================================================================================== +template +PFN_vkCmdBindDescriptorSets2KHR CmdBuffer::GetCmdBindDescriptorSets2KHRFunc( + const Device* pDevice) +{ + PFN_vkCmdBindDescriptorSets2KHR pFunc = nullptr; + + if (pDevice->UseCompactDynamicDescriptors()) + { + pFunc = CmdBindDescriptorSets2KHR; + } + else + { + pFunc = CmdBindDescriptorSets2KHR; + } + + return pFunc; +} + +// ===================================================================================================================== +template +PFN_vkCmdPushDescriptorSet2KHR CmdBuffer::GetCmdPushDescriptorSet2KHRFunc( + const Device* pDevice) +{ + const size_t imageDescSize = pDevice->GetProperties().descriptorSizes.imageView; + const size_t samplerDescSize = pDevice->GetProperties().descriptorSizes.sampler; + const size_t bufferDescSize = pDevice->GetProperties().descriptorSizes.bufferView; + + PFN_vkCmdPushDescriptorSet2KHR pFunc = nullptr; + + if ((imageDescSize == 32) && + (samplerDescSize == 16) && + (bufferDescSize == 16)) + { + pFunc = &CmdPushDescriptorSet2KHR< + 32, + 16, + 16, + numPalDevices>; + } + else + { + VK_NEVER_CALLED(); + } + + return pFunc; +} + +// ===================================================================================================================== +PFN_vkCmdPushDescriptorSet2KHR CmdBuffer::GetCmdPushDescriptorSet2KHRFunc( + const Device* pDevice) +{ + PFN_vkCmdPushDescriptorSet2KHR pFunc = nullptr; + + switch (pDevice->NumPalDevices()) + { + case 1: + pFunc = GetCmdPushDescriptorSet2KHRFunc<1>(pDevice); + break; +#if (VKI_BUILD_MAX_NUM_GPUS > 1) + case 2: + pFunc = GetCmdPushDescriptorSet2KHRFunc<2>(pDevice); + break; +#endif +#if (VKI_BUILD_MAX_NUM_GPUS > 2) + case 3: + pFunc = GetCmdPushDescriptorSet2KHRFunc<3>(pDevice); + break; +#endif +#if (VKI_BUILD_MAX_NUM_GPUS > 3) + case 4: + pFunc = GetCmdPushDescriptorSet2KHRFunc<4>(pDevice); + break; +#endif + default: + VK_NEVER_CALLED(); + break; + } + + return pFunc; +} + +// ===================================================================================================================== +PFN_vkCmdPushDescriptorSetWithTemplate2KHR CmdBuffer::GetCmdPushDescriptorSetWithTemplate2KHRFunc( + const Device* pDevice) +{ + PFN_vkCmdPushDescriptorSetWithTemplate2KHR pFunc = nullptr; + + switch (pDevice->NumPalDevices()) + { + case 1: + pFunc = CmdPushDescriptorSetWithTemplate2KHR<1>; + break; +#if (VKI_BUILD_MAX_NUM_GPUS > 1) + case 2: + pFunc = CmdPushDescriptorSetWithTemplate2KHR<2>; + break; +#endif +#if (VKI_BUILD_MAX_NUM_GPUS > 2) + case 3: + pFunc = CmdPushDescriptorSetWithTemplate2KHR<3>; + break; +#endif +#if (VKI_BUILD_MAX_NUM_GPUS > 3) + case 4: + pFunc = CmdPushDescriptorSetWithTemplate2KHR<4>; + break; +#endif + default: + VK_NEVER_CALLED(); + break; + } + + return pFunc; +} + // ===================================================================================================================== // Template instantiation needed for references entry.cpp. diff --git a/icd/api/vk_compute_pipeline.cpp b/icd/api/vk_compute_pipeline.cpp index 64a5e30c..55292c1b 100644 --- a/icd/api/vk_compute_pipeline.cpp +++ b/icd/api/vk_compute_pipeline.cpp @@ -211,7 +211,6 @@ VkResult ComputePipeline::Create( result = BuildShaderStageInfo(pDevice, 1, &pCreateInfo->stage, - false, [](const uint32_t inputIdx, const uint32_t stageIdx) { return 0u; diff --git a/icd/api/vk_device.cpp b/icd/api/vk_device.cpp index 17fc6b7e..ade98460 100644 --- a/icd/api/vk_device.cpp +++ b/icd/api/vk_device.cpp @@ -44,6 +44,7 @@ #include "include/vk_fence.h" #include "include/vk_formats.h" #include "include/vk_framebuffer.h" + #include "include/vk_pipeline_layout.h" #include "include/vk_physical_device.h" #include "include/vk_image.h" @@ -669,7 +670,6 @@ VkResult Device::Create( } break; } - default: break; } @@ -1449,6 +1449,13 @@ void Device::InitDispatchTable() ep->vkCmdPushDescriptorSetWithTemplateKHR = CmdBuffer::GetCmdPushDescriptorSetWithTemplateKHRFunc(this); } + if (m_enabledExtensions.IsExtensionEnabled(DeviceExtensions::KHR_MAINTENANCE6)) + { + ep->vkCmdBindDescriptorSets2KHR = CmdBuffer::GetCmdBindDescriptorSets2KHRFunc(this); + ep->vkCmdPushDescriptorSet2KHR = CmdBuffer::GetCmdPushDescriptorSet2KHRFunc(this); + ep->vkCmdPushDescriptorSetWithTemplate2KHR = CmdBuffer::GetCmdPushDescriptorSetWithTemplate2KHRFunc(this); + } + // ================================================================================================================= // After generic overrides, apply any internal layer specific dispatch table override. @@ -1853,13 +1860,12 @@ VkResult Device::CreateInternalComputePipeline( // Build shader module Vkgc::BinaryData spvBin = { codeByteSize, pCode }; + internalShaderFlags |= VK_INTERNAL_SHADER_FLAGS_INTERNAL_SHADER_BIT; result = pCompiler->BuildShaderModule( this, 0, internalShaderFlags, spvBin, - false, - true, &shaderModule); if (result == VK_SUCCESS) @@ -2910,6 +2916,14 @@ VkResult Device::BindBufferMemory( break; } + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: + { + const auto* pExtInfo = static_cast(pNext); + + pPerBindResult = pExtInfo->pResult; + break; + } + default: VK_NOT_IMPLEMENTED; break; @@ -2990,6 +3004,14 @@ VkResult Device::BindImageMemory( break; } + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: + { + const auto* pExtInfo = static_cast(pNext); + + pPerBindResult = pExtInfo->pResult; + break; + } + default: VK_NOT_IMPLEMENTED; break; diff --git a/icd/api/vk_dispatch.cpp b/icd/api/vk_dispatch.cpp index 7b3c87ef..5797d7e5 100644 --- a/icd/api/vk_dispatch.cpp +++ b/icd/api/vk_dispatch.cpp @@ -623,6 +623,8 @@ void DispatchTable::Init() INIT_DISPATCH_ALIAS(vkResetQueryPoolEXT , vkResetQueryPool ); INIT_DISPATCH_ENTRY(vkCmdSetLineStippleEXT ); + INIT_DISPATCH_ALIAS(vkCmdSetLineStippleKHR , + vkCmdSetLineStippleEXT ); INIT_DISPATCH_ENTRY(vkSetDeviceMemoryPriorityEXT ); INIT_DISPATCH_ENTRY(vkGetDeviceFaultInfoEXT ); @@ -823,6 +825,13 @@ void DispatchTable::Init() INIT_DISPATCH_ENTRY(vkGetImageSubresourceLayout2KHR ); INIT_DISPATCH_ENTRY(vkCmdBindIndexBuffer2KHR ); + INIT_DISPATCH_ENTRY(vkCmdBindDescriptorSets2KHR ); + INIT_DISPATCH_ENTRY(vkCmdPushConstants2KHR ); + INIT_DISPATCH_ENTRY(vkCmdPushDescriptorSet2KHR ); + INIT_DISPATCH_ENTRY(vkCmdPushDescriptorSetWithTemplate2KHR ); + INIT_DISPATCH_ENTRY(vkCmdSetDescriptorBufferOffsets2EXT ); + INIT_DISPATCH_ENTRY(vkCmdBindDescriptorBufferEmbeddedSamplers2EXT ); + } // ===================================================================================================================== diff --git a/icd/api/vk_graphics_pipeline.cpp b/icd/api/vk_graphics_pipeline.cpp index 39ea3dcb..61f8aa4e 100644 --- a/icd/api/vk_graphics_pipeline.cpp +++ b/icd/api/vk_graphics_pipeline.cpp @@ -58,6 +58,7 @@ namespace vk VkResult GraphicsPipeline::CreatePipelineBinaries( Device* pDevice, const VkGraphicsPipelineCreateInfo* pCreateInfo, + const GraphicsPipelineExtStructs& extStructs, VkPipelineCreateFlags2KHR flags, const GraphicsPipelineShaderStageInfo* pShaderInfo, const PipelineLayout* pPipelineLayout, @@ -125,6 +126,7 @@ VkResult GraphicsPipeline::CreatePipelineBinaries( result = pDefaultCompiler->ConvertGraphicsPipelineInfo( pDevice, pCreateInfo, + extStructs, flags, pShaderInfo, pPipelineLayout, @@ -162,6 +164,7 @@ VkResult GraphicsPipeline::CreatePipelineBinaries( result = pDefaultCompiler->ConvertGraphicsPipelineInfo( pDevice, pCreateInfo, + extStructs, flags, pShaderInfo, pPipelineLayout, @@ -639,6 +642,7 @@ VkResult GraphicsPipeline::Create( Device* pDevice, PipelineCache* pPipelineCache, const VkGraphicsPipelineCreateInfo* pCreateInfo, + const GraphicsPipelineExtStructs& extStructs, VkPipelineCreateFlags2KHR flags, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipeline) @@ -681,7 +685,7 @@ VkResult GraphicsPipeline::Create( { // If pipeline only contains PreRasterizationShaderLib and no fragment shader is in the create info, - // we add a null fragement library in order to use fast link. + // we add a null fragment library in order to use fast link. if ((libInfo.flags.isLibrary == false) && ((libInfo.pPreRasterizationShaderLib != nullptr) && (libInfo.pFragmentShaderLib == nullptr))) { @@ -704,7 +708,7 @@ VkResult GraphicsPipeline::Create( if (IsGplFastLinkPossible(libInfo)) { result = pDevice->GetCompiler(DefaultDeviceIndex)->BuildGplFastLinkCreateInfo( - pDevice, pCreateInfo, flags, libInfo, pPipelineLayout, &binaryMetadata, &binaryCreateInfo); + pDevice, pCreateInfo, extStructs, flags, libInfo, pPipelineLayout, &binaryMetadata, &binaryCreateInfo); if (result == VK_SUCCESS) { @@ -745,7 +749,11 @@ VkResult GraphicsPipeline::Create( pDevice->GetRuntimeSettings().enablePipelineDump || pDevice->GetRuntimeSettings().logTagIdMask) { - BuildApiHash(pCreateInfo, flags, &apiPsoHash, &elfHash); + BuildApiHash(pCreateInfo, + flags, + binaryCreateInfo, + &apiPsoHash, + &elfHash); binaryCreateInfo.apiPsoHash = apiPsoHash; } enableFastLink = true; @@ -759,7 +767,6 @@ VkResult GraphicsPipeline::Create( result = BuildShaderStageInfo(pDevice, pCreateInfo->stageCount, pCreateInfo->pStages, - Util::TestAnyFlagSet(flags, VK_PIPELINE_CREATE_LIBRARY_BIT_KHR), [](const uint32_t inputIdx, const uint32_t stageIdx) { return stageIdx; @@ -777,7 +784,11 @@ VkResult GraphicsPipeline::Create( } // 4. Build API and ELF hashes - BuildApiHash(pCreateInfo, flags, &apiPsoHash, &elfHash); + BuildApiHash(pCreateInfo, + flags, + binaryCreateInfo, + &apiPsoHash, + &elfHash); binaryCreateInfo.apiPsoHash = apiPsoHash; @@ -787,6 +798,7 @@ VkResult GraphicsPipeline::Create( result = CreatePipelineBinaries( pDevice, pCreateInfo, + extStructs, flags, &shaderStageInfo, pPipelineLayout, @@ -807,6 +819,7 @@ VkResult GraphicsPipeline::Create( BuildPipelineObjectCreateInfo( pDevice, pCreateInfo, + extStructs, flags, &pipelineOptimizerKey, &binaryMetadata, @@ -872,6 +885,7 @@ VkResult GraphicsPipeline::Create( &binaryCreateInfo, &shaderStageInfo, &objectCreateInfo, + extStructs, &elfHash); if (result == VK_SUCCESS) { @@ -1040,6 +1054,7 @@ VkResult GraphicsPipeline::BuildDeferCompileWorkload( GraphicsPipelineBinaryCreateInfo* pBinaryCreateInfo, GraphicsPipelineShaderStageInfo* pShaderStageInfo, GraphicsPipelineObjectCreateInfo* pObjectCreateInfo, + const GraphicsPipelineExtStructs& extStructs, Util::MetroHash::Hash* pElfHash) { VkResult result = VK_SUCCESS; @@ -1092,6 +1107,8 @@ VkResult GraphicsPipeline::BuildDeferCompileWorkload( pCreateInfo->shaderStageInfo = *pShaderStageInfo; pCreateInfo->binaryCreateInfo = *pBinaryCreateInfo; pCreateInfo->objectCreateInfo = *pObjectCreateInfo; + + pCreateInfo->extStructs = extStructs; pCreateInfo->elfHash = *pElfHash; pCreateInfo->binaryCreateInfo.pipelineInfo.enableEarlyCompile = false; @@ -1192,6 +1209,7 @@ void GraphicsPipeline::ExecuteDeferCreateOptimizedPipeline( &pCreateInfo->binaryCreateInfo, &pCreateInfo->shaderStageInfo, &pCreateInfo->objectCreateInfo, + pCreateInfo->extStructs, &pCreateInfo->elfHash); } @@ -1202,6 +1220,7 @@ VkResult GraphicsPipeline::DeferCreateOptimizedPipeline( GraphicsPipelineBinaryCreateInfo* pBinaryCreateInfo, GraphicsPipelineShaderStageInfo* pShaderStageInfo, GraphicsPipelineObjectCreateInfo* pObjectCreateInfo, + const GraphicsPipelineExtStructs& extStructs, Util::MetroHash::Hash* pElfHash) { VkResult result = VK_SUCCESS; @@ -1226,6 +1245,7 @@ VkResult GraphicsPipeline::DeferCreateOptimizedPipeline( { result = CreatePipelineBinaries(pDevice, nullptr, + extStructs, 0, pShaderStageInfo, nullptr, diff --git a/icd/api/vk_graphics_pipeline_library.cpp b/icd/api/vk_graphics_pipeline_library.cpp index 9f70f99f..d165ea87 100644 --- a/icd/api/vk_graphics_pipeline_library.cpp +++ b/icd/api/vk_graphics_pipeline_library.cpp @@ -315,8 +315,7 @@ VkResult GraphicsPipelineLibrary::CreatePartialPipelineBinary( const GraphicsPipelineShaderStageInfo* pShaderStageInfo, GraphicsPipelineBinaryCreateInfo* pBinaryCreateInfo, const VkAllocationCallbacks* pAllocator, - ShaderModuleHandle* pTempModules, - TempModuleState* pTempModuleStages) + GplModuleState* pTempModuleStages) { VkResult result = VK_SUCCESS; PipelineCompiler* pCompiler = pDevice->GetCompiler(DefaultDeviceIndex); @@ -335,27 +334,29 @@ VkResult GraphicsPipelineLibrary::CreatePartialPipelineBinary( &pBinaryCreateInfo->pipelineInfo.fs, }; + uint32_t gplMask = 0; for (uint32_t i = 0; i < ShaderStage::ShaderStageGfxCount; ++i) { if ((pShaderInfos[i]->pModuleData != nullptr) && (pShaderStageInfo->stages[i].pModuleHandle != nullptr) && pCompiler->IsValidShaderModule(pShaderStageInfo->stages[i].pModuleHandle)) { - VK_ASSERT(pShaderStageInfo->stages[i].pModuleHandle == &pTempModules[i]); + bool canBuildShader = (pShaderStageInfo->stages[i].stage != ShaderStage::ShaderStageFragment) || + (IsRasterizationDisabled(pCreateInfo, pLibInfo, dynamicStateFlags) == false); - bool canBuildShader = (((pShaderStageInfo->stages[i].stage == ShaderStage::ShaderStageFragment) && - IsRasterizationDisabled(pCreateInfo, pLibInfo, dynamicStateFlags)) - == false); + GraphicsLibraryType gplType = GetGraphicsLibraryType(pShaderStageInfo->stages[i].stage); + if (Util::TestAnyFlagSet(gplMask, 1 << gplType)) + { + continue; + } - if (canBuildShader && (result == VK_SUCCESS)) + if (canBuildShader) { // We don't take care of the result. Early compile failure in some cases is expected - result = pCompiler->CreateGraphicsShaderBinary( - pDevice, pPipelineCache, pShaderStageInfo->stages[i].stage, pBinaryCreateInfo, &pTempModules[i]); + pCompiler->CreateGraphicsShaderBinary( + pDevice, pPipelineCache, gplType, pBinaryCreateInfo, &pTempModuleStages[i]); + gplMask |= (1 << gplType); } - - pTempModuleStages[i].stage = pShaderStageInfo->stages[i].stage; - pTempModuleStages[i].freeBinaryOnly = false; } } @@ -365,60 +366,37 @@ VkResult GraphicsPipelineLibrary::CreatePartialPipelineBinary( if ((pLibInfo->libFlags & VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT) && (pLibInfo->pPreRasterizationShaderLib != nullptr)) { - const ShaderModuleHandle* pParentHandle = - pLibInfo->pPreRasterizationShaderLib->GetShaderModuleHandle(ShaderStage::ShaderStageVertex); - // Parent library may not have vertex shader if it uses mesh shader. - if ((pParentHandle != nullptr) && (result == VK_SUCCESS)) - { - constexpr uint32_t TempIdx = ShaderStage::ShaderStageVertex; + constexpr uint32_t TempIdx = ShaderStage::ShaderStageVertex; - pBinaryCreateInfo->pipelineInfo.enableUberFetchShader = false; + pBinaryCreateInfo->pipelineInfo.enableUberFetchShader = false; + pBinaryCreateInfo->pShaderLibraries[GraphicsLibraryPreRaster] = nullptr; - pTempModules[TempIdx] = *pParentHandle; - - result = pCompiler->CreateGraphicsShaderBinary( - pDevice, pPipelineCache, ShaderStage::ShaderStageVertex, pBinaryCreateInfo, &pTempModules[TempIdx]); - - pTempModuleStages[TempIdx].stage = ShaderStage::ShaderStageVertex; - pTempModuleStages[TempIdx].freeBinaryOnly = true; - } + VK_ASSERT(pTempModuleStages[TempIdx].elfPackage.codeSize == 0); + result = pCompiler->CreateGraphicsShaderBinary( + pDevice, pPipelineCache, GraphicsLibraryPreRaster, pBinaryCreateInfo, &pTempModuleStages[TempIdx]); } if ((pLibInfo->libFlags & VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT) && - (pLibInfo->pFragmentShaderLib != nullptr)) + (pLibInfo->pFragmentShaderLib != nullptr) && + (result == VK_SUCCESS)) { - const ShaderModuleHandle* pParentHandle = - pLibInfo->pFragmentShaderLib->GetShaderModuleHandle(ShaderStage::ShaderStageFragment); + constexpr uint32_t TempIdx = ShaderStage::ShaderStageFragment; - VK_ASSERT(pParentHandle != nullptr); + VK_ASSERT(pTempModuleStages[TempIdx].elfPackage.codeSize == 0); - if ((pParentHandle != nullptr) && (result == VK_SUCCESS)) - { - constexpr uint32_t TempIdx = ShaderStage::ShaderStageFragment; - - pTempModules[TempIdx] = *pParentHandle; - - result = pCompiler->CreateGraphicsShaderBinary(pDevice, pPipelineCache, - ShaderStage::ShaderStageFragment, pBinaryCreateInfo, &pTempModules[TempIdx]); - - pTempModuleStages[TempIdx].stage = ShaderStage::ShaderStageFragment; - pTempModuleStages[TempIdx].freeBinaryOnly = true; - } + result = pCompiler->CreateGraphicsShaderBinary(pDevice, pPipelineCache, + GraphicsLibraryFragment, pBinaryCreateInfo, &pTempModuleStages[TempIdx]); } } - for (uint32_t stage = 0; (result == VK_SUCCESS) && (stage < ShaderStage::ShaderStageGfxCount); ++stage) + // Create shader libraries for fast-link + if (pDevice->GetRuntimeSettings().useShaderLibraryForPipelineLibraryFastLink) { - if (pCompiler->IsValidShaderModule(&pTempModules[stage]) == false) - { - pTempModuleStages[stage].stage = ShaderStage::ShaderStageInvalid; - } - else if (pDevice->GetRuntimeSettings().useShaderLibraryForPipelineLibraryFastLink) + for (uint32_t stage = 0; (result == VK_SUCCESS) && (stage < ShaderStage::ShaderStageGfxCount); ++stage) { - // Create shader libraries for fast-link GraphicsLibraryType gplType = GetGraphicsLibraryType(static_cast(stage)); - if ((pBinaryCreateInfo->earlyElfPackage[gplType].codeSize != 0) && + if ((pBinaryCreateInfo->earlyElfPackage[gplType].pCode != nullptr) && (pBinaryCreateInfo->pShaderLibraries[gplType] == nullptr)) { Vkgc::BinaryData palElfBinary = {}; @@ -429,12 +407,16 @@ VkResult GraphicsPipelineLibrary::CreatePartialPipelineBinary( palElfBinary, pAllocator, &pBinaryCreateInfo->pShaderLibraries[gplType]); + pBinaryCreateInfo->earlyElfPackage[gplType].pCode = nullptr; + } + + if (pTempModuleStages[stage].elfPackage.codeSize > 0) + { + pDevice->VkInstance()->FreeMem(const_cast(pTempModuleStages[stage].elfPackage.pCode)); + pTempModuleStages[stage].elfPackage = {}; } } - } - if (pDevice->GetRuntimeSettings().useShaderLibraryForPipelineLibraryFastLink) - { // If there is no fragment shader when create fragment library, we use a null pal graphics library. if ((pLibInfo->libFlags & VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT) && (pBinaryCreateInfo->pipelineInfo.fs.pModuleData == nullptr)) @@ -453,6 +435,7 @@ VkResult GraphicsPipelineLibrary::Create( Device* pDevice, PipelineCache* pPipelineCache, const VkGraphicsPipelineCreateInfo* pCreateInfo, + const GraphicsPipelineExtStructs& extStructs, VkPipelineCreateFlags2KHR flags, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipeline) @@ -468,18 +451,17 @@ VkResult GraphicsPipelineLibrary::Create( GraphicsPipelineBinaryCreateInfo binaryCreateInfo = {}; GraphicsPipelineShaderStageInfo shaderStageInfo = {}; - ShaderModuleHandle tempModules[ShaderStage::ShaderStageGfxCount] = {}; - TempModuleState tempModuleStates[ShaderStage::ShaderStageGfxCount] = {}; + GplModuleState tempModuleStates[ShaderStage::ShaderStageGfxCount] = {}; binaryCreateInfo.pipelineInfo.iaState.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; // 1. Build shader stage infos if (result == VK_SUCCESS) { + ShaderModuleHandle tempModules[ShaderStage::ShaderStageGfxCount] = {}; result = BuildShaderStageInfo(pDevice, pCreateInfo->stageCount, pCreateInfo->pStages, - Util::TestAnyFlagSet(flags, VK_PIPELINE_CREATE_LIBRARY_BIT_KHR), [](const uint32_t inputIdx, const uint32_t stageIdx) { return stageIdx; @@ -488,6 +470,24 @@ VkResult GraphicsPipelineLibrary::Create( tempModules, pPipelineCache, binaryCreateInfo.stageFeedback); + + // Initialize tempModuleStates + for (uint32_t stage = 0; stage < ShaderStage::ShaderStageGfxCount; stage++) + { + if (shaderStageInfo.stages[stage].pModuleHandle != nullptr) + { + tempModuleStates[stage].stage = static_cast(stage); + } + else + { + tempModuleStates[stage].stage = ShaderStageInvalid; + } + + if (pDevice->GetCompiler(DefaultDeviceIndex)->IsValidShaderModule(&tempModules[stage])) + { + tempModuleStates[stage].moduleHandle = tempModules[stage]; + } + } } // 2. Build ShaderOptimizer pipeline key @@ -511,7 +511,11 @@ VkResult GraphicsPipelineLibrary::Create( // 3. Build API and ELF hashes uint64_t apiPsoHash = {}; Util::MetroHash::Hash elfHash = {}; - BuildApiHash(pCreateInfo, flags, &apiPsoHash, &elfHash); + BuildApiHash(pCreateInfo, + flags, + binaryCreateInfo, + &apiPsoHash, + &elfHash); binaryCreateInfo.apiPsoHash = apiPsoHash; // 4. Get pipeline layout @@ -529,6 +533,7 @@ VkResult GraphicsPipelineLibrary::Create( result = pDevice->GetCompiler(DefaultDeviceIndex)->ConvertGraphicsPipelineInfo( pDevice, pCreateInfo, + extStructs, flags, &shaderStageInfo, pPipelineLayout, @@ -549,7 +554,6 @@ VkResult GraphicsPipelineLibrary::Create( &shaderStageInfo, &binaryCreateInfo, pAllocator, - tempModules, tempModuleStates); } @@ -562,6 +566,7 @@ VkResult GraphicsPipelineLibrary::Create( BuildPipelineObjectCreateInfo( pDevice, pCreateInfo, + extStructs, flags, &pipelineOptimizerKey, &binaryMetadata, @@ -595,7 +600,6 @@ VkResult GraphicsPipelineLibrary::Create( libInfo, elfHash, apiPsoHash, - tempModules, tempModuleStates, pPipelineLayout); @@ -646,18 +650,12 @@ VkResult GraphicsPipelineLibrary::Destroy( uint32_t libraryMask = 0; for (uint32_t i = 0; i < ShaderStage::ShaderStageGfxCount; ++i) { - if (m_tempModuleStates[i].stage != ShaderStage::ShaderStageInvalid) + if (m_gplModuleStates[i].stage != ShaderStage::ShaderStageInvalid) { - if (m_tempModuleStates[i].freeBinaryOnly) - { - PipelineCompiler::FreeGraphicsShaderBinary(m_tempModules + i); - } - else - { - pCompiler->FreeShaderModule(m_tempModules + i); - } - libraryMask |= (1 << GetGraphicsLibraryType(m_tempModuleStates[i].stage)); + libraryMask |= (1 << GetGraphicsLibraryType(m_gplModuleStates[i].stage)); } + + pCompiler->FreeGplModuleState(&m_gplModuleStates[i]); } for (uint32_t i = 0; i < ArrayLen(m_pBinaryCreateInfo->pShaderLibraries); ++i) @@ -688,8 +686,7 @@ GraphicsPipelineLibrary::GraphicsPipelineLibrary( const GraphicsPipelineLibraryInfo& libInfo, const Util::MetroHash::Hash& elfHash, const uint64_t apiHash, - const ShaderModuleHandle* pTempModules, - const TempModuleState* pTempModuleStates, + const GplModuleState* pGplModuleStates, const PipelineLayout* pPipelineLayout) #if VKI_RAY_TRACING : GraphicsPipelineCommon(false, pDevice), @@ -712,66 +709,7 @@ GraphicsPipelineLibrary::GraphicsPipelineLibrary( dummyCacheHash, apiHash); - memcpy(m_tempModules, pTempModules, ShaderStage::ShaderStageGfxCount * sizeof(ShaderModuleHandle)); - memcpy(m_tempModuleStates, pTempModuleStates, ShaderStage::ShaderStageGfxCount * sizeof(TempModuleState)); -} - -// ===================================================================================================================== -const ShaderModuleHandle* GraphicsPipelineLibrary::GetShaderModuleHandle( - const ShaderStage stage - ) const -{ - const ShaderModuleHandle* pHandle = nullptr; - VkGraphicsPipelineLibraryFlagsEXT libFlag = 0; - - switch (stage) - { - case ShaderStage::ShaderStageTask: - case ShaderStage::ShaderStageVertex: - case ShaderStage::ShaderStageTessControl: - case ShaderStage::ShaderStageTessEval: - case ShaderStage::ShaderStageGeometry: - case ShaderStage::ShaderStageMesh: - libFlag = VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT; - break; - case ShaderStage::ShaderStageFragment: - libFlag = VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT; - break; - default: - VK_NEVER_CALLED(); - break; - } - - // Find shader module handle from temp modules in current library - if (libFlag & m_libInfo.libFlags) - { - for (uint32_t i = 0; i < ShaderStage::ShaderStageGfxCount; ++i) - { - if (stage == m_tempModuleStates[i].stage) - { - pHandle = m_tempModules + i; - break; - } - else if (ShaderStageInvalid == m_tempModuleStates[i].stage) - { - break; - } - } - } - // Find the shader module handle from parent library - else if (libFlag & (m_pBinaryCreateInfo->libFlags & ~m_libInfo.libFlags)) - { - if (libFlag == VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT) - { - pHandle = m_libInfo.pPreRasterizationShaderLib->GetShaderModuleHandle(stage); - } - else if (libFlag == VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT) - { - pHandle = m_libInfo.pFragmentShaderLib->GetShaderModuleHandle(stage); - } - } - - return pHandle; + memcpy(m_gplModuleStates, pGplModuleStates, ShaderStage::ShaderStageGfxCount * sizeof(GplModuleState)); } // ===================================================================================================================== @@ -782,9 +720,9 @@ void GraphicsPipelineLibrary::GetOwnedPalShaderLibraries( uint32_t libraryMask = 0; for (uint32_t i = 0; i < ShaderStage::ShaderStageGfxCount; ++i) { - if (m_tempModuleStates[i].stage != ShaderStage::ShaderStageInvalid) + if (m_gplModuleStates[i].stage != ShaderStage::ShaderStageInvalid) { - libraryMask |= (1 << GetGraphicsLibraryType(m_tempModuleStates[i].stage)); + libraryMask |= (1 << GetGraphicsLibraryType(m_gplModuleStates[i].stage)); } } @@ -801,5 +739,4 @@ void GraphicsPipelineLibrary::GetOwnedPalShaderLibraries( } } } - } diff --git a/icd/api/vk_memory.cpp b/icd/api/vk_memory.cpp index 3bed7a4b..4b99eb59 100644 --- a/icd/api/vk_memory.cpp +++ b/icd/api/vk_memory.cpp @@ -939,7 +939,8 @@ Memory::Memory( m_sharedGpuMemoryHandle(sharedGpuMemoryHandle), m_priority(info.priority, info.priorityOffset), m_sizeAccountedForDeviceMask(0), - m_primaryDeviceIndex(primaryIndex) + m_primaryDeviceIndex(primaryIndex), + m_mappedPointer(nullptr) { m_size = info.size; m_heap0 = info.heaps[0]; @@ -962,7 +963,8 @@ Memory::Memory( m_pExternalPalImage(nullptr), m_sharedGpuMemoryHandle(0), m_sizeAccountedForDeviceMask(0), - m_primaryDeviceIndex(primaryIndex) + m_primaryDeviceIndex(primaryIndex), + m_mappedPointer(nullptr) { // PAL info is not available for memory objects allocated for presentable images m_size = 0; @@ -1007,6 +1009,12 @@ void Memory::Free( Pal::IDevice* pPalDevice = pDevice->PalDevice(i); pDevice->RemoveMemReference(pPalDevice, pGpuMemory); + if (m_mappedPointer != nullptr) + { + pGpuMemory->Unmap(); + m_mappedPointer = nullptr; + } + // Destroy PAL memory object pGpuMemory->Destroy(); @@ -1156,6 +1164,7 @@ Pal::OsExternalHandle Memory::GetShareHandle( // ===================================================================================================================== // Map GPU memory into client address space. Simply calls through to PAL. VkResult Memory::Map( + Device* pDevice, VkFlags flags, VkDeviceSize offset, VkDeviceSize size, @@ -1163,6 +1172,8 @@ VkResult Memory::Map( { VkResult result = VK_SUCCESS; + const RuntimeSettings& settings = pDevice->GetRuntimeSettings(); + // According to spec, "memory must not have been allocated with multiple instances" // if it is multi-instance allocation, we should just return VK_ERROR_MEMORY_MAP_FAILED if (m_flags.multiInstance == 0) @@ -1172,13 +1183,24 @@ VkResult Memory::Map( { void* pData; - palResult = PalMemory(m_primaryDeviceIndex)->Map(&pData); - - if (palResult == Pal::Result::Success) + if (m_mappedPointer != nullptr) + { + pData = m_mappedPointer; + } + else { - *ppData = Util::VoidPtrInc(pData, static_cast(offset)); + palResult = PalMemory(m_primaryDeviceIndex)->Map(&pData); + if (palResult == Pal::Result::Success) + { + if (settings.skipUnMapMemory) + { + m_mappedPointer = pData; + } + } } + + *ppData = Util::VoidPtrInc(pData, static_cast(offset)); result = (palResult == Pal::Result::Success) ? VK_SUCCESS : VK_ERROR_MEMORY_MAP_FAILED; } else @@ -1202,8 +1224,11 @@ void Memory::Unmap(void) VK_ASSERT(m_flags.multiInstance == 0); - palResult = PalMemory(m_primaryDeviceIndex)->Unmap(); - VK_ASSERT(palResult == Pal::Result::Success); + if (m_mappedPointer == nullptr) + { + palResult = PalMemory(m_primaryDeviceIndex)->Unmap(); + VK_ASSERT(palResult == Pal::Result::Success); + } } // ===================================================================================================================== @@ -1438,7 +1463,9 @@ VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( VkMemoryMapFlags flags, void** ppData) { - return Memory::ObjectFromHandle(memory)->Map(flags, offset, size, ppData); + Device* pDevice = ApiDevice::ObjectFromHandle(device); + + return Memory::ObjectFromHandle(memory)->Map(pDevice, flags, offset, size, ppData); } // ===================================================================================================================== @@ -1455,7 +1482,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory2KHR( const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData) { + Device* pDevice = ApiDevice::ObjectFromHandle(device); + return Memory::ObjectFromHandle(pMemoryMapInfo->memory)->Map( + pDevice, pMemoryMapInfo->flags, pMemoryMapInfo->offset, pMemoryMapInfo->size, diff --git a/icd/api/vk_physical_device.cpp b/icd/api/vk_physical_device.cpp index 04ced74f..745767e9 100644 --- a/icd/api/vk_physical_device.cpp +++ b/icd/api/vk_physical_device.cpp @@ -4153,6 +4153,7 @@ DeviceExtensions::Supported PhysicalDevice::GetAvailableExtensions( availableExtensions.AddExtension(VK_DEVICE_EXTENSION(KHR_SHADER_FLOAT_CONTROLS)); availableExtensions.AddExtension(VK_DEVICE_EXTENSION(KHR_CREATE_RENDERPASS2)); availableExtensions.AddExtension(VK_DEVICE_EXTENSION(EXT_CALIBRATED_TIMESTAMPS)); + availableExtensions.AddExtension(VK_DEVICE_EXTENSION(KHR_CALIBRATED_TIMESTAMPS)); availableExtensions.AddExtension(VK_DEVICE_EXTENSION(EXT_HDR_METADATA)); availableExtensions.AddExtension(VK_DEVICE_EXTENSION(EXT_SAMPLE_LOCATIONS)); @@ -4353,6 +4354,13 @@ DeviceExtensions::Supported PhysicalDevice::GetAvailableExtensions( availableExtensions.AddExtension(VK_DEVICE_EXTENSION(EXT_BORDER_COLOR_SWIZZLE)); } +#if VKI_BUILD_GFX11 + if ((pPhysicalDevice == nullptr) || (pPhysicalDevice->PalProperties().gfxLevel >= Pal::GfxIpLevel::GfxIp11_0)) + { + availableExtensions.AddExtension(VK_DEVICE_EXTENSION(EXT_PRIMITIVES_GENERATED_QUERY)); + } +#endif + if (IsKhrCooperativeMatrixSupported(pPhysicalDevice)) { availableExtensions.AddExtension(VK_DEVICE_EXTENSION(KHR_COOPERATIVE_MATRIX)); @@ -4370,7 +4378,13 @@ DeviceExtensions::Supported PhysicalDevice::GetAvailableExtensions( availableExtensions.AddExtension(VK_DEVICE_EXTENSION(NV_COMPUTE_SHADER_DERIVATIVES)); } + if ((pPhysicalDevice == nullptr) || (pPhysicalDevice->GetRuntimeSettings().enableGraphicsPipelineLibraries)) + { + availableExtensions.AddExtension(VK_DEVICE_EXTENSION(EXT_GRAPHICS_PIPELINE_LIBRARY)); + } + availableExtensions.AddExtension(VK_DEVICE_EXTENSION(KHR_MAINTENANCE5)); + availableExtensions.AddExtension(VK_DEVICE_EXTENSION(KHR_MAINTENANCE6)); availableExtensions.AddExtension(VK_DEVICE_EXTENSION(KHR_PUSH_DESCRIPTOR)); @@ -4400,6 +4414,19 @@ DeviceExtensions::Supported PhysicalDevice::GetAvailableExtensions( availableExtensions.AddExtension(VK_DEVICE_EXTENSION(EXT_VERTEX_INPUT_DYNAMIC_STATE)); + availableExtensions.AddExtension(VK_DEVICE_EXTENSION(KHR_SHADER_EXPECT_ASSUME)); + + availableExtensions.AddExtension(VK_DEVICE_EXTENSION(KHR_SHADER_SUBGROUP_ROTATE)); + + availableExtensions.AddExtension(VK_DEVICE_EXTENSION(KHR_SHADER_FLOAT_CONTROLS2)); + + availableExtensions.AddExtension(VK_DEVICE_EXTENSION(KHR_SHADER_QUAD_CONTROL)); + + availableExtensions.AddExtension(VK_DEVICE_EXTENSION(KHR_VERTEX_ATTRIBUTE_DIVISOR)); + availableExtensions.AddExtension(VK_DEVICE_EXTENSION(KHR_INDEX_TYPE_UINT8)); + availableExtensions.AddExtension(VK_DEVICE_EXTENSION(KHR_LINE_RASTERIZATION)); + availableExtensions.AddExtension(VK_DEVICE_EXTENSION(KHR_LOAD_STORE_OP_NONE)); + bool disableAMDVendorExtensions = false; if (pPhysicalDevice != nullptr) { @@ -4998,7 +5025,9 @@ void PhysicalDevice::GetPhysicalDeviceSubgroupProperties( VK_SUBGROUP_FEATURE_CLUSTERED_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT | - VK_SUBGROUP_FEATURE_QUAD_BIT; + VK_SUBGROUP_FEATURE_QUAD_BIT | + VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR | + VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR; *pQuadOperationsInAllStages = VK_TRUE; } @@ -6930,6 +6959,19 @@ size_t PhysicalDevice::GetFeatures2( break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: + { + auto* pExtInfo = reinterpret_cast(pHeader); + + if (updateFeatures) + { + pExtInfo->maintenance6 = VK_TRUE; + } + + structSize = sizeof(*pExtInfo); + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: { auto* pExtInfo = reinterpret_cast(pHeader); @@ -7127,6 +7169,32 @@ size_t PhysicalDevice::GetFeatures2( break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: + { + auto* pExtInfo = reinterpret_cast(pHeader); + + if (updateFeatures) + { + pExtInfo->shaderMaximalReconvergence = VK_TRUE; + } + + structSize = sizeof(*pExtInfo); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR: + { + auto* pExtInfo = reinterpret_cast(pHeader); + + if (updateFeatures) + { + pExtInfo->shaderFloatControls2 = VK_TRUE; + } + + structSize = sizeof(*pExtInfo); + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: { auto* pExtInfo = reinterpret_cast(pHeader); @@ -7224,6 +7292,43 @@ size_t PhysicalDevice::GetFeatures2( break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR: + { + auto* pExtInfo = reinterpret_cast(pHeader); + if (updateFeatures) + { + pExtInfo->shaderExpectAssume = VK_TRUE; + } + + structSize = sizeof(*pExtInfo); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR: + { + auto* pExtInfo = reinterpret_cast(pHeader); + if (updateFeatures) + { + pExtInfo->shaderSubgroupRotate = VK_TRUE; + pExtInfo->shaderSubgroupRotateClustered = VK_TRUE; + } + + structSize = sizeof(*pExtInfo); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: + { + auto* pExtInfo = reinterpret_cast(pHeader); + if (updateFeatures) + { + pExtInfo->shaderQuadControl = VK_TRUE; + } + + structSize = sizeof(*pExtInfo); + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: { auto* pExtInfo = reinterpret_cast(pHeader); @@ -7653,7 +7758,7 @@ void PhysicalDevice::GetDeviceProperties2( pProps->transformFeedbackDraw = VK_TRUE; pProps->transformFeedbackQueries = VK_TRUE; pProps->transformFeedbackStreamsLinesTriangles = VK_TRUE; - pProps->transformFeedbackRasterizationStreamSelect = VK_FALSE; + pProps->transformFeedbackRasterizationStreamSelect = VK_TRUE; break; } @@ -8096,6 +8201,16 @@ void PhysicalDevice::GetDeviceProperties2( break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: + { + auto* pProps = static_cast(pNext); + + pProps->blockTexelViewCompatibleMultipleLayers = VK_TRUE; + pProps->maxCombinedImageSamplerDescriptorCount = MaxCombinedImageSamplerDescriptorCount; + pProps->fragmentShadingRateClampCombinerInputs = VK_TRUE; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: { auto* pProps = static_cast(pNext); @@ -8228,6 +8343,7 @@ void PhysicalDevice::GetDeviceProperties2( break; } #endif + default: break; } diff --git a/icd/api/vk_pipeline.cpp b/icd/api/vk_pipeline.cpp index cf35dad4..0b1c5758 100644 --- a/icd/api/vk_pipeline.cpp +++ b/icd/api/vk_pipeline.cpp @@ -254,7 +254,6 @@ VkResult Pipeline::BuildShaderStageInfo( const Device* pDevice, const uint32_t stageCount, const VkPipelineShaderStageCreateInfo* pStages, - const bool isLibrary, uint32_t (*pfnGetOutputIdx)(const uint32_t inputIdx, const uint32_t stageIdx), ShaderStageInfo* pShaderStageInfo, @@ -268,9 +267,6 @@ VkResult Pipeline::BuildShaderStageInfo( uint32_t maxOutIdx = 0; - const bool duplicateExistingModules = isLibrary; - const bool adaptForFastLink = isLibrary; - for (uint32_t i = 0; i < stageCount; ++i) { const VkPipelineShaderStageCreateInfo& stageInfo = pStages[i]; @@ -291,7 +287,7 @@ VkResult Pipeline::BuildShaderStageInfo( pPipelineShaderStageRequiredSubgroupSizeCreateInfo->requiredSubgroupSize; } - if ((stageInfo.module != VK_NULL_HANDLE) && (duplicateExistingModules == false)) + if (stageInfo.module != VK_NULL_HANDLE) { const ShaderModule* pModule = ShaderModule::ObjectFromHandle(stageInfo.module); @@ -321,28 +317,18 @@ VkResult Pipeline::BuildShaderStageInfo( SHADER_MODULE_CREATE_INFO, PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT); - if (stageInfo.module != VK_NULL_HANDLE) - { - // Shader needs to be recompiled with additional options for compatibility with fast-link mode - const ShaderModule* pModule = ShaderModule::ObjectFromHandle(stageInfo.module); - shaderBinary.codeSize = pModule->GetCodeSize(); - shaderBinary.pCode = pModule->GetCode(); - } - else - { - VK_ASSERT((pShaderModuleCreateInfo != nullptr)|| - (pPipelineShaderStageModuleIdentifierCreateInfoEXT != nullptr)); + VK_ASSERT((pShaderModuleCreateInfo != nullptr) || + (pPipelineShaderStageModuleIdentifierCreateInfoEXT != nullptr)); - if (pShaderModuleCreateInfo != nullptr) - { - flags = pShaderModuleCreateInfo->flags; - shaderBinary.codeSize = pShaderModuleCreateInfo->codeSize; - shaderBinary.pCode = pShaderModuleCreateInfo->pCode; + if (pShaderModuleCreateInfo != nullptr) + { + flags = pShaderModuleCreateInfo->flags; + shaderBinary.codeSize = pShaderModuleCreateInfo->codeSize; + shaderBinary.pCode = pShaderModuleCreateInfo->pCode; - codeHash = ShaderModule::BuildCodeHash( - shaderBinary.pCode, - shaderBinary.codeSize); - } + codeHash = ShaderModule::BuildCodeHash( + shaderBinary.pCode, + shaderBinary.codeSize); } if (shaderBinary.pCode != nullptr) @@ -352,8 +338,6 @@ VkResult Pipeline::BuildShaderStageInfo( flags, VK_INTERNAL_SHADER_FLAGS_FORCE_UNCACHED_BIT, shaderBinary, - adaptForFastLink, - false, &pTempModules[outIdx]); pShaderStageInfo[outIdx].pModuleHandle = &pTempModules[outIdx]; @@ -521,9 +505,10 @@ bool Pipeline::GetBinary( bool result = false; if (PalPipeline(DefaultDeviceIndex) != nullptr) { - pBinaryInfo->binaryHash = m_cacheHash; - pBinaryInfo->pBinary = - PalPipeline(DefaultDeviceIndex)->GetCodeObjectWithShaderType(shaderType, &pBinaryInfo->binaryByteSize); + pBinaryInfo->binaryHash = m_cacheHash; + pBinaryInfo->pipelineBinary.pCode = + PalPipeline(DefaultDeviceIndex)->GetCodeObjectWithShaderType(shaderType, + &pBinaryInfo->pipelineBinary.codeSize); result = true; } return result; @@ -538,13 +523,13 @@ VkResult Pipeline::GetShaderDisassembly( size_t* pBufferSize, void* pBuffer) const { - PipelineBinaryInfo pipelineBinary = {}; + PipelineBinaryInfo binaryInfo = {}; - bool hasPipelineBinary = GetBinary(shaderType, &pipelineBinary); + bool hasPipelineBinary = GetBinary(shaderType, &binaryInfo); if (hasPipelineBinary == false) { - // The pipelineBinary will be null if the pipeline wasn't created with + // The pipeline binary will be null if the pipeline wasn't created with // VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR or for shader // module identifier return VK_ERROR_UNKNOWN; @@ -552,7 +537,7 @@ VkResult Pipeline::GetShaderDisassembly( // To extract the shader code, we can re-parse the saved ELF binary and lookup the shader's program // instructions by examining the symbol table entry for that shader's entrypoint. - Util::Abi::PipelineAbiReader abiReader(pDevice->VkInstance()->Allocator(), pipelineBinary.pBinary); + Util::Abi::PipelineAbiReader abiReader(pDevice->VkInstance()->Allocator(), binaryInfo.pipelineBinary.pCode); VkResult result = VK_SUCCESS; Pal::Result palResult = abiReader.Init(); @@ -768,11 +753,11 @@ uint32_t Pipeline::GetAvailableAmdIlSymbol( Util::BitMaskScanForward(&firstShaderStage, shaderStageMask); Pal::ShaderType shaderType = static_cast(firstShaderStage); - PipelineBinaryInfo pipelineBinary = {}; - bool hasBinary = GetBinary(shaderType, &pipelineBinary); + PipelineBinaryInfo binaryInfo = {}; + bool hasBinary = GetBinary(shaderType, &binaryInfo); if (hasBinary) { - Util::Abi::PipelineAbiReader abiReader(m_pDevice->VkInstance()->Allocator(), pipelineBinary.pBinary); + Util::Abi::PipelineAbiReader abiReader(m_pDevice->VkInstance()->Allocator(), binaryInfo.pipelineBinary.pCode); Pal::Result result = abiReader.Init(); if (result == Pal::Result::Success) @@ -941,19 +926,19 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD( PipelineBinaryInfo binaryInfo = {}; bool hasBinary = pPipeline->GetBinary(shaderType, &binaryInfo); - if (hasBinary && (binaryInfo.pBinary != nullptr)) + if (hasBinary && (binaryInfo.pipelineBinary.pCode != nullptr)) { if (pBuffer != nullptr) { - const size_t copySize = Util::Min(*pBufferSize, binaryInfo.binaryByteSize); + const size_t copySize = Util::Min(*pBufferSize, binaryInfo.pipelineBinary.codeSize); - memcpy(pBuffer, binaryInfo.pBinary, copySize); + memcpy(pBuffer, binaryInfo.pipelineBinary.pCode, copySize); - result = (copySize == binaryInfo.binaryByteSize) ? VK_SUCCESS : VK_INCOMPLETE; + result = (copySize == binaryInfo.pipelineBinary.codeSize) ? VK_SUCCESS : VK_INCOMPLETE; } else { - *pBufferSize = binaryInfo.binaryByteSize; + *pBufferSize = binaryInfo.pipelineBinary.codeSize; result = VK_SUCCESS; } diff --git a/icd/api/vk_shader.cpp b/icd/api/vk_shader.cpp index 973915a4..a72164f3 100644 --- a/icd/api/vk_shader.cpp +++ b/icd/api/vk_shader.cpp @@ -213,8 +213,6 @@ VkResult ShaderModule::Init( m_flags, 0, shaderBinary, - false, - false, &m_handle); if (result == VK_SUCCESS) diff --git a/icd/res/ver.h b/icd/res/ver.h index af2f5272..37b3a9db 100644 --- a/icd/res/ver.h +++ b/icd/res/ver.h @@ -36,7 +36,7 @@ #define VERSION_MAJOR_STR MAKE_VERSION_STRING(VULKAN_ICD_MAJOR_VERSION) "\0" // Bump up after each promotion to mainline -#define VULKAN_ICD_BUILD_VERSION 297 +#define VULKAN_ICD_BUILD_VERSION 299 // String version is needed with leading zeros and extra termination (unicode) #define VERSION_NUMBER_MINOR VULKAN_ICD_BUILD_VERSION @@ -45,7 +45,7 @@ // These values specify the driver ID and driver info string #define VULKAN_DRIVER_ID VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR // "AMDOPEN" #define VULKAN_DRIVER_NAME_STR "AMD open-source driver" -#define VULKAN_DRIVER_INFO_STR "2024.Q1.1" +#define VULKAN_DRIVER_INFO_STR "2024.Q1.2" #define VULKAN_DRIVER_INFO_STR_LLPC "(LLPC)" // These values tell which version of the conformance test the driver is compliant against diff --git a/icd/settings/settings.cpp b/icd/settings/settings.cpp index c7d4d1c3..0e4b3430 100644 --- a/icd/settings/settings.cpp +++ b/icd/settings/settings.cpp @@ -496,13 +496,10 @@ VkResult VulkanSettingsLoader::OverrideProfiledSettings( // Disable image type checking on Navi10 to avoid 2% loss. m_settings.disableImageResourceTypeCheck = true; - m_settings.enableGraphicsPipelineLibraries = true; } if (appProfile == AppProfile::CSGO) { - m_settings.enableGraphicsPipelineLibraries = true; - if (pInfo->gfxLevel == Pal::GfxIpLevel::GfxIp10_3) { @@ -866,6 +863,8 @@ VkResult VulkanSettingsLoader::OverrideProfiledSettings( } m_settings.ac01WaNotNeeded = true; + + m_settings.disable3dLinearImageFormatSupport = false; } if (appProfile == AppProfile::GhostReconBreakpoint) @@ -946,8 +945,6 @@ VkResult VulkanSettingsLoader::OverrideProfiledSettings( { m_settings.disableDisplayDcc = DisplayableDcc::DisplayableDccDisabled; - m_settings.rtEnableTriangleSplitting = true; - m_settings.rtTriangleCompressionMode = NoTriangleCompression; m_settings.useFlipHint = false; @@ -1134,6 +1131,7 @@ VkResult VulkanSettingsLoader::OverrideProfiledSettings( { m_settings.resourceBarrierOptions &= ~ResourceBarrierOptions::AvoidCpuMemoryCoher; } + m_settings.skipUnMapMemory = true; } if (appProfile == AppProfile::WarThunder) @@ -1360,6 +1358,20 @@ VkResult VulkanSettingsLoader::OverrideProfiledSettings( m_settings.disableSingleMipAnisoOverride = false; } + if (appProfile == AppProfile::DXVK) + { + m_settings.enableGraphicsPipelineLibraries = false; + } + + if (appProfile == AppProfile::Enshrouded) + { +#if VKI_BUILD_GFX11 + if (pInfo->gfxLevel >= Pal::GfxIpLevel::GfxIp11_0) + { + } +#endif + } + pAllocCb->pfnFree(pAllocCb->pUserData, pInfo); } @@ -1589,6 +1601,12 @@ void VulkanSettingsLoader::ValidateSettings() m_settings.enableRaytracingSupport = RaytracingNotSupported; } + // When using continuations, always set thread group size to 32 x 1 x 1, that's what we only support. + if (m_settings.llpcRaytracingMode == RaytracingContinuations) + { + m_settings.rtFlattenThreadGroupSize = 32; + } + #if VKI_BUILD_GFX11 // RTIP 2.0+ is always expected to support hardware traversal stack VK_ASSERT((rayTracingIpLevel <= Pal::RayTracingIpLevel::RtIp1_1) || diff --git a/icd/settings/settings_xgl.json b/icd/settings/settings_xgl.json index 7a52a64f..c68c6666 100644 --- a/icd/settings/settings_xgl.json +++ b/icd/settings/settings_xgl.json @@ -4164,6 +4164,44 @@ "Type": "bool", "Scope": "Driver" }, + { + "Name": "RtGpuDebugFlags", + "Description": "Gpu Debug flags for GPU RT Debug feature (asserts/printf)", + "Tags": [ + "Ray Tracing" + ], + "Defaults": { + "Default": "NoFlag" + }, + "ValidValues": { + "IsEnum": true, + "Name": "RtGpuDebugFlags", + "Values": [ + { + "Name": "NoFlag", + "Value": 0, + "Description": "Disable all gpu debug flags" + }, + { + "Name": "HostAssert", + "Value": 1, + "Description": "Enable Asserts" + }, + { + "Name": "HostPrint", + "Value": 2, + "Description": "Enable Prints" + }, + { + "Name": "ShaderHalt", + "Value": 4, + "Description": "Enable Halt shader" + } + ] + }, + "Type": "enum", + "Scope": "Driver" + }, { "Name": "RtEnableCompilePipelineLibrary", "Description": "Compile pipeline library as a ShaderLibrary.", @@ -5171,6 +5209,52 @@ "Name": "EnableMergeSort", "Scope": "Driver" }, + { + "Description": "Number of Rebraid Iterations", + "Tags": [ + "Ray Tracing" + ], + "BuildTypes": [ + "VKI_RAY_TRACING" + ], + "Defaults": { + "Default": 1 + }, + "Type": "uint32", + "Name": "NumRebraidIterations", + "Scope": "Driver" + }, + { + "Description": "Rebraid Quality Heuristic Type", + "Tags": [ + "Ray Tracing" + ], + "BuildTypes": [ + "VKI_RAY_TRACING" + ], + "Defaults": { + "Default": "RebraidQualityHeuristicInstanceEmptyArea" + }, + "ValidValues": { + "IsEnum": true, + "Name": "RebraidQualityHeuristicType", + "Values": [ + { + "Name": "RebraidQualityHeuristicInstanceEmptyArea", + "Value": 0, + "Description": "Uses SA of empty space due to opening" + }, + { + "Name": "RebraidQualityHeuristicInstanceSurfaceArea", + "Value": 1, + "Description": "Uses SA of Instance" + } + ] + }, + "Type": "enum", + "Name": "RebraidQualityHeuristicType", + "Scope": "Driver" + }, { "Description": "Fast BVH Build with no Morton Code sorting. Applies to BVHs with up to a wave size number of primitives.", "Tags": [ @@ -5186,6 +5270,36 @@ "Name": "FastBuildThreshold", "Scope": "Driver" }, + { + "Description": "Enable pair compression in early build stage, i.e., During Encode phase.", + "Tags": [ + "RayTracing" + ], + "BuildTypes": [ + "VKI_RAY_TRACING" + ], + "Defaults": { + "Default": false + }, + "Type": "bool", + "Name": "EnableEarlyPairCompression", + "Scope": "Driver" + }, + { + "Description": "Triangle pair search radius during EarlyPairCompression.", + "Tags": [ + "RayTracing" + ], + "BuildTypes": [ + "VKI_RAY_TRACING" + ], + "Defaults": { + "Default": "8" + }, + "Type": "uint32", + "Name": "TrianglePairingSearchRadius", + "Scope": "Driver" + }, { "Description": "LBVH Build when number of primitives is below the threshold. Threshold does not apply when set to 0.", "Tags": [ @@ -8803,23 +8917,47 @@ "General" ], "Defaults": { - "Default": false + "Default": true }, "Type": "bool", "Scope": "Driver", "Name": "Disable3dLinearImageFormatSupport" }, + { + "Name": "SkipUnMapMemory", + "Description": "skip UnMap when application repeately calling map/unmap on the same memory object to avoid extra paging traffic in kernel.", + "Tags": [ + "Optimization" + ], + "Defaults": { + "Default": false + }, + "Type": "bool", + "Scope": "Driver" + }, { "Description": "Enable Graphics Pipeline Libraries", "Tags": [ "Pipeline Options" ], "Defaults": { - "Default": false + "Default": true }, "Type": "bool", "Scope": "Driver", "Name": "EnableGraphicsPipelineLibraries" + }, + { + "Description": "Enable ColorClearAutoSync that tells PAL to automatically insert any required barriers between color image clears", + "Tags": [ + "General" + ], + "Defaults": { + "Default": false + }, + "Type": "bool", + "Scope": "Driver", + "Name": "EnableColorClearAutoSync" } ] } \ No newline at end of file diff --git a/icd/tools/generate/shaderProfileTemplate.py b/icd/tools/generate/shaderProfileTemplate.py index 9d943f3a..bb836509 100644 --- a/icd/tools/generate/shaderProfileTemplate.py +++ b/icd/tools/generate/shaderProfileTemplate.py @@ -2470,7 +2470,7 @@ def json_enum_reader_template(values, prefix=""): "shaders": { "entity": "array", "varName": "shaders", - "arraySize": "ShaderStage::ShaderStageNativeStageCount", + "arraySize": "ShaderStage::ShaderStageCount", "arrayValue": "", "dataType": "ShaderProfilePattern", "buildTypes": {}, @@ -2625,7 +2625,7 @@ def json_enum_reader_template(values, prefix=""): "entity": "array", "description": "Applied to ShaderCreateInfo/PipelineShaderInfo/DynamicXShaderInfo:", "varName": "shaders", - "arraySize": "ShaderStage::ShaderStageNativeStageCount", + "arraySize": "ShaderStage::ShaderStageCount", "arrayValue": "", "dataType": "ShaderProfileAction", "buildTypes": {},