guest/renderControl_enc/ExtendedRenderControl.cpp - platform/hardware/google/gfxstream - Git at Google

 // Copyright (C) 2024 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 #include "ExtendedRenderControl.h"

 using gfxstream::guest::ChecksumCalculator;

 const std::string& ExtendedRCEncoderContext::queryHostExtensions() {
     if (!m_hostExtensions.empty()) {
         return m_hostExtensions;
     }

     // Extensions strings are usually quite long, preallocate enough here.
     std::string extensionsBuffer(1023, '\0');

     // Returns the required size including the 0-terminator, so
     // account it when passing/using the sizes.
     int extensionSize =
         this->rcGetHostExtensionsString(this, extensionsBuffer.size() + 1, &extensionsBuffer[0]);
     if (extensionSize < 0) {
         extensionsBuffer.resize(-extensionSize);
         extensionSize =
             this->rcGetHostExtensionsString(this, -extensionSize + 1, &extensionsBuffer[0]);
     }

     if (extensionSize > 0) {
         extensionsBuffer.resize(extensionSize - 1);
         m_hostExtensions.swap(extensionsBuffer);
     }

     return m_hostExtensions;
 }

 void ExtendedRCEncoderContext::queryAndSetHostCompositionImpl() {
     const std::string& hostExtensions = queryHostExtensions();
     // make sure V2 is checked first before V1, as host may declare supporting both
     if (hostExtensions.find(kHostCompositionV2) != std::string::npos) {
         this->setHostComposition(HOST_COMPOSITION_V2);
     } else if (hostExtensions.find(kHostCompositionV1) != std::string::npos) {
         this->setHostComposition(HOST_COMPOSITION_V1);
     } else {
         this->setHostComposition(HOST_COMPOSITION_NONE);
     }
 }

 void ExtendedRCEncoderContext::setChecksumHelper(ChecksumCalculator* calculator) {
     const std::string& hostExtensions = queryHostExtensions();
     // check the host supported version
     uint32_t checksumVersion = 0;
     const char* checksumPrefix = ChecksumCalculator::getMaxVersionStrPrefix();
     const char* glProtocolStr = strstr(hostExtensions.c_str(), checksumPrefix);
     if (glProtocolStr) {
         uint32_t maxVersion = ChecksumCalculator::getMaxVersion();
         sscanf(glProtocolStr + strlen(checksumPrefix), "%d", &checksumVersion);
         if (maxVersion < checksumVersion) {
             checksumVersion = maxVersion;
         }
         // The ordering of the following two commands matters!
         // Must tell the host first before setting it in the guest
         this->rcSelectChecksumHelper(this, checksumVersion, 0);
         calculator->setVersion(checksumVersion);
     }
 }

 void ExtendedRCEncoderContext::queryAndSetSyncImpl() {
     const std::string& hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kRCNativeSyncV4) != std::string::npos) {
         this->setSyncImpl(SYNC_IMPL_NATIVE_SYNC_V4);
     } else if (hostExtensions.find(kRCNativeSyncV3) != std::string::npos) {
         this->setSyncImpl(SYNC_IMPL_NATIVE_SYNC_V3);
     } else if (hostExtensions.find(kRCNativeSyncV2) != std::string::npos) {
         this->setSyncImpl(SYNC_IMPL_NATIVE_SYNC_V2);
     } else {
         this->setSyncImpl(SYNC_IMPL_NONE);
     }
 }

 void ExtendedRCEncoderContext::queryAndSetDmaImpl() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kDmaExtStr_v1) != std::string::npos) {
         this->setDmaImpl(DMA_IMPL_v1);
     } else {
         this->setDmaImpl(DMA_IMPL_NONE);
     }
 }

 void ExtendedRCEncoderContext::queryAndSetGLESMaxVersion() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kGLESMaxVersion_2) != std::string::npos) {
         this->setGLESMaxVersion(GLES_MAX_VERSION_2);
     } else if (hostExtensions.find(kGLESMaxVersion_3_0) != std::string::npos) {
         this->setGLESMaxVersion(GLES_MAX_VERSION_3_0);
     } else if (hostExtensions.find(kGLESMaxVersion_3_1) != std::string::npos) {
         this->setGLESMaxVersion(GLES_MAX_VERSION_3_1);
     } else if (hostExtensions.find(kGLESMaxVersion_3_2) != std::string::npos) {
         this->setGLESMaxVersion(GLES_MAX_VERSION_3_2);
     } else {
         ALOGW("Unrecognized GLES max version string in extensions: %s", hostExtensions.c_str());
         this->setGLESMaxVersion(GLES_MAX_VERSION_2);
     }
 }

 void ExtendedRCEncoderContext::queryAndSetNoErrorState(bool& hostError) {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kGLESUseHostError) != std::string::npos) {
         hostError = false;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetDirectMemSupport() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kGLDirectMem) != std::string::npos) {
         this->featureInfo()->hasDirectMem = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetVulkanSupport() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kVulkan) != std::string::npos) {
         this->featureInfo()->hasVulkan = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetDeferredVulkanCommandsSupport() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kDeferredVulkanCommands) != std::string::npos) {
         this->featureInfo()->hasDeferredVulkanCommands = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetVulkanNullOptionalStringsSupport() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kVulkanNullOptionalStrings) != std::string::npos) {
         this->featureInfo()->hasVulkanNullOptionalStrings = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetVulkanCreateResourcesWithRequirementsSupport() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kVulkanCreateResourcesWithRequirements) != std::string::npos) {
         this->featureInfo()->hasVulkanCreateResourcesWithRequirements = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetVulkanIgnoredHandles() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kVulkanIgnoredHandles) != std::string::npos) {
         this->featureInfo()->hasVulkanIgnoredHandles = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetYUVCache() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kYUVCache) != std::string::npos) {
         this->featureInfo()->hasYUVCache = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetAsyncUnmapBuffer() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kAsyncUnmapBuffer) != std::string::npos) {
         this->featureInfo()->hasAsyncUnmapBuffer = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetVirtioGpuNext() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kVirtioGpuNext) != std::string::npos) {
         this->featureInfo()->hasVirtioGpuNext = true;
     }
 }

 void ExtendedRCEncoderContext::queryHasSharedSlotsHostMemoryAllocator() {
     const std::string& hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kHasSharedSlotsHostMemoryAllocator) != std::string::npos) {
         this->featureInfo()->hasSharedSlotsHostMemoryAllocator = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetVulkanFreeMemorySync() {
     const std::string& hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kVulkanFreeMemorySync) != std::string::npos) {
         this->featureInfo()->hasVulkanFreeMemorySync = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetVirtioGpuNativeSync() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kVirtioGpuNativeSync) != std::string::npos) {
         this->featureInfo()->hasVirtioGpuNativeSync = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetVulkanShaderFloat16Int8Support() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kVulkanShaderFloat16Int8) != std::string::npos) {
         this->featureInfo()->hasVulkanShaderFloat16Int8 = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetVulkanAsyncQueueSubmitSupport() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kVulkanAsyncQueueSubmit) != std::string::npos) {
         this->featureInfo()->hasVulkanAsyncQueueSubmit = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetHostSideTracingSupport() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kHostSideTracing) != std::string::npos) {
         this->featureInfo()->hasHostSideTracing = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetAsyncFrameCommands() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kAsyncFrameCommands) != std::string::npos) {
         this->featureInfo()->hasAsyncFrameCommands = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetVulkanQueueSubmitWithCommandsSupport() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kVulkanQueueSubmitWithCommands) != std::string::npos) {
         this->featureInfo()->hasVulkanQueueSubmitWithCommands = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetVulkanBatchedDescriptorSetUpdateSupport() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kVulkanBatchedDescriptorSetUpdate) != std::string::npos) {
         this->featureInfo()->hasVulkanBatchedDescriptorSetUpdate = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetSyncBufferData() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kSyncBufferData) != std::string::npos) {
         this->featureInfo()->hasSyncBufferData = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetVulkanAsyncQsri() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kVulkanAsyncQsri) != std::string::npos) {
         this->featureInfo()->hasVulkanAsyncQsri = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetReadColorBufferDma() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kReadColorBufferDma) != std::string::npos) {
         this->featureInfo()->hasReadColorBufferDma = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetHWCMultiConfigs() {
     std::string hostExtensions = queryHostExtensions();
     if (hostExtensions.find(kHWCMultiConfigs) != std::string::npos) {
         this->featureInfo()->hasHWCMultiConfigs = true;
     }
 }

 void ExtendedRCEncoderContext::queryAndSetVulkanAuxCommandBufferMemory() {
     std::string hostExtensions = queryHostExtensions();
     this->featureInfo()->hasVulkanAuxCommandMemory =
         hostExtensions.find(kVulkanAuxCommandMemory) != std::string::npos;
 }

 GLint ExtendedRCEncoderContext::queryVersion() {
     GLint version = this->rcGetRendererVersion(this);
     return version;
 }

 void ExtendedRCEncoderContext::setVulkanFeatureInfo(void* info) {
     struct EmulatorGfxStreamVkFeatureInfo* featureInfo =
         (struct EmulatorGfxStreamVkFeatureInfo*)info;

     featureInfo->hasDirectMem = this->featureInfo()->hasDirectMem;
     featureInfo->hasVulkan = this->featureInfo()->hasVulkan;
     featureInfo->hasDeferredVulkanCommands = this->featureInfo()->hasDeferredVulkanCommands;
     featureInfo->hasVulkanNullOptionalStrings = this->featureInfo()->hasVulkanNullOptionalStrings;
     featureInfo->hasVulkanCreateResourcesWithRequirements =
         this->featureInfo()->hasVulkanCreateResourcesWithRequirements;
     featureInfo->hasVulkanIgnoredHandles = this->featureInfo()->hasVulkanIgnoredHandles;
     featureInfo->hasVirtioGpuNext = this->featureInfo()->hasVirtioGpuNext;
     featureInfo->hasVulkanFreeMemorySync = this->featureInfo()->hasVulkanFreeMemorySync;
     featureInfo->hasVirtioGpuNativeSync = this->featureInfo()->hasVirtioGpuNativeSync;
     featureInfo->hasVulkanShaderFloat16Int8 = this->featureInfo()->hasVulkanShaderFloat16Int8;
     featureInfo->hasVulkanAsyncQueueSubmit = this->featureInfo()->hasVulkanAsyncQueueSubmit;
     featureInfo->hasVulkanQueueSubmitWithCommands =
         this->featureInfo()->hasVulkanQueueSubmitWithCommands;
     featureInfo->hasVulkanBatchedDescriptorSetUpdate =
         this->featureInfo()->hasVulkanBatchedDescriptorSetUpdate;
     featureInfo->hasVulkanAsyncQsri = this->featureInfo()->hasVulkanAsyncQsri;
     featureInfo->hasVulkanAuxCommandMemory = this->featureInfo()->hasVulkanAuxCommandMemory;
 }
	// Copyright (C) 2024 The Android Open Source Project
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.
	#include "ExtendedRenderControl.h"

	using gfxstream::guest::ChecksumCalculator;

	const std::string& ExtendedRCEncoderContext::queryHostExtensions() {
	if (!m_hostExtensions.empty()) {
	return m_hostExtensions;
	}

	// Extensions strings are usually quite long, preallocate enough here.
	std::string extensionsBuffer(1023, '\0');

	// Returns the required size including the 0-terminator, so
	// account it when passing/using the sizes.
	int extensionSize =
	this->rcGetHostExtensionsString(this, extensionsBuffer.size() + 1, &extensionsBuffer[0]);
	if (extensionSize < 0) {
	extensionsBuffer.resize(-extensionSize);
	extensionSize =
	this->rcGetHostExtensionsString(this, -extensionSize + 1, &extensionsBuffer[0]);
	}

	if (extensionSize > 0) {
	extensionsBuffer.resize(extensionSize - 1);
	m_hostExtensions.swap(extensionsBuffer);
	}

	return m_hostExtensions;
	}

	void ExtendedRCEncoderContext::queryAndSetHostCompositionImpl() {
	const std::string& hostExtensions = queryHostExtensions();
	// make sure V2 is checked first before V1, as host may declare supporting both
	if (hostExtensions.find(kHostCompositionV2) != std::string::npos) {
	this->setHostComposition(HOST_COMPOSITION_V2);
	} else if (hostExtensions.find(kHostCompositionV1) != std::string::npos) {
	this->setHostComposition(HOST_COMPOSITION_V1);
	} else {
	this->setHostComposition(HOST_COMPOSITION_NONE);
	}
	}

	void ExtendedRCEncoderContext::setChecksumHelper(ChecksumCalculator* calculator) {
	const std::string& hostExtensions = queryHostExtensions();
	// check the host supported version
	uint32_t checksumVersion = 0;
	const char* checksumPrefix = ChecksumCalculator::getMaxVersionStrPrefix();
	const char* glProtocolStr = strstr(hostExtensions.c_str(), checksumPrefix);
	if (glProtocolStr) {
	uint32_t maxVersion = ChecksumCalculator::getMaxVersion();
	sscanf(glProtocolStr + strlen(checksumPrefix), "%d", &checksumVersion);
	if (maxVersion < checksumVersion) {
	checksumVersion = maxVersion;
	}
	// The ordering of the following two commands matters!
	// Must tell the host first before setting it in the guest
	this->rcSelectChecksumHelper(this, checksumVersion, 0);
	calculator->setVersion(checksumVersion);
	}
	}

	void ExtendedRCEncoderContext::queryAndSetSyncImpl() {
	const std::string& hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kRCNativeSyncV4) != std::string::npos) {
	this->setSyncImpl(SYNC_IMPL_NATIVE_SYNC_V4);
	} else if (hostExtensions.find(kRCNativeSyncV3) != std::string::npos) {
	this->setSyncImpl(SYNC_IMPL_NATIVE_SYNC_V3);
	} else if (hostExtensions.find(kRCNativeSyncV2) != std::string::npos) {
	this->setSyncImpl(SYNC_IMPL_NATIVE_SYNC_V2);
	} else {
	this->setSyncImpl(SYNC_IMPL_NONE);
	}
	}

	void ExtendedRCEncoderContext::queryAndSetDmaImpl() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kDmaExtStr_v1) != std::string::npos) {
	this->setDmaImpl(DMA_IMPL_v1);
	} else {
	this->setDmaImpl(DMA_IMPL_NONE);
	}
	}

	void ExtendedRCEncoderContext::queryAndSetGLESMaxVersion() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kGLESMaxVersion_2) != std::string::npos) {
	this->setGLESMaxVersion(GLES_MAX_VERSION_2);
	} else if (hostExtensions.find(kGLESMaxVersion_3_0) != std::string::npos) {
	this->setGLESMaxVersion(GLES_MAX_VERSION_3_0);
	} else if (hostExtensions.find(kGLESMaxVersion_3_1) != std::string::npos) {
	this->setGLESMaxVersion(GLES_MAX_VERSION_3_1);
	} else if (hostExtensions.find(kGLESMaxVersion_3_2) != std::string::npos) {
	this->setGLESMaxVersion(GLES_MAX_VERSION_3_2);
	} else {
	ALOGW("Unrecognized GLES max version string in extensions: %s", hostExtensions.c_str());
	this->setGLESMaxVersion(GLES_MAX_VERSION_2);
	}
	}

	void ExtendedRCEncoderContext::queryAndSetNoErrorState(bool& hostError) {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kGLESUseHostError) != std::string::npos) {
	hostError = false;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetDirectMemSupport() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kGLDirectMem) != std::string::npos) {
	this->featureInfo()->hasDirectMem = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetVulkanSupport() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kVulkan) != std::string::npos) {
	this->featureInfo()->hasVulkan = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetDeferredVulkanCommandsSupport() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kDeferredVulkanCommands) != std::string::npos) {
	this->featureInfo()->hasDeferredVulkanCommands = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetVulkanNullOptionalStringsSupport() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kVulkanNullOptionalStrings) != std::string::npos) {
	this->featureInfo()->hasVulkanNullOptionalStrings = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetVulkanCreateResourcesWithRequirementsSupport() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kVulkanCreateResourcesWithRequirements) != std::string::npos) {
	this->featureInfo()->hasVulkanCreateResourcesWithRequirements = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetVulkanIgnoredHandles() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kVulkanIgnoredHandles) != std::string::npos) {
	this->featureInfo()->hasVulkanIgnoredHandles = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetYUVCache() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kYUVCache) != std::string::npos) {
	this->featureInfo()->hasYUVCache = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetAsyncUnmapBuffer() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kAsyncUnmapBuffer) != std::string::npos) {
	this->featureInfo()->hasAsyncUnmapBuffer = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetVirtioGpuNext() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kVirtioGpuNext) != std::string::npos) {
	this->featureInfo()->hasVirtioGpuNext = true;
	}
	}

	void ExtendedRCEncoderContext::queryHasSharedSlotsHostMemoryAllocator() {
	const std::string& hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kHasSharedSlotsHostMemoryAllocator) != std::string::npos) {
	this->featureInfo()->hasSharedSlotsHostMemoryAllocator = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetVulkanFreeMemorySync() {
	const std::string& hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kVulkanFreeMemorySync) != std::string::npos) {
	this->featureInfo()->hasVulkanFreeMemorySync = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetVirtioGpuNativeSync() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kVirtioGpuNativeSync) != std::string::npos) {
	this->featureInfo()->hasVirtioGpuNativeSync = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetVulkanShaderFloat16Int8Support() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kVulkanShaderFloat16Int8) != std::string::npos) {
	this->featureInfo()->hasVulkanShaderFloat16Int8 = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetVulkanAsyncQueueSubmitSupport() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kVulkanAsyncQueueSubmit) != std::string::npos) {
	this->featureInfo()->hasVulkanAsyncQueueSubmit = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetHostSideTracingSupport() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kHostSideTracing) != std::string::npos) {
	this->featureInfo()->hasHostSideTracing = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetAsyncFrameCommands() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kAsyncFrameCommands) != std::string::npos) {
	this->featureInfo()->hasAsyncFrameCommands = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetVulkanQueueSubmitWithCommandsSupport() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kVulkanQueueSubmitWithCommands) != std::string::npos) {
	this->featureInfo()->hasVulkanQueueSubmitWithCommands = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetVulkanBatchedDescriptorSetUpdateSupport() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kVulkanBatchedDescriptorSetUpdate) != std::string::npos) {
	this->featureInfo()->hasVulkanBatchedDescriptorSetUpdate = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetSyncBufferData() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kSyncBufferData) != std::string::npos) {
	this->featureInfo()->hasSyncBufferData = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetVulkanAsyncQsri() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kVulkanAsyncQsri) != std::string::npos) {
	this->featureInfo()->hasVulkanAsyncQsri = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetReadColorBufferDma() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kReadColorBufferDma) != std::string::npos) {
	this->featureInfo()->hasReadColorBufferDma = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetHWCMultiConfigs() {
	std::string hostExtensions = queryHostExtensions();
	if (hostExtensions.find(kHWCMultiConfigs) != std::string::npos) {
	this->featureInfo()->hasHWCMultiConfigs = true;
	}
	}

	void ExtendedRCEncoderContext::queryAndSetVulkanAuxCommandBufferMemory() {
	std::string hostExtensions = queryHostExtensions();
	this->featureInfo()->hasVulkanAuxCommandMemory =
	hostExtensions.find(kVulkanAuxCommandMemory) != std::string::npos;
	}

	GLint ExtendedRCEncoderContext::queryVersion() {
	GLint version = this->rcGetRendererVersion(this);
	return version;
	}

	void ExtendedRCEncoderContext::setVulkanFeatureInfo(void* info) {
	struct EmulatorGfxStreamVkFeatureInfo* featureInfo =
	(struct EmulatorGfxStreamVkFeatureInfo*)info;

	featureInfo->hasDirectMem = this->featureInfo()->hasDirectMem;
	featureInfo->hasVulkan = this->featureInfo()->hasVulkan;
	featureInfo->hasDeferredVulkanCommands = this->featureInfo()->hasDeferredVulkanCommands;
	featureInfo->hasVulkanNullOptionalStrings = this->featureInfo()->hasVulkanNullOptionalStrings;
	featureInfo->hasVulkanCreateResourcesWithRequirements =
	this->featureInfo()->hasVulkanCreateResourcesWithRequirements;
	featureInfo->hasVulkanIgnoredHandles = this->featureInfo()->hasVulkanIgnoredHandles;
	featureInfo->hasVirtioGpuNext = this->featureInfo()->hasVirtioGpuNext;
	featureInfo->hasVulkanFreeMemorySync = this->featureInfo()->hasVulkanFreeMemorySync;
	featureInfo->hasVirtioGpuNativeSync = this->featureInfo()->hasVirtioGpuNativeSync;
	featureInfo->hasVulkanShaderFloat16Int8 = this->featureInfo()->hasVulkanShaderFloat16Int8;
	featureInfo->hasVulkanAsyncQueueSubmit = this->featureInfo()->hasVulkanAsyncQueueSubmit;
	featureInfo->hasVulkanQueueSubmitWithCommands =
	this->featureInfo()->hasVulkanQueueSubmitWithCommands;
	featureInfo->hasVulkanBatchedDescriptorSetUpdate =
	this->featureInfo()->hasVulkanBatchedDescriptorSetUpdate;
	featureInfo->hasVulkanAsyncQsri = this->featureInfo()->hasVulkanAsyncQsri;
	featureInfo->hasVulkanAuxCommandMemory = this->featureInfo()->hasVulkanAuxCommandMemory;
	}