Merge "goldfish-codecs: improve image data copy"
diff --git a/Android.mk b/Android.mk
index 2c0a5c2..7afa40a 100644
--- a/Android.mk
+++ b/Android.mk
@@ -149,6 +149,11 @@
include $(GOLDFISH_OPENGL_PATH)/system/GLESv2/Android.mk
include $(GOLDFISH_OPENGL_PATH)/system/gralloc/Android.mk
+
+ifneq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+include $(GOLDFISH_OPENGL_PATH)/system/hals/Android.mk
+endif
+
include $(GOLDFISH_OPENGL_PATH)/system/cbmanager/Android.mk
include $(GOLDFISH_OPENGL_PATH)/system/egl/Android.mk
diff --git a/CMakeLists.txt b/CMakeLists.txt
index eba847a..9c58ad1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,7 +2,7 @@
# instead run make from .../device/generic/goldfish-opengl
# which will re-generate this file.
set(GOLDFISH_DEVICE_ROOT ${CMAKE_CURRENT_SOURCE_DIR})
-android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/./Android.mk" "2c3250b596a2b161e479dd3624a74ae6e485d6238d59d9a5dc55064c46482943")
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/./Android.mk" "c8e5536771d09cd120c3e396beac994a1e2d2880f37b4e3bd1844be4cfc31555")
add_subdirectory(shared/OpenglCodecCommon)
add_subdirectory(system/GLESv1_enc)
add_subdirectory(system/GLESv2_enc)
@@ -14,4 +14,4 @@
add_subdirectory(system/GLESv2)
add_subdirectory(system/gralloc)
add_subdirectory(system/egl)
-add_subdirectory(system/vulkan)
+add_subdirectory(system/vulkan)
\ No newline at end of file
diff --git a/system/OpenglSystemCommon/EmulatorFeatureInfo.h b/system/OpenglSystemCommon/EmulatorFeatureInfo.h
index 13bd8ad..e20c129 100644
--- a/system/OpenglSystemCommon/EmulatorFeatureInfo.h
+++ b/system/OpenglSystemCommon/EmulatorFeatureInfo.h
@@ -88,6 +88,9 @@
// Vulkan create resources with requirements
static const char kVulkanCreateResourcesWithRequirements[] = "ANDROID_EMU_vulkan_create_resources_with_requirements";
+// Vulkan ignored handles
+static const char kVulkanIgnoredHandles[] = "ANDROID_EMU_vulkan_ignored_handles";
+
// YUV host cache
static const char kYUVCache[] = "ANDROID_EMU_YUV_Cache";
@@ -107,6 +110,7 @@
hasDeferredVulkanCommands(false),
hasVulkanNullOptionalStrings(false),
hasVulkanCreateResourcesWithRequirements(false),
+ hasVulkanIgnoredHandles(false),
hasYUVCache (false),
hasAsyncUnmapBuffer (false) { }
@@ -119,6 +123,7 @@
bool hasDeferredVulkanCommands;
bool hasVulkanNullOptionalStrings;
bool hasVulkanCreateResourcesWithRequirements;
+ bool hasVulkanIgnoredHandles;
bool hasYUVCache;
bool hasAsyncUnmapBuffer;
};
diff --git a/system/OpenglSystemCommon/HostConnection.cpp b/system/OpenglSystemCommon/HostConnection.cpp
index b72bc8c..f69b1d5 100644
--- a/system/OpenglSystemCommon/HostConnection.cpp
+++ b/system/OpenglSystemCommon/HostConnection.cpp
@@ -610,6 +610,7 @@
queryAndSetDeferredVulkanCommandsSupport(m_rcEnc);
queryAndSetVulkanNullOptionalStringsSupport(m_rcEnc);
queryAndSetVulkanCreateResourcesWithRequirementsSupport(m_rcEnc);
+ queryAndSetVulkanIgnoredHandles(m_rcEnc);
queryAndSetYUVCache(m_rcEnc);
queryAndSetAsyncUnmapBuffer(m_rcEnc);
if (m_processPipe) {
@@ -788,6 +789,13 @@
}
}
+void HostConnection::queryAndSetVulkanIgnoredHandles(ExtendedRCEncoderContext* rcEnc) {
+ std::string glExtensions = queryGLExtensions(rcEnc);
+ if (glExtensions.find(kVulkanIgnoredHandles) != std::string::npos) {
+ rcEnc->featureInfo()->hasVulkanIgnoredHandles = true;
+ }
+}
+
void HostConnection::queryAndSetYUVCache(ExtendedRCEncoderContext* rcEnc) {
std::string glExtensions = queryGLExtensions(rcEnc);
if (glExtensions.find(kYUVCache) != std::string::npos) {
diff --git a/system/OpenglSystemCommon/HostConnection.h b/system/OpenglSystemCommon/HostConnection.h
index 501c254..0f262a3 100644
--- a/system/OpenglSystemCommon/HostConnection.h
+++ b/system/OpenglSystemCommon/HostConnection.h
@@ -200,6 +200,7 @@
void queryAndSetDeferredVulkanCommandsSupport(ExtendedRCEncoderContext *rcEnc);
void queryAndSetVulkanNullOptionalStringsSupport(ExtendedRCEncoderContext *rcEnc);
void queryAndSetVulkanCreateResourcesWithRequirementsSupport(ExtendedRCEncoderContext *rcEnc);
+ void queryAndSetVulkanIgnoredHandles(ExtendedRCEncoderContext *rcEnc);
void queryAndSetYUVCache(ExtendedRCEncoderContext *mrcEnc);
void queryAndSetAsyncUnmapBuffer(ExtendedRCEncoderContext *rcEnc);
diff --git a/system/hals/Android.mk b/system/hals/Android.mk
new file mode 100644
index 0000000..912a362
--- /dev/null
+++ b/system/hals/Android.mk
@@ -0,0 +1,74 @@
+#
+# Copyright 2015 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := android.hardware.graphics.allocator@3.0-service
+LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_VENDOR_MODULE := true
+LOCAL_SRC_FILES := allocator3.cpp
+LOCAL_INIT_RC := android.hardware.graphics.allocator@3.0-service.rc
+
+LOCAL_SHARED_LIBRARIES += \
+ android.hardware.graphics.allocator@3.0 \
+ android.hardware.graphics.mapper@3.0 \
+ libOpenglSystemCommon \
+ libOpenglCodecCommon$(GOLDFISH_OPENGL_LIB_SUFFIX) \
+ libbase \
+ libcutils \
+ libhidlbase \
+ liblog \
+ libutils
+
+LOCAL_C_INCLUDES += \
+ device/generic/goldfish-opengl/system/include \
+ device/generic/goldfish-opengl/system/OpenglSystemCommon \
+ device/generic/goldfish-opengl/shared/OpenglCodecCommon \
+ device/generic/goldfish-opengl/host/include/libOpenglRender \
+ device/generic/goldfish-opengl/system/renderControl_enc \
+
+include $(BUILD_EXECUTABLE)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := android.hardware.graphics.mapper@3.0-impl
+LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_VENDOR_MODULE := true
+LOCAL_SRC_FILES := mapper3.cpp
+
+# android.hardware.graphics.allocator@3.0 \
+
+LOCAL_SHARED_LIBRARIES += \
+ android.hardware.graphics.mapper@3.0 \
+ libOpenglSystemCommon \
+ libOpenglCodecCommon$(GOLDFISH_OPENGL_LIB_SUFFIX) \
+ libbase \
+ libcutils \
+ libhidlbase \
+ liblog \
+ libutils \
+ libsync
+
+LOCAL_C_INCLUDES += \
+ device/generic/goldfish-opengl/system/include \
+ device/generic/goldfish-opengl/system/OpenglSystemCommon \
+ device/generic/goldfish-opengl/shared/OpenglCodecCommon \
+ device/generic/goldfish-opengl/host/include/libOpenglRender \
+ device/generic/goldfish-opengl/system/renderControl_enc \
+
+include $(BUILD_SHARED_LIBRARY)
+
diff --git a/system/hals/allocator3.cpp b/system/hals/allocator3.cpp
new file mode 100644
index 0000000..e5e182d
--- /dev/null
+++ b/system/hals/allocator3.cpp
@@ -0,0 +1,425 @@
+/*
+* Copyright (C) 2020 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 <android/hardware/graphics/allocator/3.0/IAllocator.h>
+#include <android/hardware/graphics/mapper/3.0/IMapper.h>
+#include <hidl/LegacySupport.h>
+
+#include "glUtils.h"
+#include "cb_handle_30.h"
+#include "host_connection_session.h"
+#include "types.h"
+#include "debug.h"
+
+using ::android::hardware::hidl_handle;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_bitfield;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+
+using ::android::hardware::graphics::common::V1_2::PixelFormat;
+using ::android::hardware::graphics::common::V1_0::BufferUsage;
+
+namespace AllocatorV3 = ::android::hardware::graphics::allocator::V3_0;
+namespace MapperV3 = ::android::hardware::graphics::mapper::V3_0;
+
+using IAllocator3 = AllocatorV3::IAllocator;
+using IMapper3 = MapperV3::IMapper;
+using Error3 = MapperV3::Error;
+using BufferDescriptorInfo = IMapper3::BufferDescriptorInfo;
+
+class GoldfishAllocator : public IAllocator3 {
+public:
+ GoldfishAllocator() : m_hostConn(HostConnection::createUnique()) {}
+
+ Return<void> dumpDebugInfo(dumpDebugInfo_cb hidl_cb) {
+ hidl_cb("GoldfishAllocator::dumpDebugInfo is not implemented");
+ return {};
+ }
+
+ Return<void> allocate(const hidl_vec<uint32_t>& rawDescriptor,
+ uint32_t count,
+ allocate_cb hidl_cb) {
+ uint32_t stride = 0;
+ std::vector<cb_handle_30_t*> cbs;
+ cbs.reserve(count);
+
+ const Error3 e = allocateImpl(rawDescriptor, count, &stride, &cbs);
+ if (e == Error3::NONE) {
+ hidl_vec<hidl_handle> handles(cbs.cbegin(), cbs.cend());
+ hidl_cb(Error3::NONE, stride, handles);
+ } else {
+ hidl_cb(e, 0, {});
+ }
+
+ for (cb_handle_30_t* cb : cbs) {
+ freeCb(std::unique_ptr<cb_handle_30_t>(cb));
+ }
+
+ return {};
+ }
+
+private:
+ // this function should be in sync with GoldfishMapper::isSupportedImpl
+ Error3 allocateImpl(const hidl_vec<uint32_t>& rawDescriptor,
+ uint32_t count,
+ uint32_t* pStride,
+ std::vector<cb_handle_30_t*>* cbs) {
+ BufferDescriptorInfo descriptor;
+ if (!decodeBufferDescriptorInfo(rawDescriptor, &descriptor)) {
+ RETURN_ERROR(Error3::BAD_DESCRIPTOR);
+ }
+
+ if (!descriptor.width) { RETURN_ERROR(Error3::UNSUPPORTED); }
+ if (!descriptor.height) { RETURN_ERROR(Error3::UNSUPPORTED); }
+ if (descriptor.layerCount != 1) { RETURN_ERROR(Error3::UNSUPPORTED); }
+
+ const uint32_t usage = descriptor.usage;
+ const bool usageSwWrite = usage & BufferUsage::CPU_WRITE_MASK;
+ const bool usageSwRead = usage & BufferUsage::CPU_READ_MASK;
+ const bool usageHwCamWrite = usage & BufferUsage::CAMERA_OUTPUT;
+ const bool usageHwCamRead = usage & BufferUsage::CAMERA_INPUT;
+
+ int bpp = 1;
+ int glFormat = 0;
+ int glType = 0;
+ int align = 1;
+ bool yuv_format = false;
+ EmulatorFrameworkFormat emulatorFrameworkFormat =
+ EmulatorFrameworkFormat::GL_COMPATIBLE;
+
+ PixelFormat format;
+ Error3 e = getBufferFormat(descriptor.format, usage, &format);
+ if (e != Error3::NONE) {
+ ALOGE("%s:%d Unsupported format: frameworkFormat=%d, usage=%x",
+ __func__, __LINE__, descriptor.format, usage);
+ return e;
+ }
+
+ switch (format) {
+ case PixelFormat::RGBA_8888:
+ case PixelFormat::RGBX_8888:
+ case PixelFormat::BGRA_8888:
+ bpp = 4;
+ glFormat = GL_RGBA;
+ glType = GL_UNSIGNED_BYTE;
+ break;
+
+ case PixelFormat::RGB_888:
+ if (usage & (BufferUsage::GPU_TEXTURE |
+ BufferUsage::GPU_RENDER_TARGET |
+ BufferUsage::COMPOSER_OVERLAY |
+ BufferUsage::COMPOSER_CLIENT_TARGET)) {
+ RETURN_ERROR(Error3::UNSUPPORTED);
+ } else {
+ bpp = 3;
+ glFormat = GL_RGB;
+ glType = GL_UNSIGNED_BYTE;
+ }
+ break;
+
+ case PixelFormat::RGB_565:
+ bpp = 2;
+ glFormat = GL_RGB565;
+ glType = GL_UNSIGNED_SHORT_5_6_5;
+ break;
+
+ case PixelFormat::RGBA_FP16:
+ bpp = 8;
+ glFormat = GL_RGBA16F;
+ glType = GL_HALF_FLOAT;
+ break;
+
+ case PixelFormat::RGBA_1010102:
+ bpp = 4;
+ glFormat = GL_RGB10_A2;
+ glType = GL_UNSIGNED_INT_2_10_10_10_REV;
+ break;
+
+ case PixelFormat::RAW16:
+ case PixelFormat::Y16:
+ bpp = 2;
+ align = 16 * bpp;
+ if (!((usageSwRead || usageHwCamRead) && (usageSwWrite || usageHwCamWrite))) {
+ // Raw sensor data or Y16 only goes between camera and CPU
+ RETURN_ERROR(Error3::UNSUPPORTED);
+ }
+ // Not expecting to actually create any GL surfaces for this
+ glFormat = GL_LUMINANCE;
+ glType = GL_UNSIGNED_SHORT;
+ break;
+
+ case PixelFormat::BLOB:
+ if (!usageSwRead) {
+ // Blob data cannot be used by HW other than camera emulator
+ // But there is a CTS test trying to have access to it
+ // BUG: https://buganizer.corp.google.com/issues/37719518
+ RETURN_ERROR(Error3::UNSUPPORTED);
+ }
+ // Not expecting to actually create any GL surfaces for this
+ glFormat = GL_LUMINANCE;
+ glType = GL_UNSIGNED_BYTE;
+ break;
+
+ case PixelFormat::YCRCB_420_SP:
+ yuv_format = true;
+ // Not expecting to actually create any GL surfaces for this
+ break;
+
+ case PixelFormat::YV12:
+ align = 16;
+ yuv_format = true;
+ // We are going to use RGB8888 on the host for Vulkan
+ glFormat = GL_RGBA;
+ glType = GL_UNSIGNED_BYTE;
+ emulatorFrameworkFormat = EmulatorFrameworkFormat::YV12;
+ break;
+
+ case PixelFormat::YCBCR_420_888:
+ yuv_format = true;
+ // We are going to use RGB888 on the host
+ glFormat = GL_RGB;
+ glType = GL_UNSIGNED_BYTE;
+ emulatorFrameworkFormat = EmulatorFrameworkFormat::YUV_420_888;
+ break;
+
+ default:
+ ALOGE("%s:%d Unsupported format: format=%d, frameworkFormat=%d, usage=%x",
+ __func__, __LINE__, format, descriptor.format, usage);
+ RETURN_ERROR(Error3::UNSUPPORTED);
+ }
+
+ const size_t align1 = align - 1;
+ const uint32_t width = descriptor.width;
+ const uint32_t height = descriptor.height;
+ uint32_t stride;
+ size_t bufferSize;
+
+ if (yuv_format) {
+ const size_t yStride = (width * bpp + align1) & ~align1;
+ const size_t uvStride = (yStride / 2 + align1) & ~align1;
+ const size_t uvHeight = height / 2;
+ bufferSize = yStride * height + 2 * (uvHeight * uvStride);
+ stride = yStride / bpp;
+ } else {
+ const size_t bpr = (width * bpp + align1) & ~align1;
+ bufferSize = bpr * height;
+ stride = bpr / bpp;
+ }
+
+ *pStride = stride;
+
+ return allocateImpl2(usage,
+ width, height,
+ format, emulatorFrameworkFormat,
+ glFormat, glType,
+ bufferSize,
+ bpp, stride,
+ count, cbs);
+ }
+
+ Error3 allocateImpl2(const uint32_t usage,
+ const uint32_t width, const uint32_t height,
+ const PixelFormat format,
+ const EmulatorFrameworkFormat emulatorFrameworkFormat,
+ const int glFormat, const int glType,
+ const size_t bufferSize,
+ const uint32_t bytesPerPixel,
+ const uint32_t stride,
+ const uint32_t count,
+ std::vector<cb_handle_30_t*>* cbs) {
+ for (uint32_t i = 0; i < count; ++i) {
+ cb_handle_30_t* cb;
+ Error3 e = allocateCb(usage,
+ width, height,
+ format, emulatorFrameworkFormat,
+ glFormat, glType,
+ bufferSize,
+ bytesPerPixel, stride,
+ &cb);
+ if (e == Error3::NONE) {
+ cbs->push_back(cb);
+ } else {
+ return e;
+ }
+ }
+
+ RETURN(Error3::NONE);
+ }
+
+ // see GoldfishMapper::encodeBufferDescriptorInfo
+ static bool decodeBufferDescriptorInfo(const hidl_vec<uint32_t>& raw,
+ BufferDescriptorInfo* d) {
+ if (raw.size() == 5) {
+ d->width = raw[0];
+ d->height = raw[1];
+ d->layerCount = raw[2];
+ d->format = static_cast<PixelFormat>(raw[3]);
+ d->usage = raw[4];
+
+ RETURN(true);
+ } else {
+ RETURN_ERROR(false);
+ }
+ }
+
+ static Error3 getBufferFormat(const PixelFormat frameworkFormat,
+ const uint32_t usage,
+ PixelFormat* format) {
+ if (frameworkFormat == PixelFormat::IMPLEMENTATION_DEFINED) {
+ if (usage & BufferUsage::CAMERA_OUTPUT) {
+ if (usage & BufferUsage::GPU_TEXTURE) {
+ // Camera-to-display is RGBA
+ *format = PixelFormat::RGBA_8888;
+ RETURN(Error3::NONE);
+ } else if (usage & BufferUsage::VIDEO_ENCODER) {
+ // Camera-to-encoder is NV21
+ *format = PixelFormat::YCRCB_420_SP;
+ RETURN(Error3::NONE);
+ }
+ }
+ RETURN_ERROR(Error3::UNSUPPORTED);
+ } else {
+ *format = frameworkFormat;
+ RETURN(Error3::NONE);
+ }
+ }
+
+ static bool needHostCb(const uint32_t usage, const PixelFormat format) {
+ return ((usage & BufferUsage::GPU_DATA_BUFFER)
+ || (format != PixelFormat::BLOB &&
+ format != PixelFormat::RAW16 &&
+ format != PixelFormat::Y16))
+ && (usage & (BufferUsage::GPU_TEXTURE
+ | BufferUsage::GPU_RENDER_TARGET
+ | BufferUsage::COMPOSER_OVERLAY
+ | BufferUsage::VIDEO_ENCODER
+ | BufferUsage::COMPOSER_CLIENT_TARGET
+ | BufferUsage::CPU_READ_MASK));
+ }
+
+ Error3 allocateCb(const uint32_t usage,
+ const uint32_t width, const uint32_t height,
+ const PixelFormat format,
+ const EmulatorFrameworkFormat emulatorFrameworkFormat,
+ const int glFormat, const int glType,
+ const size_t bufferSize,
+ const int32_t bytesPerPixel,
+ const int32_t stride,
+ cb_handle_30_t** cb) {
+ GoldfishAddressSpaceHostMemoryAllocator host_memory_allocator;
+ if (!host_memory_allocator.is_opened()) {
+ RETURN_ERROR(Error3::NO_RESOURCES);
+ }
+
+ GoldfishAddressSpaceBlock bufferBits;
+ if (host_memory_allocator.hostMalloc(&bufferBits, bufferSize)) {
+ RETURN_ERROR(Error3::NO_RESOURCES);
+ }
+
+ uint32_t hostHandle = 0;
+ QEMU_PIPE_HANDLE hostHandleRefCountFd = QEMU_PIPE_INVALID_HANDLE;
+ if (needHostCb(usage, format)) {
+ hostHandleRefCountFd = qemu_pipe_open("refcount");
+ if (!qemu_pipe_valid(hostHandleRefCountFd)) {
+ RETURN_ERROR(Error3::NO_RESOURCES);
+ }
+
+ const GLenum allocFormat =
+ (PixelFormat::RGBX_8888 == format) ? GL_RGB : glFormat;
+
+ const HostConnectionSession conn = getHostConnectionSession();
+ ExtendedRCEncoderContext *const rcEnc = conn.getRcEncoder();
+ CRASH_IF(!rcEnc, "conn.getRcEncoder() failed");
+
+ hostHandle = rcEnc->rcCreateColorBufferDMA(
+ rcEnc,
+ width, height,
+ allocFormat, static_cast<int>(emulatorFrameworkFormat));
+
+ if (!hostHandle) {
+ qemu_pipe_close(hostHandleRefCountFd);
+ RETURN_ERROR(Error3::NO_RESOURCES);
+ }
+
+ if (qemu_pipe_write(hostHandleRefCountFd,
+ &hostHandle,
+ sizeof(hostHandle)) != sizeof(hostHandle)) {
+ rcEnc->rcCloseColorBuffer(rcEnc, hostHandle);
+ qemu_pipe_close(hostHandleRefCountFd);
+ RETURN_ERROR(Error3::NO_RESOURCES);
+ }
+ }
+
+ std::unique_ptr<cb_handle_30_t> handle =
+ std::make_unique<cb_handle_30_t>(
+ host_memory_allocator.release(),
+ hostHandleRefCountFd,
+ hostHandle,
+ usage,
+ width,
+ height,
+ static_cast<int>(format),
+ glFormat,
+ glType,
+ bufferSize,
+ bufferBits.guestPtr(),
+ bufferBits.size(),
+ bufferBits.offset(),
+ bytesPerPixel,
+ stride);
+
+ bufferBits.release();
+ *cb = handle.release();
+ RETURN(Error3::NONE);
+ }
+
+ void freeCb(std::unique_ptr<cb_handle_30_t> cb) {
+ // no need to undo .hostMalloc: the kernel will take care of it once the
+ // last bufferFd (duped) is closed.
+
+ if (qemu_pipe_valid(cb->hostHandleRefCountFd)) {
+ qemu_pipe_close(cb->hostHandleRefCountFd);
+ }
+ GoldfishAddressSpaceBlock::memoryUnmap(cb->getBufferPtr(), cb->mmapedSize);
+ GoldfishAddressSpaceHostMemoryAllocator::closeHandle(cb->bufferFd);
+ }
+
+ HostConnectionSession getHostConnectionSession() const {
+ return HostConnectionSession(m_hostConn);
+ }
+
+ //std::unique_ptr<HostConnection> m_hostConn; // b/142677230
+ HostConnection* m_hostConn;
+};
+
+int main(int, char**) {
+ using ::android::sp;
+
+ ::android::hardware::configureRpcThreadpool(4, true /* callerWillJoin */);
+
+ sp<IAllocator3> allocator(new GoldfishAllocator());
+ if (allocator->registerAsService() != ::android::NO_ERROR) {
+ ALOGE("failed to register graphics IAllocator@3.0 service");
+ return -EINVAL;
+ }
+
+ ALOGI("graphics IAllocator@3.0 service is initialized");
+ ::android::hardware::joinRpcThreadpool();
+
+ ALOGI("graphics IAllocator@3.0 service is terminating");
+ return 0;
+}
diff --git a/system/hals/android.hardware.graphics.allocator@3.0-service.rc b/system/hals/android.hardware.graphics.allocator@3.0-service.rc
new file mode 100644
index 0000000..8b9e13a
--- /dev/null
+++ b/system/hals/android.hardware.graphics.allocator@3.0-service.rc
@@ -0,0 +1,8 @@
+service vendor.gralloc-3-0 /vendor/bin/hw/android.hardware.graphics.allocator@3.0-service
+ interface android.hardware.graphics.allocator@3.0::IAllocator default
+ class hal animation
+ interface android.hardware.graphics.allocator@3.0::IAllocator default
+ user system
+ group graphics drmrpc
+ capabilities SYS_NICE
+ onrestart restart surfaceflinger
diff --git a/system/hals/cb_handle_30.h b/system/hals/cb_handle_30.h
new file mode 100644
index 0000000..11ce322
--- /dev/null
+++ b/system/hals/cb_handle_30.h
@@ -0,0 +1,81 @@
+/*
+* Copyright 2011 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.
+*/
+
+#ifndef SYSTEM_HALS_CB_HANDLE_30_H
+#define SYSTEM_HALS_CB_HANDLE_30_H
+
+#include "gralloc_cb.h"
+#include "goldfish_address_space.h"
+
+const uint32_t CB_HANDLE_MAGIC_30 = CB_HANDLE_MAGIC_BASE | 0x2;
+
+struct cb_handle_30_t : public cb_handle_t {
+ cb_handle_30_t(address_space_handle_t p_bufferFd,
+ QEMU_PIPE_HANDLE p_hostHandleRefCountFd,
+ uint32_t p_hostHandle,
+ int32_t p_usage,
+ int32_t p_width,
+ int32_t p_height,
+ int32_t p_format,
+ int32_t p_glFormat,
+ int32_t p_glType,
+ uint32_t p_bufSize,
+ void* p_bufPtr,
+ uint32_t p_mmapedSize,
+ uint64_t p_mmapedOffset,
+ uint32_t p_bytesPerPixel,
+ uint32_t p_stride)
+ : cb_handle_t(p_bufferFd,
+ p_hostHandleRefCountFd,
+ CB_HANDLE_MAGIC_30,
+ p_hostHandle,
+ p_usage,
+ p_width,
+ p_height,
+ p_format,
+ p_glFormat,
+ p_glType,
+ p_bufSize,
+ p_bufPtr,
+ p_mmapedOffset),
+ mmapedSize(p_mmapedSize),
+ bytesPerPixel(p_bytesPerPixel),
+ stride(p_stride) {
+ numInts = CB_HANDLE_NUM_INTS(numFds);
+ }
+
+ bool isValid() const { return (version == sizeof(native_handle_t)) && (magic == CB_HANDLE_MAGIC_30); }
+
+ static cb_handle_30_t* from(void* p) {
+ if (!p) { return nullptr; }
+ cb_handle_30_t* cb = static_cast<cb_handle_30_t*>(p);
+ return cb->isValid() ? cb : nullptr;
+ }
+
+ static const cb_handle_30_t* from(const void* p) {
+ return from(const_cast<void*>(p));
+ }
+
+ static cb_handle_30_t* from_unconst(const void* p) {
+ return from(const_cast<void*>(p));
+ }
+
+ uint32_t mmapedSize; // real allocation side
+ uint32_t bytesPerPixel;
+ uint32_t stride;
+};
+
+#endif // SYSTEM_HALS_CB_HANDLE_30_H
diff --git a/system/hals/debug.h b/system/hals/debug.h
new file mode 100644
index 0000000..f8e41b4
--- /dev/null
+++ b/system/hals/debug.h
@@ -0,0 +1,44 @@
+/*
+* Copyright (C) 2020 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.
+*/
+
+#ifndef GOLDFISH_OPENGL_SYSTEM_HALS_DEBUG_H_INCLUDED
+#define GOLDFISH_OPENGL_SYSTEM_HALS_DEBUG_H_INCLUDED
+
+#include <log/log.h>
+
+#define RETURN(X) return (X)
+
+#define RETURN_ERROR(X) \
+ do { \
+ ALOGE("%s:%d failed with '%s'", __func__, __LINE__, #X); \
+ return (X); \
+ } while (false)
+
+#define CRASH(MSG) \
+ do { \
+ ALOGE("%s:%d crashed with '%s'", __func__, __LINE__, MSG); \
+ ::abort(); \
+ } while (false)
+
+#define CRASH_IF(COND, MSG) \
+ do { \
+ if ((COND)) { \
+ ALOGE("%s:%d crashed on '%s' with '%s'", __func__, __LINE__, #COND, MSG); \
+ ::abort(); \
+ } \
+ } while (false)
+
+#endif // GOLDFISH_OPENGL_SYSTEM_HALS_DEBUG_H_INCLUDED
diff --git a/system/hals/host_connection_session.h b/system/hals/host_connection_session.h
new file mode 100644
index 0000000..12d3b76
--- /dev/null
+++ b/system/hals/host_connection_session.h
@@ -0,0 +1,56 @@
+/*
+* Copyright (C) 2020 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.
+*/
+
+#ifndef GOLDFISH_OPENGL_SYSTEM_HALS_HOST_CONNECTION_SESSION_H_INCLUDED
+#define GOLDFISH_OPENGL_SYSTEM_HALS_HOST_CONNECTION_SESSION_H_INCLUDED
+
+#include "HostConnection.h"
+
+class HostConnectionSession {
+public:
+ explicit HostConnectionSession(HostConnection* hc) : conn(hc) {
+ hc->lock();
+ }
+
+ ~HostConnectionSession() {
+ if (conn) {
+ conn->unlock();
+ }
+ }
+
+ HostConnectionSession(HostConnectionSession&& rhs) : conn(rhs.conn) {
+ rhs.conn = nullptr;
+ }
+
+ HostConnectionSession& operator=(HostConnectionSession&& rhs) {
+ if (this != &rhs) {
+ std::swap(conn, rhs.conn);
+ }
+ return *this;
+ }
+
+ HostConnectionSession(const HostConnectionSession&) = delete;
+ HostConnectionSession& operator=(const HostConnectionSession&) = delete;
+
+ ExtendedRCEncoderContext* getRcEncoder() const {
+ return conn->rcEncoder();
+ }
+
+private:
+ HostConnection* conn;
+};
+
+#endif // GOLDFISH_OPENGL_SYSTEM_HALS_HOST_CONNECTION_SESSION_H_INCLUDED
diff --git a/system/hals/mapper3.cpp b/system/hals/mapper3.cpp
new file mode 100644
index 0000000..99c6514
--- /dev/null
+++ b/system/hals/mapper3.cpp
@@ -0,0 +1,615 @@
+/*
+* Copyright (C) 2020 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 <android/hardware/graphics/mapper/3.0/IMapper.h>
+#include <cutils/native_handle.h>
+#include <sync/sync.h>
+
+#include "cb_handle_30.h"
+#include "host_connection_session.h"
+#include "FormatConversions.h"
+#include "debug.h"
+
+using ::android::hardware::hidl_handle;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+
+using ::android::hardware::graphics::common::V1_2::PixelFormat;
+using ::android::hardware::graphics::common::V1_0::BufferUsage;
+
+namespace MapperV3 = ::android::hardware::graphics::mapper::V3_0;
+
+using IMapper3 = MapperV3::IMapper;
+using Error3 = MapperV3::Error;
+using YCbCrLayout3 = MapperV3::YCbCrLayout;
+
+namespace {
+size_t align(const size_t v, const size_t a) { return (v + a - 1) & ~(a - 1); }
+
+static int waitFenceFd(const int fd, const char* logname) {
+ const int warningTimeout = 5000;
+ if (sync_wait(dup(fd), warningTimeout) < 0) {
+ if (errno == ETIME) {
+ ALOGW("%s: fence %d didn't signal in %d ms", logname, fd, warningTimeout);
+ if (sync_wait(fd, -1) < 0) {
+ RETURN_ERROR(errno);
+ } else {
+ RETURN(0);
+ }
+ } else {
+ RETURN_ERROR(errno);
+ }
+ } else {
+ RETURN(0);
+ }
+}
+
+int waitHidlFence(const hidl_handle& hidlHandle, const char* logname) {
+ const native_handle_t* nativeHandle = hidlHandle.getNativeHandle();
+
+ if (!nativeHandle) {
+ RETURN(0);
+ }
+ if (nativeHandle->numFds > 1) {
+ RETURN_ERROR(-EINVAL);
+ }
+ if (nativeHandle->numInts != 0) {
+ RETURN_ERROR(-EINVAL);
+ }
+
+ return waitFenceFd(nativeHandle->data[0], logname);
+}
+
+class GoldfishMapper : public IMapper3 {
+public:
+ GoldfishMapper() : m_hostConn(HostConnection::createUnique()) {
+ GoldfishAddressSpaceHostMemoryAllocator host_memory_allocator;
+ CRASH_IF(!host_memory_allocator.is_opened(),
+ "GoldfishAddressSpaceHostMemoryAllocator failed to open");
+
+ GoldfishAddressSpaceBlock bufferBits;
+ CRASH_IF(host_memory_allocator.hostMalloc(&bufferBits, 256),
+ "hostMalloc failed");
+
+ m_physAddrToOffset = bufferBits.physAddr() - bufferBits.offset();
+ }
+
+ Return<void> importBuffer(const hidl_handle& hh,
+ importBuffer_cb hidl_cb) {
+ native_handle_t* imported = nullptr;
+ const Error3 e = importBufferImpl(hh.getNativeHandle(), &imported);
+ if (e == Error3::NONE) {
+ hidl_cb(Error3::NONE, imported);
+ } else {
+ hidl_cb(e, nullptr);
+ }
+ return {};
+ }
+
+ Return<Error3> freeBuffer(void* raw) {
+ if (!raw) {
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+ cb_handle_30_t* cb = cb_handle_30_t::from(raw);
+ if (!cb) {
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+
+ if (cb->hostHandle) {
+ const HostConnectionSession conn = getHostConnectionSession();
+ ExtendedRCEncoderContext *const rcEnc = conn.getRcEncoder();
+ rcEnc->rcCloseColorBuffer(rcEnc, cb->hostHandle);
+ }
+
+ if (cb->mmapedSize > 0) {
+ GoldfishAddressSpaceBlock::memoryUnmap(cb->getBufferPtr(), cb->mmapedSize);
+ }
+
+ native_handle_close(cb);
+ native_handle_delete(cb);
+
+ RETURN(Error3::NONE);
+ }
+
+ Return<void> lock(void* raw,
+ uint64_t cpuUsage,
+ const Rect& accessRegion,
+ const hidl_handle& acquireFence,
+ lock_cb hidl_cb) {
+ void* ptr = nullptr;
+ int32_t bytesPerPixel = 0;
+ int32_t bytesPerStride = 0;
+
+ const Error3 e = lockImpl(raw, cpuUsage, accessRegion, acquireFence,
+ &ptr, &bytesPerPixel, &bytesPerStride);
+ if (e == Error3::NONE) {
+ hidl_cb(Error3::NONE, ptr, bytesPerPixel, bytesPerStride);
+ } else {
+ hidl_cb(e, nullptr, 0, 0);
+ }
+ return {};
+ }
+
+ Return<void> lockYCbCr(void* raw,
+ uint64_t cpuUsage,
+ const Rect& accessRegion,
+ const hidl_handle& acquireFence,
+ lockYCbCr_cb hidl_cb) {
+ YCbCrLayout3 ycbcr = {};
+ const Error3 e = lockYCbCrImpl(raw, cpuUsage, accessRegion, acquireFence,
+ &ycbcr);
+ if (e == Error3::NONE) {
+ hidl_cb(Error3::NONE, ycbcr);
+ } else {
+ hidl_cb(e, {});
+ }
+ return {};
+ }
+
+ Return<void> unlock(void* raw, unlock_cb hidl_cb) {
+ hidl_cb(unlockImpl(raw), {});
+ return {};
+
+ }
+
+ Return<void> createDescriptor(const BufferDescriptorInfo& description,
+ createDescriptor_cb hidl_cb) {
+ hidl_vec<uint32_t> raw;
+ encodeBufferDescriptorInfo(description, &raw);
+ hidl_cb(Error3::NONE, raw);
+ return {};
+ }
+
+ Return<void> isSupported(const IMapper::BufferDescriptorInfo& description,
+ isSupported_cb hidl_cb) {
+ hidl_cb(Error3::NONE, isSupportedImpl(description));
+ return {};
+ }
+
+ Return<Error3> validateBufferSize(void* buffer,
+ const BufferDescriptorInfo& descriptor,
+ uint32_t stride) {
+ const cb_handle_30_t* cb = cb_handle_30_t::from(buffer);
+ if (cb) {
+ return validateBufferSizeImpl(*cb, descriptor, stride);
+ } else {
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+ }
+
+ Return<void> getTransportSize(void* buffer,
+ getTransportSize_cb hidl_cb) {
+ const cb_handle_30_t* cb = cb_handle_30_t::from(buffer);
+ if (cb) {
+ hidl_cb(Error3::NONE, cb->numFds, cb->numInts);
+ } else {
+ hidl_cb(Error3::BAD_BUFFER, 0, 0);
+ }
+
+ return {};
+ }
+
+private: // **** impl ****
+ Error3 importBufferImpl(const native_handle_t* nh, native_handle_t** phandle) {
+ if (!nh) {
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+ native_handle_t* imported = native_handle_clone(nh);
+ if (!imported) {
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+ cb_handle_30_t* cb = cb_handle_30_t::from(imported);
+ if (!cb) {
+ native_handle_close(imported);
+ native_handle_delete(imported);
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+
+ if (cb->mmapedSize > 0) {
+ void* ptr;
+ const int res = GoldfishAddressSpaceBlock::memoryMap(
+ cb->getBufferPtr(),
+ cb->mmapedSize,
+ cb->bufferFd,
+ cb->getMmapedOffset(),
+ &ptr);
+ if (res) {
+ native_handle_close(imported);
+ native_handle_delete(imported);
+ RETURN_ERROR(Error3::NO_RESOURCES);
+ }
+ cb->setBufferPtr(ptr);
+ }
+
+ if (cb->hostHandle) {
+ const HostConnectionSession conn = getHostConnectionSession();
+ ExtendedRCEncoderContext *const rcEnc = conn.getRcEncoder();
+ rcEnc->rcOpenColorBuffer2(rcEnc, cb->hostHandle);
+ }
+
+ *phandle = imported;
+ RETURN(Error3::NONE);
+ }
+
+ Error3 lockImpl(void* raw,
+ uint64_t cpuUsage,
+ const Rect& accessRegion,
+ const hidl_handle& acquireFence,
+ void** pptr,
+ int32_t* pBytesPerPixel,
+ int32_t* pBytesPerStride) {
+ if (!raw) {
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+ cb_handle_30_t* cb = cb_handle_30_t::from(raw);
+ if (!cb) {
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+ if (!cb->bufferSize) {
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+ char* const bufferBits = static_cast<char*>(cb->getBufferPtr());
+ if (!bufferBits) {
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+ if (waitHidlFence(acquireFence, __func__)) {
+ RETURN_ERROR(Error3::BAD_VALUE);
+ }
+
+ if (cb->hostHandle) {
+ const Error3 e = lockHostImpl(*cb, cpuUsage, accessRegion, bufferBits);
+ if (e != Error3::NONE) {
+ return e;
+ }
+ }
+
+ *pptr = bufferBits;
+ *pBytesPerPixel = cb->bytesPerPixel;
+ *pBytesPerStride = cb->bytesPerPixel * cb->stride;
+ RETURN(Error3::NONE);
+ }
+
+ Error3 lockYCbCrImpl(void* raw,
+ uint64_t cpuUsage,
+ const Rect& accessRegion,
+ const hidl_handle& acquireFence,
+ YCbCrLayout3* pYcbcr) {
+ if (!raw) {
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+ cb_handle_30_t* cb = cb_handle_30_t::from(raw);
+ if (!cb) {
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+ if (!cb->bufferSize) {
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+ char* const bufferBits = static_cast<char*>(cb->getBufferPtr());
+ if (!bufferBits) {
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+ if (waitHidlFence(acquireFence, __func__)) {
+ RETURN_ERROR(Error3::BAD_VALUE);
+ }
+
+ size_t uOffset;
+ size_t vOffset;
+ size_t yStride;
+ size_t cStride;
+ size_t cStep;
+ switch (static_cast<PixelFormat>(cb->format)) {
+ case PixelFormat::YCRCB_420_SP:
+ yStride = cb->width;
+ cStride = yStride;
+ vOffset = yStride * cb->height;
+ uOffset = vOffset + 1;
+ cStep = 2;
+ break;
+
+ case PixelFormat::YV12:
+ // https://developer.android.com/reference/android/graphics/ImageFormat.html#YV12
+ yStride = align(cb->width, 16);
+ cStride = align(yStride / 2, 16);
+ vOffset = yStride * cb->height;
+ uOffset = vOffset + (cStride * cb->height / 2);
+ cStep = 1;
+ break;
+
+ case PixelFormat::YCBCR_420_888:
+ yStride = cb->width;
+ cStride = yStride / 2;
+ uOffset = cb->height * yStride;
+ vOffset = uOffset + cStride * cb->height / 2;
+ cStep = 1;
+ break;
+
+ default:
+ ALOGE("%s:%d unexpected format (%d)", __func__, __LINE__, cb->format);
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+
+ if (cb->hostHandle) {
+ const Error3 e = lockHostImpl(*cb, cpuUsage, accessRegion, bufferBits);
+ if (e != Error3::NONE) {
+ return e;
+ }
+ }
+
+ pYcbcr->y = bufferBits;
+ pYcbcr->cb = bufferBits + uOffset;
+ pYcbcr->cr = bufferBits + vOffset;
+ pYcbcr->yStride = yStride;
+ pYcbcr->cStride = cStride;
+ pYcbcr->chromaStep = cStep;
+
+ RETURN(Error3::NONE);
+ }
+
+ Error3 lockHostImpl(cb_handle_30_t& cb,
+ const uint32_t usage,
+ const Rect& accessRegion,
+ char* const bufferBits) {
+ const bool usageSwRead = usage & BufferUsage::CPU_READ_MASK;
+ const bool usageSwWrite = usage & BufferUsage::CPU_WRITE_MASK;
+ const bool usageHwCamera = usage & (BufferUsage::CAMERA_INPUT | BufferUsage::CAMERA_OUTPUT);
+ const bool usageHwCameraWrite = usage & BufferUsage::CAMERA_OUTPUT;
+
+ const HostConnectionSession conn = getHostConnectionSession();
+ ExtendedRCEncoderContext *const rcEnc = conn.getRcEncoder();
+
+ const int res = rcEnc->rcColorBufferCacheFlush(
+ rcEnc, cb.hostHandle, 0, usageSwRead);
+ if (res < 0) {
+ RETURN_ERROR(Error3::NO_RESOURCES);
+ }
+
+ // camera delivers bits to the buffer directly and does not require
+ // an explicit read.
+ if (usageSwRead && !usageHwCamera) {
+ if (gralloc_is_yuv_format(cb.format)) {
+ if (rcEnc->hasYUVCache()) {
+ uint32_t bufferSize;
+ switch (static_cast<PixelFormat>(cb.format)) {
+ case PixelFormat::YV12:
+ get_yv12_offsets(cb.width, cb.height,
+ nullptr, nullptr, &bufferSize);
+ break;
+ case PixelFormat::YCBCR_420_888:
+ get_yuv420p_offsets(cb.width, cb.height,
+ nullptr, nullptr, &bufferSize);
+ break;
+ default:
+ CRASH("Unexpected format, switch is out of sync with gralloc_is_yuv_format");
+ break;
+ }
+
+ rcEnc->rcReadColorBufferYUV(rcEnc, cb.hostHandle,
+ 0, 0, cb.width, cb.height,
+ bufferBits, bufferSize);
+ } else {
+ // We are using RGB888
+ std::vector<char> tmpBuf(cb.width * cb.height * 3);
+ rcEnc->rcReadColorBuffer(rcEnc, cb.hostHandle,
+ 0, 0, cb.width, cb.height,
+ cb.glFormat, cb.glType,
+ tmpBuf.data());
+ switch (static_cast<PixelFormat>(cb.format)) {
+ case PixelFormat::YV12:
+ rgb888_to_yv12(bufferBits, tmpBuf.data(),
+ cb.width, cb.height,
+ accessRegion.left,
+ accessRegion.top,
+ accessRegion.left + accessRegion.width - 1,
+ accessRegion.top + accessRegion.height - 1);
+ break;
+ case PixelFormat::YCBCR_420_888:
+ rgb888_to_yuv420p(bufferBits, tmpBuf.data(),
+ cb.width, cb.height,
+ accessRegion.left,
+ accessRegion.top,
+ accessRegion.left + accessRegion.width - 1,
+ accessRegion.top + accessRegion.height - 1);
+ break;
+ default:
+ CRASH("Unexpected format, switch is out of sync with gralloc_is_yuv_format");
+ break;
+ }
+ }
+ } else {
+ rcEnc->rcReadColorBuffer(rcEnc,
+ cb.hostHandle,
+ 0, 0, cb.width, cb.height,
+ cb.glFormat, cb.glType,
+ bufferBits);
+ }
+ }
+
+ if (usageSwWrite || usageHwCameraWrite) {
+ cb.lockedLeft = accessRegion.left;
+ cb.lockedTop = accessRegion.top;
+ cb.lockedWidth = accessRegion.width;
+ cb.lockedHeight = accessRegion.height;
+ } else {
+ cb.lockedLeft = 0;
+ cb.lockedTop = 0;
+ cb.lockedWidth = cb.width;
+ cb.lockedHeight = cb.height;
+ }
+
+ RETURN(Error3::NONE);
+ }
+
+ Error3 unlockImpl(void* raw) {
+ if (!raw) {
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+ cb_handle_30_t* cb = cb_handle_30_t::from(raw);
+ if (!cb) {
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+ if (!cb->bufferSize) {
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+ char* const bufferBits = static_cast<char*>(cb->getBufferPtr());
+ if (!bufferBits) {
+ RETURN_ERROR(Error3::BAD_BUFFER);
+ }
+
+ if (cb->hostHandle) {
+ unlockHostImpl(*cb, bufferBits);
+ }
+
+ RETURN(Error3::NONE);
+ }
+
+ void unlockHostImpl(cb_handle_30_t& cb, char* const bufferBits) {
+ const int bpp = glUtilsPixelBitSize(cb.glFormat, cb.glType) >> 3;
+ const int left = cb.lockedLeft;
+ const int top = cb.lockedTop;
+ const int width = cb.lockedWidth;
+ const int height = cb.lockedHeight;
+ const uint32_t rgbSize = width * height * bpp;
+ std::vector<char> convertedBuf;
+ const char* bitsToSend;
+ uint32_t sizeToSend;
+
+ if (gralloc_is_yuv_format(cb.format)) {
+ bitsToSend = bufferBits;
+ switch (static_cast<PixelFormat>(cb.format)) {
+ case PixelFormat::YV12:
+ get_yv12_offsets(width, height, nullptr, nullptr, &sizeToSend);
+ break;
+ case PixelFormat::YCBCR_420_888:
+ get_yuv420p_offsets(width, height, nullptr, nullptr, &sizeToSend);
+ break;
+ default:
+ CRASH("Unexpected format, switch is out of sync with gralloc_is_yuv_format");
+ break;
+ }
+ } else {
+ convertedBuf.resize(rgbSize);
+ copy_rgb_buffer_from_unlocked(
+ convertedBuf.data(), bufferBits,
+ cb.width,
+ width, height, top, left, bpp);
+ bitsToSend = convertedBuf.data();
+ sizeToSend = rgbSize;
+ }
+
+ {
+ const HostConnectionSession conn = getHostConnectionSession();
+ ExtendedRCEncoderContext *const rcEnc = conn.getRcEncoder();
+ rcEnc->bindDmaDirectly(bufferBits,
+ getMmapedPhysAddr(cb.getMmapedOffset()));
+ rcEnc->rcUpdateColorBufferDMA(rcEnc, cb.hostHandle,
+ left, top, width, height,
+ cb.glFormat, cb.glType,
+ const_cast<char*>(bitsToSend), sizeToSend);
+ }
+
+ cb.lockedLeft = 0;
+ cb.lockedTop = 0;
+ cb.lockedWidth = 0;
+ cb.lockedHeight = 0;
+ }
+
+ bool isSupportedImpl(const IMapper::BufferDescriptorInfo& descriptor) const {
+ if (!descriptor.width) { RETURN(false); }
+ if (!descriptor.height) { RETURN(false); }
+ if (descriptor.layerCount != 1) { RETURN(false); }
+
+ const uint32_t usage = descriptor.usage;
+ const bool usageSwWrite = usage & BufferUsage::CPU_WRITE_MASK;
+ const bool usageSwRead = usage & BufferUsage::CPU_READ_MASK;
+ const bool usageHwCamWrite = usage & BufferUsage::CAMERA_OUTPUT;
+ const bool usageHwCamRead = usage & BufferUsage::CAMERA_INPUT;
+
+ switch (descriptor.format) {
+ case PixelFormat::RGBA_8888:
+ case PixelFormat::RGBX_8888:
+ case PixelFormat::BGRA_8888:
+ case PixelFormat::RGB_565:
+ case PixelFormat::RGBA_FP16:
+ case PixelFormat::RGBA_1010102:
+ case PixelFormat::YCRCB_420_SP:
+ case PixelFormat::YV12:
+ case PixelFormat::YCBCR_420_888:
+ RETURN(true);
+
+ case PixelFormat::IMPLEMENTATION_DEFINED:
+ if (usage & BufferUsage::CAMERA_OUTPUT) {
+ if (usage & BufferUsage::GPU_TEXTURE) {
+ RETURN(true);
+ } else if (usage & BufferUsage::VIDEO_ENCODER) {
+ RETURN(true);
+ }
+ }
+ RETURN(false);
+
+ case PixelFormat::RGB_888:
+ RETURN(0 == (usage & (BufferUsage::GPU_TEXTURE |
+ BufferUsage::GPU_RENDER_TARGET |
+ BufferUsage::COMPOSER_OVERLAY |
+ BufferUsage::COMPOSER_CLIENT_TARGET)));
+
+ case PixelFormat::RAW16:
+ case PixelFormat::Y16:
+ RETURN((usageSwRead || usageHwCamRead) &&
+ (usageSwWrite || usageHwCamWrite));
+
+ case PixelFormat::BLOB:
+ RETURN(usageSwRead);
+
+ default:
+ RETURN(false);
+ }
+ }
+
+ Error3 validateBufferSizeImpl(const cb_handle_t& /*cb*/,
+ const BufferDescriptorInfo& /*descriptor*/,
+ uint32_t /*stride*/) {
+ RETURN(Error3::NONE);
+ }
+
+ HostConnectionSession getHostConnectionSession() const {
+ return HostConnectionSession(m_hostConn);
+ }
+
+ static void encodeBufferDescriptorInfo(const BufferDescriptorInfo& d,
+ hidl_vec<uint32_t>* raw) {
+ raw->resize(5);
+
+ (*raw)[0] = d.width;
+ (*raw)[1] = d.height;
+ (*raw)[2] = d.layerCount;
+ (*raw)[3] = static_cast<uint32_t>(d.format);
+ (*raw)[4] = d.usage & UINT32_MAX;
+ }
+
+ uint64_t getMmapedPhysAddr(uint64_t offset) const {
+ return m_physAddrToOffset + offset;
+ }
+
+ //std::unique_ptr<HostConnection> m_hostConn; // b/142677230
+ HostConnection* m_hostConn;
+ uint64_t m_physAddrToOffset;
+};
+} // namespace
+
+extern "C" IMapper3* HIDL_FETCH_IMapper(const char* /*name*/) {
+ return new GoldfishMapper;
+}
diff --git a/system/hals/types.h b/system/hals/types.h
new file mode 100644
index 0000000..c7d2646
--- /dev/null
+++ b/system/hals/types.h
@@ -0,0 +1,43 @@
+/*
+* Copyright (C) 2020 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.
+*/
+
+#ifndef GOLDFISH_OPENGL_SYSTEM_HALS_TYPES_H_INCLUDED
+#define GOLDFISH_OPENGL_SYSTEM_HALS_TYPES_H_INCLUDED
+
+/* Tell the emulator which formats need special handling. */
+enum class EmulatorFrameworkFormat {
+ GL_COMPATIBLE = 0,
+ YV12 = 1,
+ YUV_420_888 = 2, // (Y+)(U+)(V+)
+};
+
+#ifndef GL_RGBA16F
+#define GL_RGBA16F 0x881A
+#endif // GL_RGBA16F
+
+#ifndef GL_HALF_FLOAT
+#define GL_HALF_FLOAT 0x140B
+#endif // GL_HALF_FLOAT
+
+#ifndef GL_RGB10_A2
+#define GL_RGB10_A2 0x8059
+#endif // GL_RGB10_A2
+
+#ifndef GL_UNSIGNED_INT_2_10_10_10_REV
+#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368
+#endif // GL_UNSIGNED_INT_2_10_10_10_REV
+
+#endif // GOLDFISH_OPENGL_SYSTEM_HALS_TYPES_H_INCLUDED
diff --git a/system/vulkan_enc/ResourceTracker.cpp b/system/vulkan_enc/ResourceTracker.cpp
index 1210bc6..9857952 100644
--- a/system/vulkan_enc/ResourceTracker.cpp
+++ b/system/vulkan_enc/ResourceTracker.cpp
@@ -614,6 +614,9 @@
if (mFeatureInfo->hasVulkanNullOptionalStrings) {
mStreamFeatureBits |= VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT;
}
+ if (mFeatureInfo->hasVulkanIgnoredHandles) {
+ mStreamFeatureBits |= VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT;
+ }
}
void setThreadingCallbacks(const ResourceTracker::ThreadingCallbacks& callbacks) {
diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
index 6e3aec5..1ef4d04 100644
--- a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
@@ -2594,6 +2594,20 @@
VulkanStreamGuest* vkStream,
const VkGraphicsPipelineCreateInfo* forMarshaling)
{
+ uint32_t hasRasterization = 1;
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+ {
+ hasRasterization = (((0 == forMarshaling->pRasterizationState)) ? (0) : (!((*(forMarshaling->pRasterizationState)).rasterizerDiscardEnable)));
+ uint32_t cgen_var_70 = (uint32_t)hasRasterization;
+ vkStream->putBe32(cgen_var_70);
+ }
+ uint32_t hasTessellation = 1;
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+ {
+ hasTessellation = arrayany(forMarshaling->pStages, 0, forMarshaling->stageCount, [](VkPipelineShaderStageCreateInfo s) { return ((s.stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) || (s.stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)); });
+ uint32_t cgen_var_71 = (uint32_t)hasTessellation;
+ vkStream->putBe32(cgen_var_71);
+ }
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
vkStream->putBe32(pNext_size);
@@ -2608,61 +2622,103 @@
{
marshal_VkPipelineShaderStageCreateInfo(vkStream, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
}
- marshal_VkPipelineVertexInputStateCreateInfo(vkStream, (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState));
- marshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, (const VkPipelineInputAssemblyStateCreateInfo*)(forMarshaling->pInputAssemblyState));
// WARNING PTR CHECK
- uint64_t cgen_var_70 = (uint64_t)(uintptr_t)forMarshaling->pTessellationState;
- vkStream->putBe64(cgen_var_70);
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+ {
+ uint64_t cgen_var_72 = (uint64_t)(uintptr_t)forMarshaling->pVertexInputState;
+ vkStream->putBe64(cgen_var_72);
+ }
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forMarshaling->pVertexInputState))
+ {
+ marshal_VkPipelineVertexInputStateCreateInfo(vkStream, (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState));
+ }
+ // WARNING PTR CHECK
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+ {
+ uint64_t cgen_var_73 = (uint64_t)(uintptr_t)forMarshaling->pInputAssemblyState;
+ vkStream->putBe64(cgen_var_73);
+ }
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forMarshaling->pInputAssemblyState))
+ {
+ marshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, (const VkPipelineInputAssemblyStateCreateInfo*)(forMarshaling->pInputAssemblyState));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_74 = (uint64_t)(uintptr_t)forMarshaling->pTessellationState;
+ vkStream->putBe64(cgen_var_74);
if (forMarshaling->pTessellationState)
{
- marshal_VkPipelineTessellationStateCreateInfo(vkStream, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState));
+ if (hasTessellation)
+ {
+ marshal_VkPipelineTessellationStateCreateInfo(vkStream, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState));
+ }
}
// WARNING PTR CHECK
- uint64_t cgen_var_71 = (uint64_t)(uintptr_t)forMarshaling->pViewportState;
- vkStream->putBe64(cgen_var_71);
+ uint64_t cgen_var_75 = (uint64_t)(uintptr_t)forMarshaling->pViewportState;
+ vkStream->putBe64(cgen_var_75);
if (forMarshaling->pViewportState)
{
- marshal_VkPipelineViewportStateCreateInfo(vkStream, (const VkPipelineViewportStateCreateInfo*)(forMarshaling->pViewportState));
+ if (hasRasterization)
+ {
+ marshal_VkPipelineViewportStateCreateInfo(vkStream, (const VkPipelineViewportStateCreateInfo*)(forMarshaling->pViewportState));
+ }
}
- marshal_VkPipelineRasterizationStateCreateInfo(vkStream, (const VkPipelineRasterizationStateCreateInfo*)(forMarshaling->pRasterizationState));
// WARNING PTR CHECK
- uint64_t cgen_var_72 = (uint64_t)(uintptr_t)forMarshaling->pMultisampleState;
- vkStream->putBe64(cgen_var_72);
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+ {
+ uint64_t cgen_var_76 = (uint64_t)(uintptr_t)forMarshaling->pRasterizationState;
+ vkStream->putBe64(cgen_var_76);
+ }
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forMarshaling->pRasterizationState))
+ {
+ marshal_VkPipelineRasterizationStateCreateInfo(vkStream, (const VkPipelineRasterizationStateCreateInfo*)(forMarshaling->pRasterizationState));
+ }
+ // WARNING PTR CHECK
+ uint64_t cgen_var_77 = (uint64_t)(uintptr_t)forMarshaling->pMultisampleState;
+ vkStream->putBe64(cgen_var_77);
if (forMarshaling->pMultisampleState)
{
- marshal_VkPipelineMultisampleStateCreateInfo(vkStream, (const VkPipelineMultisampleStateCreateInfo*)(forMarshaling->pMultisampleState));
+ if (hasRasterization)
+ {
+ marshal_VkPipelineMultisampleStateCreateInfo(vkStream, (const VkPipelineMultisampleStateCreateInfo*)(forMarshaling->pMultisampleState));
+ }
}
// WARNING PTR CHECK
- uint64_t cgen_var_73 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilState;
- vkStream->putBe64(cgen_var_73);
+ uint64_t cgen_var_78 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilState;
+ vkStream->putBe64(cgen_var_78);
if (forMarshaling->pDepthStencilState)
{
- marshal_VkPipelineDepthStencilStateCreateInfo(vkStream, (const VkPipelineDepthStencilStateCreateInfo*)(forMarshaling->pDepthStencilState));
+ if (hasRasterization)
+ {
+ marshal_VkPipelineDepthStencilStateCreateInfo(vkStream, (const VkPipelineDepthStencilStateCreateInfo*)(forMarshaling->pDepthStencilState));
+ }
}
// WARNING PTR CHECK
- uint64_t cgen_var_74 = (uint64_t)(uintptr_t)forMarshaling->pColorBlendState;
- vkStream->putBe64(cgen_var_74);
+ uint64_t cgen_var_79 = (uint64_t)(uintptr_t)forMarshaling->pColorBlendState;
+ vkStream->putBe64(cgen_var_79);
if (forMarshaling->pColorBlendState)
{
- marshal_VkPipelineColorBlendStateCreateInfo(vkStream, (const VkPipelineColorBlendStateCreateInfo*)(forMarshaling->pColorBlendState));
+ if (hasRasterization)
+ {
+ marshal_VkPipelineColorBlendStateCreateInfo(vkStream, (const VkPipelineColorBlendStateCreateInfo*)(forMarshaling->pColorBlendState));
+ }
}
// WARNING PTR CHECK
- uint64_t cgen_var_75 = (uint64_t)(uintptr_t)forMarshaling->pDynamicState;
- vkStream->putBe64(cgen_var_75);
+ uint64_t cgen_var_80 = (uint64_t)(uintptr_t)forMarshaling->pDynamicState;
+ vkStream->putBe64(cgen_var_80);
if (forMarshaling->pDynamicState)
{
marshal_VkPipelineDynamicStateCreateInfo(vkStream, (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState));
}
- uint64_t cgen_var_76;
- vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_76, 1);
- vkStream->write((uint64_t*)&cgen_var_76, 1 * 8);
- uint64_t cgen_var_77;
- vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_77, 1);
- vkStream->write((uint64_t*)&cgen_var_77, 1 * 8);
+ uint64_t cgen_var_81;
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_81, 1);
+ vkStream->write((uint64_t*)&cgen_var_81, 1 * 8);
+ uint64_t cgen_var_82;
+ vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_82, 1);
+ vkStream->write((uint64_t*)&cgen_var_82, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
- uint64_t cgen_var_78;
- vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle, &cgen_var_78, 1);
- vkStream->write((uint64_t*)&cgen_var_78, 1 * 8);
+ uint64_t cgen_var_83;
+ vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle, &cgen_var_83, 1);
+ vkStream->write((uint64_t*)&cgen_var_83, 1 * 8);
vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
}
@@ -2670,6 +2726,16 @@
VulkanStreamGuest* vkStream,
VkGraphicsPipelineCreateInfo* forUnmarshaling)
{
+ uint32_t hasRasterization = 1;
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+ {
+ hasRasterization = (const uint32_t)vkStream->getBe32();
+ }
+ uint32_t hasTessellation = 1;
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+ {
+ hasTessellation = (const uint32_t)vkStream->getBe32();
+ }
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
size_t pNext_size;
pNext_size = vkStream->getBe32();
@@ -2685,8 +2751,26 @@
{
unmarshal_VkPipelineShaderStageCreateInfo(vkStream, (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
}
- unmarshal_VkPipelineVertexInputStateCreateInfo(vkStream, (VkPipelineVertexInputStateCreateInfo*)(forUnmarshaling->pVertexInputState));
- unmarshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, (VkPipelineInputAssemblyStateCreateInfo*)(forUnmarshaling->pInputAssemblyState));
+ // WARNING PTR CHECK
+ const VkPipelineVertexInputStateCreateInfo* check_pVertexInputState;
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+ {
+ check_pVertexInputState = (const VkPipelineVertexInputStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ }
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forUnmarshaling->pVertexInputState))
+ {
+ unmarshal_VkPipelineVertexInputStateCreateInfo(vkStream, (VkPipelineVertexInputStateCreateInfo*)(forUnmarshaling->pVertexInputState));
+ }
+ // WARNING PTR CHECK
+ const VkPipelineInputAssemblyStateCreateInfo* check_pInputAssemblyState;
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+ {
+ check_pInputAssemblyState = (const VkPipelineInputAssemblyStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ }
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forUnmarshaling->pInputAssemblyState))
+ {
+ unmarshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, (VkPipelineInputAssemblyStateCreateInfo*)(forUnmarshaling->pInputAssemblyState));
+ }
// WARNING PTR CHECK
const VkPipelineTessellationStateCreateInfo* check_pTessellationState;
check_pTessellationState = (const VkPipelineTessellationStateCreateInfo*)(uintptr_t)vkStream->getBe64();
@@ -2696,7 +2780,14 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pTessellationState inconsistent between guest and host\n");
}
- unmarshal_VkPipelineTessellationStateCreateInfo(vkStream, (VkPipelineTessellationStateCreateInfo*)(forUnmarshaling->pTessellationState));
+ if (hasTessellation)
+ {
+ unmarshal_VkPipelineTessellationStateCreateInfo(vkStream, (VkPipelineTessellationStateCreateInfo*)(forUnmarshaling->pTessellationState));
+ }
+ else
+ {
+ forUnmarshaling->pTessellationState = 0;
+ }
}
// WARNING PTR CHECK
const VkPipelineViewportStateCreateInfo* check_pViewportState;
@@ -2707,9 +2798,25 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pViewportState inconsistent between guest and host\n");
}
- unmarshal_VkPipelineViewportStateCreateInfo(vkStream, (VkPipelineViewportStateCreateInfo*)(forUnmarshaling->pViewportState));
+ if (hasRasterization)
+ {
+ unmarshal_VkPipelineViewportStateCreateInfo(vkStream, (VkPipelineViewportStateCreateInfo*)(forUnmarshaling->pViewportState));
+ }
+ else
+ {
+ forUnmarshaling->pViewportState = 0;
+ }
}
- unmarshal_VkPipelineRasterizationStateCreateInfo(vkStream, (VkPipelineRasterizationStateCreateInfo*)(forUnmarshaling->pRasterizationState));
+ // WARNING PTR CHECK
+ const VkPipelineRasterizationStateCreateInfo* check_pRasterizationState;
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+ {
+ check_pRasterizationState = (const VkPipelineRasterizationStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ }
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forUnmarshaling->pRasterizationState))
+ {
+ unmarshal_VkPipelineRasterizationStateCreateInfo(vkStream, (VkPipelineRasterizationStateCreateInfo*)(forUnmarshaling->pRasterizationState));
+ }
// WARNING PTR CHECK
const VkPipelineMultisampleStateCreateInfo* check_pMultisampleState;
check_pMultisampleState = (const VkPipelineMultisampleStateCreateInfo*)(uintptr_t)vkStream->getBe64();
@@ -2719,7 +2826,14 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pMultisampleState inconsistent between guest and host\n");
}
- unmarshal_VkPipelineMultisampleStateCreateInfo(vkStream, (VkPipelineMultisampleStateCreateInfo*)(forUnmarshaling->pMultisampleState));
+ if (hasRasterization)
+ {
+ unmarshal_VkPipelineMultisampleStateCreateInfo(vkStream, (VkPipelineMultisampleStateCreateInfo*)(forUnmarshaling->pMultisampleState));
+ }
+ else
+ {
+ forUnmarshaling->pMultisampleState = 0;
+ }
}
// WARNING PTR CHECK
const VkPipelineDepthStencilStateCreateInfo* check_pDepthStencilState;
@@ -2730,7 +2844,14 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pDepthStencilState inconsistent between guest and host\n");
}
- unmarshal_VkPipelineDepthStencilStateCreateInfo(vkStream, (VkPipelineDepthStencilStateCreateInfo*)(forUnmarshaling->pDepthStencilState));
+ if (hasRasterization)
+ {
+ unmarshal_VkPipelineDepthStencilStateCreateInfo(vkStream, (VkPipelineDepthStencilStateCreateInfo*)(forUnmarshaling->pDepthStencilState));
+ }
+ else
+ {
+ forUnmarshaling->pDepthStencilState = 0;
+ }
}
// WARNING PTR CHECK
const VkPipelineColorBlendStateCreateInfo* check_pColorBlendState;
@@ -2741,7 +2862,14 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pColorBlendState inconsistent between guest and host\n");
}
- unmarshal_VkPipelineColorBlendStateCreateInfo(vkStream, (VkPipelineColorBlendStateCreateInfo*)(forUnmarshaling->pColorBlendState));
+ if (hasRasterization)
+ {
+ unmarshal_VkPipelineColorBlendStateCreateInfo(vkStream, (VkPipelineColorBlendStateCreateInfo*)(forUnmarshaling->pColorBlendState));
+ }
+ else
+ {
+ forUnmarshaling->pColorBlendState = 0;
+ }
}
// WARNING PTR CHECK
const VkPipelineDynamicStateCreateInfo* check_pDynamicState;
@@ -2754,16 +2882,16 @@
}
unmarshal_VkPipelineDynamicStateCreateInfo(vkStream, (VkPipelineDynamicStateCreateInfo*)(forUnmarshaling->pDynamicState));
}
- uint64_t cgen_var_85;
- vkStream->read((uint64_t*)&cgen_var_85, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_85, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
- uint64_t cgen_var_86;
- vkStream->read((uint64_t*)&cgen_var_86, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_86, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+ uint64_t cgen_var_95;
+ vkStream->read((uint64_t*)&cgen_var_95, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_95, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
+ uint64_t cgen_var_96;
+ vkStream->read((uint64_t*)&cgen_var_96, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_96, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
vkStream->read((uint32_t*)&forUnmarshaling->subpass, sizeof(uint32_t));
- uint64_t cgen_var_87;
- vkStream->read((uint64_t*)&cgen_var_87, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_87, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
+ uint64_t cgen_var_97;
+ vkStream->read((uint64_t*)&cgen_var_97, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_97, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
}
@@ -2781,12 +2909,12 @@
}
vkStream->write((VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
marshal_VkPipelineShaderStageCreateInfo(vkStream, (VkPipelineShaderStageCreateInfo*)(&forMarshaling->stage));
- uint64_t cgen_var_88;
- vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_88, 1);
- vkStream->write((uint64_t*)&cgen_var_88, 1 * 8);
- uint64_t cgen_var_89;
- vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle, &cgen_var_89, 1);
- vkStream->write((uint64_t*)&cgen_var_89, 1 * 8);
+ uint64_t cgen_var_98;
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_98, 1);
+ vkStream->write((uint64_t*)&cgen_var_98, 1 * 8);
+ uint64_t cgen_var_99;
+ vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle, &cgen_var_99, 1);
+ vkStream->write((uint64_t*)&cgen_var_99, 1 * 8);
vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
}
@@ -2805,12 +2933,12 @@
}
vkStream->read((VkPipelineCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCreateFlags));
unmarshal_VkPipelineShaderStageCreateInfo(vkStream, (VkPipelineShaderStageCreateInfo*)(&forUnmarshaling->stage));
- uint64_t cgen_var_90;
- vkStream->read((uint64_t*)&cgen_var_90, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_90, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
- uint64_t cgen_var_91;
- vkStream->read((uint64_t*)&cgen_var_91, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_91, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
+ uint64_t cgen_var_100;
+ vkStream->read((uint64_t*)&cgen_var_100, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_100, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
+ uint64_t cgen_var_101;
+ vkStream->read((uint64_t*)&cgen_var_101, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_101, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
}
@@ -2848,10 +2976,10 @@
vkStream->write((uint32_t*)&forMarshaling->setLayoutCount, sizeof(uint32_t));
if (forMarshaling->setLayoutCount)
{
- uint64_t* cgen_var_92;
- vkStream->alloc((void**)&cgen_var_92, forMarshaling->setLayoutCount * 8);
- vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(forMarshaling->pSetLayouts, cgen_var_92, forMarshaling->setLayoutCount);
- vkStream->write((uint64_t*)cgen_var_92, forMarshaling->setLayoutCount * 8);
+ uint64_t* cgen_var_102;
+ vkStream->alloc((void**)&cgen_var_102, forMarshaling->setLayoutCount * 8);
+ vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(forMarshaling->pSetLayouts, cgen_var_102, forMarshaling->setLayoutCount);
+ vkStream->write((uint64_t*)cgen_var_102, forMarshaling->setLayoutCount * 8);
}
vkStream->write((uint32_t*)&forMarshaling->pushConstantRangeCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)forMarshaling->pushConstantRangeCount; ++i)
@@ -2877,10 +3005,10 @@
vkStream->read((uint32_t*)&forUnmarshaling->setLayoutCount, sizeof(uint32_t));
if (forUnmarshaling->setLayoutCount)
{
- uint64_t* cgen_var_93;
- vkStream->alloc((void**)&cgen_var_93, forUnmarshaling->setLayoutCount * 8);
- vkStream->read((uint64_t*)cgen_var_93, forUnmarshaling->setLayoutCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(cgen_var_93, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts, forUnmarshaling->setLayoutCount);
+ uint64_t* cgen_var_103;
+ vkStream->alloc((void**)&cgen_var_103, forUnmarshaling->setLayoutCount * 8);
+ vkStream->read((uint64_t*)cgen_var_103, forUnmarshaling->setLayoutCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(cgen_var_103, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts, forUnmarshaling->setLayoutCount);
}
vkStream->read((uint32_t*)&forUnmarshaling->pushConstantRangeCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pushConstantRangeCount; ++i)
@@ -2959,16 +3087,16 @@
vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
vkStream->write((VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
// WARNING PTR CHECK
- uint64_t cgen_var_94 = (uint64_t)(uintptr_t)forMarshaling->pImmutableSamplers;
- vkStream->putBe64(cgen_var_94);
+ uint64_t cgen_var_104 = (uint64_t)(uintptr_t)forMarshaling->pImmutableSamplers;
+ vkStream->putBe64(cgen_var_104);
if (forMarshaling->pImmutableSamplers)
{
if (forMarshaling->descriptorCount)
{
- uint64_t* cgen_var_95;
- vkStream->alloc((void**)&cgen_var_95, forMarshaling->descriptorCount * 8);
- vkStream->handleMapping()->mapHandles_VkSampler_u64(forMarshaling->pImmutableSamplers, cgen_var_95, forMarshaling->descriptorCount);
- vkStream->write((uint64_t*)cgen_var_95, forMarshaling->descriptorCount * 8);
+ uint64_t* cgen_var_105;
+ vkStream->alloc((void**)&cgen_var_105, forMarshaling->descriptorCount * 8);
+ vkStream->handleMapping()->mapHandles_VkSampler_u64(forMarshaling->pImmutableSamplers, cgen_var_105, forMarshaling->descriptorCount);
+ vkStream->write((uint64_t*)cgen_var_105, forMarshaling->descriptorCount * 8);
}
}
}
@@ -2992,10 +3120,10 @@
}
if (forUnmarshaling->descriptorCount)
{
- uint64_t* cgen_var_97;
- vkStream->alloc((void**)&cgen_var_97, forUnmarshaling->descriptorCount * 8);
- vkStream->read((uint64_t*)cgen_var_97, forUnmarshaling->descriptorCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSampler(cgen_var_97, (VkSampler*)forUnmarshaling->pImmutableSamplers, forUnmarshaling->descriptorCount);
+ uint64_t* cgen_var_107;
+ vkStream->alloc((void**)&cgen_var_107, forUnmarshaling->descriptorCount * 8);
+ vkStream->read((uint64_t*)cgen_var_107, forUnmarshaling->descriptorCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSampler(cgen_var_107, (VkSampler*)forUnmarshaling->pImmutableSamplers, forUnmarshaling->descriptorCount);
}
}
}
@@ -3112,16 +3240,16 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_98;
- vkStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&forMarshaling->descriptorPool, &cgen_var_98, 1);
- vkStream->write((uint64_t*)&cgen_var_98, 1 * 8);
+ uint64_t cgen_var_108;
+ vkStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&forMarshaling->descriptorPool, &cgen_var_108, 1);
+ vkStream->write((uint64_t*)&cgen_var_108, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->descriptorSetCount, sizeof(uint32_t));
if (forMarshaling->descriptorSetCount)
{
- uint64_t* cgen_var_99;
- vkStream->alloc((void**)&cgen_var_99, forMarshaling->descriptorSetCount * 8);
- vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(forMarshaling->pSetLayouts, cgen_var_99, forMarshaling->descriptorSetCount);
- vkStream->write((uint64_t*)cgen_var_99, forMarshaling->descriptorSetCount * 8);
+ uint64_t* cgen_var_109;
+ vkStream->alloc((void**)&cgen_var_109, forMarshaling->descriptorSetCount * 8);
+ vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(forMarshaling->pSetLayouts, cgen_var_109, forMarshaling->descriptorSetCount);
+ vkStream->write((uint64_t*)cgen_var_109, forMarshaling->descriptorSetCount * 8);
}
}
@@ -3138,16 +3266,16 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_100;
- vkStream->read((uint64_t*)&cgen_var_100, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_100, (VkDescriptorPool*)&forUnmarshaling->descriptorPool, 1);
+ uint64_t cgen_var_110;
+ vkStream->read((uint64_t*)&cgen_var_110, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_110, (VkDescriptorPool*)&forUnmarshaling->descriptorPool, 1);
vkStream->read((uint32_t*)&forUnmarshaling->descriptorSetCount, sizeof(uint32_t));
if (forUnmarshaling->descriptorSetCount)
{
- uint64_t* cgen_var_101;
- vkStream->alloc((void**)&cgen_var_101, forUnmarshaling->descriptorSetCount * 8);
- vkStream->read((uint64_t*)cgen_var_101, forUnmarshaling->descriptorSetCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(cgen_var_101, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts, forUnmarshaling->descriptorSetCount);
+ uint64_t* cgen_var_111;
+ vkStream->alloc((void**)&cgen_var_111, forUnmarshaling->descriptorSetCount * 8);
+ vkStream->read((uint64_t*)cgen_var_111, forUnmarshaling->descriptorSetCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(cgen_var_111, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts, forUnmarshaling->descriptorSetCount);
}
}
@@ -3155,12 +3283,12 @@
VulkanStreamGuest* vkStream,
const VkDescriptorImageInfo* forMarshaling)
{
- uint64_t cgen_var_102;
- vkStream->handleMapping()->mapHandles_VkSampler_u64(&forMarshaling->sampler, &cgen_var_102, 1);
- vkStream->write((uint64_t*)&cgen_var_102, 1 * 8);
- uint64_t cgen_var_103;
- vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_103, 1);
- vkStream->write((uint64_t*)&cgen_var_103, 1 * 8);
+ uint64_t cgen_var_112;
+ vkStream->handleMapping()->mapHandles_VkSampler_u64(&forMarshaling->sampler, &cgen_var_112, 1);
+ vkStream->write((uint64_t*)&cgen_var_112, 1 * 8);
+ uint64_t cgen_var_113;
+ vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_113, 1);
+ vkStream->write((uint64_t*)&cgen_var_113, 1 * 8);
vkStream->write((VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
}
@@ -3168,12 +3296,12 @@
VulkanStreamGuest* vkStream,
VkDescriptorImageInfo* forUnmarshaling)
{
- uint64_t cgen_var_104;
- vkStream->read((uint64_t*)&cgen_var_104, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_104, (VkSampler*)&forUnmarshaling->sampler, 1);
- uint64_t cgen_var_105;
- vkStream->read((uint64_t*)&cgen_var_105, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_105, (VkImageView*)&forUnmarshaling->imageView, 1);
+ uint64_t cgen_var_114;
+ vkStream->read((uint64_t*)&cgen_var_114, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_114, (VkSampler*)&forUnmarshaling->sampler, 1);
+ uint64_t cgen_var_115;
+ vkStream->read((uint64_t*)&cgen_var_115, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_115, (VkImageView*)&forUnmarshaling->imageView, 1);
vkStream->read((VkImageLayout*)&forUnmarshaling->imageLayout, sizeof(VkImageLayout));
}
@@ -3181,9 +3309,9 @@
VulkanStreamGuest* vkStream,
const VkDescriptorBufferInfo* forMarshaling)
{
- uint64_t cgen_var_106;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_106, 1);
- vkStream->write((uint64_t*)&cgen_var_106, 1 * 8);
+ uint64_t cgen_var_116;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_116, 1);
+ vkStream->write((uint64_t*)&cgen_var_116, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->range, sizeof(VkDeviceSize));
}
@@ -3192,9 +3320,9 @@
VulkanStreamGuest* vkStream,
VkDescriptorBufferInfo* forUnmarshaling)
{
- uint64_t cgen_var_107;
- vkStream->read((uint64_t*)&cgen_var_107, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_107, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ uint64_t cgen_var_117;
+ vkStream->read((uint64_t*)&cgen_var_117, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_117, (VkBuffer*)&forUnmarshaling->buffer, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->range, sizeof(VkDeviceSize));
}
@@ -3211,19 +3339,19 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_108;
- vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_108, 1);
- vkStream->write((uint64_t*)&cgen_var_108, 1 * 8);
+ uint64_t cgen_var_118;
+ vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_118, 1);
+ vkStream->write((uint64_t*)&cgen_var_118, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
vkStream->write((VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
// WARNING PTR CHECK
- uint64_t cgen_var_109 = (uint64_t)(uintptr_t)forMarshaling->pImageInfo;
- vkStream->putBe64(cgen_var_109);
+ uint64_t cgen_var_119 = (uint64_t)(uintptr_t)forMarshaling->pImageInfo;
+ vkStream->putBe64(cgen_var_119);
if (forMarshaling->pImageInfo)
{
- if ((VK_DESCRIPTOR_TYPE_SAMPLER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == forMarshaling->descriptorType))
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_SAMPLER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == forMarshaling->descriptorType))))
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i)
{
@@ -3232,11 +3360,11 @@
}
}
// WARNING PTR CHECK
- uint64_t cgen_var_110 = (uint64_t)(uintptr_t)forMarshaling->pBufferInfo;
- vkStream->putBe64(cgen_var_110);
+ uint64_t cgen_var_120 = (uint64_t)(uintptr_t)forMarshaling->pBufferInfo;
+ vkStream->putBe64(cgen_var_120);
if (forMarshaling->pBufferInfo)
{
- if ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == forMarshaling->descriptorType))
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == forMarshaling->descriptorType))))
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i)
{
@@ -3245,18 +3373,18 @@
}
}
// WARNING PTR CHECK
- uint64_t cgen_var_111 = (uint64_t)(uintptr_t)forMarshaling->pTexelBufferView;
- vkStream->putBe64(cgen_var_111);
+ uint64_t cgen_var_121 = (uint64_t)(uintptr_t)forMarshaling->pTexelBufferView;
+ vkStream->putBe64(cgen_var_121);
if (forMarshaling->pTexelBufferView)
{
- if ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == forMarshaling->descriptorType))
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == forMarshaling->descriptorType))))
{
if (forMarshaling->descriptorCount)
{
- uint64_t* cgen_var_112;
- vkStream->alloc((void**)&cgen_var_112, forMarshaling->descriptorCount * 8);
- vkStream->handleMapping()->mapHandles_VkBufferView_u64(forMarshaling->pTexelBufferView, cgen_var_112, forMarshaling->descriptorCount);
- vkStream->write((uint64_t*)cgen_var_112, forMarshaling->descriptorCount * 8);
+ uint64_t* cgen_var_122;
+ vkStream->alloc((void**)&cgen_var_122, forMarshaling->descriptorCount * 8);
+ vkStream->handleMapping()->mapHandles_VkBufferView_u64(forMarshaling->pTexelBufferView, cgen_var_122, forMarshaling->descriptorCount);
+ vkStream->write((uint64_t*)cgen_var_122, forMarshaling->descriptorCount * 8);
}
}
}
@@ -3275,9 +3403,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_113;
- vkStream->read((uint64_t*)&cgen_var_113, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_113, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
+ uint64_t cgen_var_123;
+ vkStream->read((uint64_t*)&cgen_var_123, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_123, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
vkStream->read((uint32_t*)&forUnmarshaling->dstBinding, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->dstArrayElement, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
@@ -3291,7 +3419,7 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pImageInfo inconsistent between guest and host\n");
}
- if ((VK_DESCRIPTOR_TYPE_SAMPLER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == forUnmarshaling->descriptorType))
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_SAMPLER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == forUnmarshaling->descriptorType))))
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorCount; ++i)
{
@@ -3312,7 +3440,7 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pBufferInfo inconsistent between guest and host\n");
}
- if ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == forUnmarshaling->descriptorType))
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == forUnmarshaling->descriptorType))))
{
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorCount; ++i)
{
@@ -3333,14 +3461,14 @@
{
fprintf(stderr, "fatal: forUnmarshaling->pTexelBufferView inconsistent between guest and host\n");
}
- if ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == forUnmarshaling->descriptorType))
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == forUnmarshaling->descriptorType))))
{
if (forUnmarshaling->descriptorCount)
{
- uint64_t* cgen_var_117;
- vkStream->alloc((void**)&cgen_var_117, forUnmarshaling->descriptorCount * 8);
- vkStream->read((uint64_t*)cgen_var_117, forUnmarshaling->descriptorCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBufferView(cgen_var_117, (VkBufferView*)forUnmarshaling->pTexelBufferView, forUnmarshaling->descriptorCount);
+ uint64_t* cgen_var_127;
+ vkStream->alloc((void**)&cgen_var_127, forUnmarshaling->descriptorCount * 8);
+ vkStream->read((uint64_t*)cgen_var_127, forUnmarshaling->descriptorCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBufferView(cgen_var_127, (VkBufferView*)forUnmarshaling->pTexelBufferView, forUnmarshaling->descriptorCount);
}
}
else
@@ -3362,14 +3490,14 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_118;
- vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->srcSet, &cgen_var_118, 1);
- vkStream->write((uint64_t*)&cgen_var_118, 1 * 8);
+ uint64_t cgen_var_128;
+ vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->srcSet, &cgen_var_128, 1);
+ vkStream->write((uint64_t*)&cgen_var_128, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->srcBinding, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->srcArrayElement, sizeof(uint32_t));
- uint64_t cgen_var_119;
- vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_119, 1);
- vkStream->write((uint64_t*)&cgen_var_119, 1 * 8);
+ uint64_t cgen_var_129;
+ vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_129, 1);
+ vkStream->write((uint64_t*)&cgen_var_129, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
@@ -3388,14 +3516,14 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_120;
- vkStream->read((uint64_t*)&cgen_var_120, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_120, (VkDescriptorSet*)&forUnmarshaling->srcSet, 1);
+ uint64_t cgen_var_130;
+ vkStream->read((uint64_t*)&cgen_var_130, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_130, (VkDescriptorSet*)&forUnmarshaling->srcSet, 1);
vkStream->read((uint32_t*)&forUnmarshaling->srcBinding, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->srcArrayElement, sizeof(uint32_t));
- uint64_t cgen_var_121;
- vkStream->read((uint64_t*)&cgen_var_121, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_121, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
+ uint64_t cgen_var_131;
+ vkStream->read((uint64_t*)&cgen_var_131, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_131, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
vkStream->read((uint32_t*)&forUnmarshaling->dstBinding, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->dstArrayElement, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
@@ -3414,16 +3542,16 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
vkStream->write((VkFramebufferCreateFlags*)&forMarshaling->flags, sizeof(VkFramebufferCreateFlags));
- uint64_t cgen_var_122;
- vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_122, 1);
- vkStream->write((uint64_t*)&cgen_var_122, 1 * 8);
+ uint64_t cgen_var_132;
+ vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_132, 1);
+ vkStream->write((uint64_t*)&cgen_var_132, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
if (forMarshaling->attachmentCount)
{
- uint64_t* cgen_var_123;
- vkStream->alloc((void**)&cgen_var_123, forMarshaling->attachmentCount * 8);
- vkStream->handleMapping()->mapHandles_VkImageView_u64(forMarshaling->pAttachments, cgen_var_123, forMarshaling->attachmentCount);
- vkStream->write((uint64_t*)cgen_var_123, forMarshaling->attachmentCount * 8);
+ uint64_t* cgen_var_133;
+ vkStream->alloc((void**)&cgen_var_133, forMarshaling->attachmentCount * 8);
+ vkStream->handleMapping()->mapHandles_VkImageView_u64(forMarshaling->pAttachments, cgen_var_133, forMarshaling->attachmentCount);
+ vkStream->write((uint64_t*)cgen_var_133, forMarshaling->attachmentCount * 8);
}
vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
@@ -3444,16 +3572,16 @@
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
vkStream->read((VkFramebufferCreateFlags*)&forUnmarshaling->flags, sizeof(VkFramebufferCreateFlags));
- uint64_t cgen_var_124;
- vkStream->read((uint64_t*)&cgen_var_124, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_124, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+ uint64_t cgen_var_134;
+ vkStream->read((uint64_t*)&cgen_var_134, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_134, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
if (forUnmarshaling->attachmentCount)
{
- uint64_t* cgen_var_125;
- vkStream->alloc((void**)&cgen_var_125, forUnmarshaling->attachmentCount * 8);
- vkStream->read((uint64_t*)cgen_var_125, forUnmarshaling->attachmentCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImageView(cgen_var_125, (VkImageView*)forUnmarshaling->pAttachments, forUnmarshaling->attachmentCount);
+ uint64_t* cgen_var_135;
+ vkStream->alloc((void**)&cgen_var_135, forUnmarshaling->attachmentCount * 8);
+ vkStream->read((uint64_t*)cgen_var_135, forUnmarshaling->attachmentCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImageView(cgen_var_135, (VkImageView*)forUnmarshaling->pAttachments, forUnmarshaling->attachmentCount);
}
vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
@@ -3523,8 +3651,8 @@
marshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pColorAttachments + i));
}
// WARNING PTR CHECK
- uint64_t cgen_var_126 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
- vkStream->putBe64(cgen_var_126);
+ uint64_t cgen_var_136 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
+ vkStream->putBe64(cgen_var_136);
if (forMarshaling->pResolveAttachments)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
@@ -3533,8 +3661,8 @@
}
}
// WARNING PTR CHECK
- uint64_t cgen_var_127 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
- vkStream->putBe64(cgen_var_127);
+ uint64_t cgen_var_137 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
+ vkStream->putBe64(cgen_var_137);
if (forMarshaling->pDepthStencilAttachment)
{
marshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pDepthStencilAttachment));
@@ -3720,9 +3848,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_130;
- vkStream->handleMapping()->mapHandles_VkCommandPool_u64(&forMarshaling->commandPool, &cgen_var_130, 1);
- vkStream->write((uint64_t*)&cgen_var_130, 1 * 8);
+ uint64_t cgen_var_140;
+ vkStream->handleMapping()->mapHandles_VkCommandPool_u64(&forMarshaling->commandPool, &cgen_var_140, 1);
+ vkStream->write((uint64_t*)&cgen_var_140, 1 * 8);
vkStream->write((VkCommandBufferLevel*)&forMarshaling->level, sizeof(VkCommandBufferLevel));
vkStream->write((uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
}
@@ -3740,9 +3868,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_131;
- vkStream->read((uint64_t*)&cgen_var_131, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkCommandPool(&cgen_var_131, (VkCommandPool*)&forUnmarshaling->commandPool, 1);
+ uint64_t cgen_var_141;
+ vkStream->read((uint64_t*)&cgen_var_141, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkCommandPool(&cgen_var_141, (VkCommandPool*)&forUnmarshaling->commandPool, 1);
vkStream->read((VkCommandBufferLevel*)&forUnmarshaling->level, sizeof(VkCommandBufferLevel));
vkStream->read((uint32_t*)&forUnmarshaling->commandBufferCount, sizeof(uint32_t));
}
@@ -3759,13 +3887,13 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_132;
- vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_132, 1);
- vkStream->write((uint64_t*)&cgen_var_132, 1 * 8);
+ uint64_t cgen_var_142;
+ vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_142, 1);
+ vkStream->write((uint64_t*)&cgen_var_142, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
- uint64_t cgen_var_133;
- vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer, &cgen_var_133, 1);
- vkStream->write((uint64_t*)&cgen_var_133, 1 * 8);
+ uint64_t cgen_var_143;
+ vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer, &cgen_var_143, 1);
+ vkStream->write((uint64_t*)&cgen_var_143, 1 * 8);
vkStream->write((VkBool32*)&forMarshaling->occlusionQueryEnable, sizeof(VkBool32));
vkStream->write((VkQueryControlFlags*)&forMarshaling->queryFlags, sizeof(VkQueryControlFlags));
vkStream->write((VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
@@ -3784,13 +3912,13 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_134;
- vkStream->read((uint64_t*)&cgen_var_134, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_134, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+ uint64_t cgen_var_144;
+ vkStream->read((uint64_t*)&cgen_var_144, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_144, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
vkStream->read((uint32_t*)&forUnmarshaling->subpass, sizeof(uint32_t));
- uint64_t cgen_var_135;
- vkStream->read((uint64_t*)&cgen_var_135, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_135, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
+ uint64_t cgen_var_145;
+ vkStream->read((uint64_t*)&cgen_var_145, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_145, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
vkStream->read((VkBool32*)&forUnmarshaling->occlusionQueryEnable, sizeof(VkBool32));
vkStream->read((VkQueryControlFlags*)&forUnmarshaling->queryFlags, sizeof(VkQueryControlFlags));
vkStream->read((VkQueryPipelineStatisticFlags*)&forUnmarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
@@ -3810,8 +3938,8 @@
}
vkStream->write((VkCommandBufferUsageFlags*)&forMarshaling->flags, sizeof(VkCommandBufferUsageFlags));
// WARNING PTR CHECK
- uint64_t cgen_var_136 = (uint64_t)(uintptr_t)forMarshaling->pInheritanceInfo;
- vkStream->putBe64(cgen_var_136);
+ uint64_t cgen_var_146 = (uint64_t)(uintptr_t)forMarshaling->pInheritanceInfo;
+ vkStream->putBe64(cgen_var_146);
if (forMarshaling->pInheritanceInfo)
{
marshal_VkCommandBufferInheritanceInfo(vkStream, (const VkCommandBufferInheritanceInfo*)(forMarshaling->pInheritanceInfo));
@@ -4112,9 +4240,9 @@
vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
vkStream->write((uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
- uint64_t cgen_var_138;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_138, 1);
- vkStream->write((uint64_t*)&cgen_var_138, 1 * 8);
+ uint64_t cgen_var_148;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_148, 1);
+ vkStream->write((uint64_t*)&cgen_var_148, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}
@@ -4136,9 +4264,9 @@
vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
vkStream->read((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
- uint64_t cgen_var_139;
- vkStream->read((uint64_t*)&cgen_var_139, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_139, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ uint64_t cgen_var_149;
+ vkStream->read((uint64_t*)&cgen_var_149, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_149, (VkBuffer*)&forUnmarshaling->buffer, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}
@@ -4161,9 +4289,9 @@
vkStream->write((VkImageLayout*)&forMarshaling->newLayout, sizeof(VkImageLayout));
vkStream->write((uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
- uint64_t cgen_var_140;
- vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_140, 1);
- vkStream->write((uint64_t*)&cgen_var_140, 1 * 8);
+ uint64_t cgen_var_150;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_150, 1);
+ vkStream->write((uint64_t*)&cgen_var_150, 1 * 8);
marshal_VkImageSubresourceRange(vkStream, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
}
@@ -4186,9 +4314,9 @@
vkStream->read((VkImageLayout*)&forUnmarshaling->newLayout, sizeof(VkImageLayout));
vkStream->read((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
- uint64_t cgen_var_141;
- vkStream->read((uint64_t*)&cgen_var_141, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_141, (VkImage*)&forUnmarshaling->image, 1);
+ uint64_t cgen_var_151;
+ vkStream->read((uint64_t*)&cgen_var_151, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_151, (VkImage*)&forUnmarshaling->image, 1);
unmarshal_VkImageSubresourceRange(vkStream, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
}
@@ -4204,17 +4332,17 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_142;
- vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_142, 1);
- vkStream->write((uint64_t*)&cgen_var_142, 1 * 8);
- uint64_t cgen_var_143;
- vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer, &cgen_var_143, 1);
- vkStream->write((uint64_t*)&cgen_var_143, 1 * 8);
+ uint64_t cgen_var_152;
+ vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_152, 1);
+ vkStream->write((uint64_t*)&cgen_var_152, 1 * 8);
+ uint64_t cgen_var_153;
+ vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer, &cgen_var_153, 1);
+ vkStream->write((uint64_t*)&cgen_var_153, 1 * 8);
marshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->renderArea));
vkStream->write((uint32_t*)&forMarshaling->clearValueCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_144 = (uint64_t)(uintptr_t)forMarshaling->pClearValues;
- vkStream->putBe64(cgen_var_144);
+ uint64_t cgen_var_154 = (uint64_t)(uintptr_t)forMarshaling->pClearValues;
+ vkStream->putBe64(cgen_var_154);
if (forMarshaling->pClearValues)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->clearValueCount; ++i)
@@ -4237,12 +4365,12 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_145;
- vkStream->read((uint64_t*)&cgen_var_145, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_145, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
- uint64_t cgen_var_146;
- vkStream->read((uint64_t*)&cgen_var_146, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_146, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
+ uint64_t cgen_var_155;
+ vkStream->read((uint64_t*)&cgen_var_155, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_155, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+ uint64_t cgen_var_156;
+ vkStream->read((uint64_t*)&cgen_var_156, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_156, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
unmarshal_VkRect2D(vkStream, (VkRect2D*)(&forUnmarshaling->renderArea));
vkStream->read((uint32_t*)&forUnmarshaling->clearValueCount, sizeof(uint32_t));
// WARNING PTR CHECK
@@ -4430,12 +4558,12 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_148;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_148, 1);
- vkStream->write((uint64_t*)&cgen_var_148, 1 * 8);
- uint64_t cgen_var_149;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_149, 1);
- vkStream->write((uint64_t*)&cgen_var_149, 1 * 8);
+ uint64_t cgen_var_158;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_158, 1);
+ vkStream->write((uint64_t*)&cgen_var_158, 1 * 8);
+ uint64_t cgen_var_159;
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_159, 1);
+ vkStream->write((uint64_t*)&cgen_var_159, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
}
@@ -4452,12 +4580,12 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_150;
- vkStream->read((uint64_t*)&cgen_var_150, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_150, (VkBuffer*)&forUnmarshaling->buffer, 1);
- uint64_t cgen_var_151;
- vkStream->read((uint64_t*)&cgen_var_151, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_151, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ uint64_t cgen_var_160;
+ vkStream->read((uint64_t*)&cgen_var_160, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_160, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ uint64_t cgen_var_161;
+ vkStream->read((uint64_t*)&cgen_var_161, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_161, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
}
@@ -4473,12 +4601,12 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_152;
- vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_152, 1);
- vkStream->write((uint64_t*)&cgen_var_152, 1 * 8);
- uint64_t cgen_var_153;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_153, 1);
- vkStream->write((uint64_t*)&cgen_var_153, 1 * 8);
+ uint64_t cgen_var_162;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_162, 1);
+ vkStream->write((uint64_t*)&cgen_var_162, 1 * 8);
+ uint64_t cgen_var_163;
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_163, 1);
+ vkStream->write((uint64_t*)&cgen_var_163, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
}
@@ -4495,12 +4623,12 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_154;
- vkStream->read((uint64_t*)&cgen_var_154, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_154, (VkImage*)&forUnmarshaling->image, 1);
- uint64_t cgen_var_155;
- vkStream->read((uint64_t*)&cgen_var_155, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_155, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ uint64_t cgen_var_164;
+ vkStream->read((uint64_t*)&cgen_var_164, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_164, (VkImage*)&forUnmarshaling->image, 1);
+ uint64_t cgen_var_165;
+ vkStream->read((uint64_t*)&cgen_var_165, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_165, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
}
@@ -4586,12 +4714,12 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_156;
- vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_156, 1);
- vkStream->write((uint64_t*)&cgen_var_156, 1 * 8);
- uint64_t cgen_var_157;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_157, 1);
- vkStream->write((uint64_t*)&cgen_var_157, 1 * 8);
+ uint64_t cgen_var_166;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_166, 1);
+ vkStream->write((uint64_t*)&cgen_var_166, 1 * 8);
+ uint64_t cgen_var_167;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_167, 1);
+ vkStream->write((uint64_t*)&cgen_var_167, 1 * 8);
}
void unmarshal_VkMemoryDedicatedAllocateInfo(
@@ -4607,12 +4735,12 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_158;
- vkStream->read((uint64_t*)&cgen_var_158, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_158, (VkImage*)&forUnmarshaling->image, 1);
- uint64_t cgen_var_159;
- vkStream->read((uint64_t*)&cgen_var_159, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_159, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ uint64_t cgen_var_168;
+ vkStream->read((uint64_t*)&cgen_var_168, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_168, (VkImage*)&forUnmarshaling->image, 1);
+ uint64_t cgen_var_169;
+ vkStream->read((uint64_t*)&cgen_var_169, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_169, (VkBuffer*)&forUnmarshaling->buffer, 1);
}
void marshal_VkMemoryAllocateFlagsInfo(
@@ -4920,10 +5048,10 @@
vkStream->write((uint32_t*)&forMarshaling->physicalDeviceCount, sizeof(uint32_t));
if (forMarshaling->physicalDeviceCount)
{
- uint64_t* cgen_var_160;
- vkStream->alloc((void**)&cgen_var_160, forMarshaling->physicalDeviceCount * 8);
- vkStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(forMarshaling->pPhysicalDevices, cgen_var_160, forMarshaling->physicalDeviceCount);
- vkStream->write((uint64_t*)cgen_var_160, forMarshaling->physicalDeviceCount * 8);
+ uint64_t* cgen_var_170;
+ vkStream->alloc((void**)&cgen_var_170, forMarshaling->physicalDeviceCount * 8);
+ vkStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(forMarshaling->pPhysicalDevices, cgen_var_170, forMarshaling->physicalDeviceCount);
+ vkStream->write((uint64_t*)cgen_var_170, forMarshaling->physicalDeviceCount * 8);
}
}
@@ -4943,10 +5071,10 @@
vkStream->read((uint32_t*)&forUnmarshaling->physicalDeviceCount, sizeof(uint32_t));
if (forUnmarshaling->physicalDeviceCount)
{
- uint64_t* cgen_var_161;
- vkStream->alloc((void**)&cgen_var_161, forUnmarshaling->physicalDeviceCount * 8);
- vkStream->read((uint64_t*)cgen_var_161, forUnmarshaling->physicalDeviceCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPhysicalDevice(cgen_var_161, (VkPhysicalDevice*)forUnmarshaling->pPhysicalDevices, forUnmarshaling->physicalDeviceCount);
+ uint64_t* cgen_var_171;
+ vkStream->alloc((void**)&cgen_var_171, forUnmarshaling->physicalDeviceCount * 8);
+ vkStream->read((uint64_t*)cgen_var_171, forUnmarshaling->physicalDeviceCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPhysicalDevice(cgen_var_171, (VkPhysicalDevice*)forUnmarshaling->pPhysicalDevices, forUnmarshaling->physicalDeviceCount);
}
}
@@ -4962,9 +5090,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_162;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_162, 1);
- vkStream->write((uint64_t*)&cgen_var_162, 1 * 8);
+ uint64_t cgen_var_172;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_172, 1);
+ vkStream->write((uint64_t*)&cgen_var_172, 1 * 8);
}
void unmarshal_VkBufferMemoryRequirementsInfo2(
@@ -4980,9 +5108,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_163;
- vkStream->read((uint64_t*)&cgen_var_163, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_163, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ uint64_t cgen_var_173;
+ vkStream->read((uint64_t*)&cgen_var_173, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_173, (VkBuffer*)&forUnmarshaling->buffer, 1);
}
void marshal_VkImageMemoryRequirementsInfo2(
@@ -4997,9 +5125,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_164;
- vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_164, 1);
- vkStream->write((uint64_t*)&cgen_var_164, 1 * 8);
+ uint64_t cgen_var_174;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_174, 1);
+ vkStream->write((uint64_t*)&cgen_var_174, 1 * 8);
}
void unmarshal_VkImageMemoryRequirementsInfo2(
@@ -5015,9 +5143,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_165;
- vkStream->read((uint64_t*)&cgen_var_165, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_165, (VkImage*)&forUnmarshaling->image, 1);
+ uint64_t cgen_var_175;
+ vkStream->read((uint64_t*)&cgen_var_175, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_175, (VkImage*)&forUnmarshaling->image, 1);
}
void marshal_VkImageSparseMemoryRequirementsInfo2(
@@ -5032,9 +5160,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_166;
- vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_166, 1);
- vkStream->write((uint64_t*)&cgen_var_166, 1 * 8);
+ uint64_t cgen_var_176;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_176, 1);
+ vkStream->write((uint64_t*)&cgen_var_176, 1 * 8);
}
void unmarshal_VkImageSparseMemoryRequirementsInfo2(
@@ -5050,9 +5178,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_167;
- vkStream->read((uint64_t*)&cgen_var_167, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_167, (VkImage*)&forUnmarshaling->image, 1);
+ uint64_t cgen_var_177;
+ vkStream->read((uint64_t*)&cgen_var_177, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_177, (VkImage*)&forUnmarshaling->image, 1);
}
void marshal_VkMemoryRequirements2(
@@ -5889,9 +6017,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_168;
- vkStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&forMarshaling->conversion, &cgen_var_168, 1);
- vkStream->write((uint64_t*)&cgen_var_168, 1 * 8);
+ uint64_t cgen_var_178;
+ vkStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&forMarshaling->conversion, &cgen_var_178, 1);
+ vkStream->write((uint64_t*)&cgen_var_178, 1 * 8);
}
void unmarshal_VkSamplerYcbcrConversionInfo(
@@ -5907,9 +6035,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_169;
- vkStream->read((uint64_t*)&cgen_var_169, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_169, (VkSamplerYcbcrConversion*)&forUnmarshaling->conversion, 1);
+ uint64_t cgen_var_179;
+ vkStream->read((uint64_t*)&cgen_var_179, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_179, (VkSamplerYcbcrConversion*)&forUnmarshaling->conversion, 1);
}
void marshal_VkBindImagePlaneMemoryInfo(
@@ -6044,10 +6172,10 @@
vkStream->write((uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
vkStream->write((VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
- uint64_t cgen_var_170 = (uint64_t)forMarshaling->offset;
- vkStream->putBe64(cgen_var_170);
- uint64_t cgen_var_171 = (uint64_t)forMarshaling->stride;
- vkStream->putBe64(cgen_var_171);
+ uint64_t cgen_var_180 = (uint64_t)forMarshaling->offset;
+ vkStream->putBe64(cgen_var_180);
+ uint64_t cgen_var_181 = (uint64_t)forMarshaling->stride;
+ vkStream->putBe64(cgen_var_181);
}
void unmarshal_VkDescriptorUpdateTemplateEntry(
@@ -6081,13 +6209,13 @@
marshal_VkDescriptorUpdateTemplateEntry(vkStream, (const VkDescriptorUpdateTemplateEntry*)(forMarshaling->pDescriptorUpdateEntries + i));
}
vkStream->write((VkDescriptorUpdateTemplateType*)&forMarshaling->templateType, sizeof(VkDescriptorUpdateTemplateType));
- uint64_t cgen_var_174;
- vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&forMarshaling->descriptorSetLayout, &cgen_var_174, 1);
- vkStream->write((uint64_t*)&cgen_var_174, 1 * 8);
+ uint64_t cgen_var_184;
+ vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&forMarshaling->descriptorSetLayout, &cgen_var_184, 1);
+ vkStream->write((uint64_t*)&cgen_var_184, 1 * 8);
vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
- uint64_t cgen_var_175;
- vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_175, 1);
- vkStream->write((uint64_t*)&cgen_var_175, 1 * 8);
+ uint64_t cgen_var_185;
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_185, 1);
+ vkStream->write((uint64_t*)&cgen_var_185, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->set, sizeof(uint32_t));
}
@@ -6111,13 +6239,13 @@
unmarshal_VkDescriptorUpdateTemplateEntry(vkStream, (VkDescriptorUpdateTemplateEntry*)(forUnmarshaling->pDescriptorUpdateEntries + i));
}
vkStream->read((VkDescriptorUpdateTemplateType*)&forUnmarshaling->templateType, sizeof(VkDescriptorUpdateTemplateType));
- uint64_t cgen_var_176;
- vkStream->read((uint64_t*)&cgen_var_176, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(&cgen_var_176, (VkDescriptorSetLayout*)&forUnmarshaling->descriptorSetLayout, 1);
+ uint64_t cgen_var_186;
+ vkStream->read((uint64_t*)&cgen_var_186, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(&cgen_var_186, (VkDescriptorSetLayout*)&forUnmarshaling->descriptorSetLayout, 1);
vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
- uint64_t cgen_var_177;
- vkStream->read((uint64_t*)&cgen_var_177, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_177, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
+ uint64_t cgen_var_187;
+ vkStream->read((uint64_t*)&cgen_var_187, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_187, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
vkStream->read((uint32_t*)&forUnmarshaling->set, sizeof(uint32_t));
}
@@ -6753,9 +6881,9 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
vkStream->write((VkSwapchainCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkSwapchainCreateFlagsKHR));
- uint64_t cgen_var_178;
- vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_178, 1);
- vkStream->write((uint64_t*)&cgen_var_178, 1 * 8);
+ uint64_t cgen_var_188;
+ vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_188, 1);
+ vkStream->write((uint64_t*)&cgen_var_188, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->minImageCount, sizeof(uint32_t));
vkStream->write((VkFormat*)&forMarshaling->imageFormat, sizeof(VkFormat));
vkStream->write((VkColorSpaceKHR*)&forMarshaling->imageColorSpace, sizeof(VkColorSpaceKHR));
@@ -6765,8 +6893,8 @@
vkStream->write((VkSharingMode*)&forMarshaling->imageSharingMode, sizeof(VkSharingMode));
vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_179 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
- vkStream->putBe64(cgen_var_179);
+ uint64_t cgen_var_189 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
+ vkStream->putBe64(cgen_var_189);
if (forMarshaling->pQueueFamilyIndices)
{
vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
@@ -6775,9 +6903,9 @@
vkStream->write((VkCompositeAlphaFlagBitsKHR*)&forMarshaling->compositeAlpha, sizeof(VkCompositeAlphaFlagBitsKHR));
vkStream->write((VkPresentModeKHR*)&forMarshaling->presentMode, sizeof(VkPresentModeKHR));
vkStream->write((VkBool32*)&forMarshaling->clipped, sizeof(VkBool32));
- uint64_t cgen_var_180;
- vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->oldSwapchain, &cgen_var_180, 1);
- vkStream->write((uint64_t*)&cgen_var_180, 1 * 8);
+ uint64_t cgen_var_190;
+ vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->oldSwapchain, &cgen_var_190, 1);
+ vkStream->write((uint64_t*)&cgen_var_190, 1 * 8);
}
void unmarshal_VkSwapchainCreateInfoKHR(
@@ -6794,9 +6922,9 @@
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
vkStream->read((VkSwapchainCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkSwapchainCreateFlagsKHR));
- uint64_t cgen_var_181;
- vkStream->read((uint64_t*)&cgen_var_181, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_181, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
+ uint64_t cgen_var_191;
+ vkStream->read((uint64_t*)&cgen_var_191, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_191, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
vkStream->read((uint32_t*)&forUnmarshaling->minImageCount, sizeof(uint32_t));
vkStream->read((VkFormat*)&forUnmarshaling->imageFormat, sizeof(VkFormat));
vkStream->read((VkColorSpaceKHR*)&forUnmarshaling->imageColorSpace, sizeof(VkColorSpaceKHR));
@@ -6820,9 +6948,9 @@
vkStream->read((VkCompositeAlphaFlagBitsKHR*)&forUnmarshaling->compositeAlpha, sizeof(VkCompositeAlphaFlagBitsKHR));
vkStream->read((VkPresentModeKHR*)&forUnmarshaling->presentMode, sizeof(VkPresentModeKHR));
vkStream->read((VkBool32*)&forUnmarshaling->clipped, sizeof(VkBool32));
- uint64_t cgen_var_183;
- vkStream->read((uint64_t*)&cgen_var_183, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_183, (VkSwapchainKHR*)&forUnmarshaling->oldSwapchain, 1);
+ uint64_t cgen_var_193;
+ vkStream->read((uint64_t*)&cgen_var_193, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_193, (VkSwapchainKHR*)&forUnmarshaling->oldSwapchain, 1);
}
void marshal_VkPresentInfoKHR(
@@ -6840,23 +6968,23 @@
vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
if (forMarshaling->waitSemaphoreCount)
{
- uint64_t* cgen_var_184;
- vkStream->alloc((void**)&cgen_var_184, forMarshaling->waitSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pWaitSemaphores, cgen_var_184, forMarshaling->waitSemaphoreCount);
- vkStream->write((uint64_t*)cgen_var_184, forMarshaling->waitSemaphoreCount * 8);
+ uint64_t* cgen_var_194;
+ vkStream->alloc((void**)&cgen_var_194, forMarshaling->waitSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pWaitSemaphores, cgen_var_194, forMarshaling->waitSemaphoreCount);
+ vkStream->write((uint64_t*)cgen_var_194, forMarshaling->waitSemaphoreCount * 8);
}
vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
if (forMarshaling->swapchainCount)
{
- uint64_t* cgen_var_185;
- vkStream->alloc((void**)&cgen_var_185, forMarshaling->swapchainCount * 8);
- vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(forMarshaling->pSwapchains, cgen_var_185, forMarshaling->swapchainCount);
- vkStream->write((uint64_t*)cgen_var_185, forMarshaling->swapchainCount * 8);
+ uint64_t* cgen_var_195;
+ vkStream->alloc((void**)&cgen_var_195, forMarshaling->swapchainCount * 8);
+ vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(forMarshaling->pSwapchains, cgen_var_195, forMarshaling->swapchainCount);
+ vkStream->write((uint64_t*)cgen_var_195, forMarshaling->swapchainCount * 8);
}
vkStream->write((const uint32_t*)forMarshaling->pImageIndices, forMarshaling->swapchainCount * sizeof(const uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_186 = (uint64_t)(uintptr_t)forMarshaling->pResults;
- vkStream->putBe64(cgen_var_186);
+ uint64_t cgen_var_196 = (uint64_t)(uintptr_t)forMarshaling->pResults;
+ vkStream->putBe64(cgen_var_196);
if (forMarshaling->pResults)
{
vkStream->write((VkResult*)forMarshaling->pResults, forMarshaling->swapchainCount * sizeof(VkResult));
@@ -6879,18 +7007,18 @@
vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
if (forUnmarshaling->waitSemaphoreCount)
{
- uint64_t* cgen_var_187;
- vkStream->alloc((void**)&cgen_var_187, forUnmarshaling->waitSemaphoreCount * 8);
- vkStream->read((uint64_t*)cgen_var_187, forUnmarshaling->waitSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_187, (VkSemaphore*)forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount);
+ uint64_t* cgen_var_197;
+ vkStream->alloc((void**)&cgen_var_197, forUnmarshaling->waitSemaphoreCount * 8);
+ vkStream->read((uint64_t*)cgen_var_197, forUnmarshaling->waitSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_197, (VkSemaphore*)forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount);
}
vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
if (forUnmarshaling->swapchainCount)
{
- uint64_t* cgen_var_188;
- vkStream->alloc((void**)&cgen_var_188, forUnmarshaling->swapchainCount * 8);
- vkStream->read((uint64_t*)cgen_var_188, forUnmarshaling->swapchainCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(cgen_var_188, (VkSwapchainKHR*)forUnmarshaling->pSwapchains, forUnmarshaling->swapchainCount);
+ uint64_t* cgen_var_198;
+ vkStream->alloc((void**)&cgen_var_198, forUnmarshaling->swapchainCount * 8);
+ vkStream->read((uint64_t*)cgen_var_198, forUnmarshaling->swapchainCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(cgen_var_198, (VkSwapchainKHR*)forUnmarshaling->pSwapchains, forUnmarshaling->swapchainCount);
}
vkStream->read((uint32_t*)forUnmarshaling->pImageIndices, forUnmarshaling->swapchainCount * sizeof(const uint32_t));
// WARNING PTR CHECK
@@ -6918,9 +7046,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_190;
- vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_190, 1);
- vkStream->write((uint64_t*)&cgen_var_190, 1 * 8);
+ uint64_t cgen_var_200;
+ vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_200, 1);
+ vkStream->write((uint64_t*)&cgen_var_200, 1 * 8);
}
void unmarshal_VkImageSwapchainCreateInfoKHR(
@@ -6936,9 +7064,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_191;
- vkStream->read((uint64_t*)&cgen_var_191, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_191, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
+ uint64_t cgen_var_201;
+ vkStream->read((uint64_t*)&cgen_var_201, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_201, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
}
void marshal_VkBindImageMemorySwapchainInfoKHR(
@@ -6953,9 +7081,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_192;
- vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_192, 1);
- vkStream->write((uint64_t*)&cgen_var_192, 1 * 8);
+ uint64_t cgen_var_202;
+ vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_202, 1);
+ vkStream->write((uint64_t*)&cgen_var_202, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->imageIndex, sizeof(uint32_t));
}
@@ -6972,9 +7100,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_193;
- vkStream->read((uint64_t*)&cgen_var_193, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_193, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
+ uint64_t cgen_var_203;
+ vkStream->read((uint64_t*)&cgen_var_203, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_203, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
vkStream->read((uint32_t*)&forUnmarshaling->imageIndex, sizeof(uint32_t));
}
@@ -6990,16 +7118,16 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_194;
- vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_194, 1);
- vkStream->write((uint64_t*)&cgen_var_194, 1 * 8);
+ uint64_t cgen_var_204;
+ vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_204, 1);
+ vkStream->write((uint64_t*)&cgen_var_204, 1 * 8);
vkStream->write((uint64_t*)&forMarshaling->timeout, sizeof(uint64_t));
- uint64_t cgen_var_195;
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_195, 1);
- vkStream->write((uint64_t*)&cgen_var_195, 1 * 8);
- uint64_t cgen_var_196;
- vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_196, 1);
- vkStream->write((uint64_t*)&cgen_var_196, 1 * 8);
+ uint64_t cgen_var_205;
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_205, 1);
+ vkStream->write((uint64_t*)&cgen_var_205, 1 * 8);
+ uint64_t cgen_var_206;
+ vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_206, 1);
+ vkStream->write((uint64_t*)&cgen_var_206, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
}
@@ -7016,16 +7144,16 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_197;
- vkStream->read((uint64_t*)&cgen_var_197, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_197, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
+ uint64_t cgen_var_207;
+ vkStream->read((uint64_t*)&cgen_var_207, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_207, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
vkStream->read((uint64_t*)&forUnmarshaling->timeout, sizeof(uint64_t));
- uint64_t cgen_var_198;
- vkStream->read((uint64_t*)&cgen_var_198, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_198, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
- uint64_t cgen_var_199;
- vkStream->read((uint64_t*)&cgen_var_199, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_199, (VkFence*)&forUnmarshaling->fence, 1);
+ uint64_t cgen_var_208;
+ vkStream->read((uint64_t*)&cgen_var_208, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_208, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ uint64_t cgen_var_209;
+ vkStream->read((uint64_t*)&cgen_var_209, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_209, (VkFence*)&forUnmarshaling->fence, 1);
vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
}
@@ -7134,9 +7262,9 @@
VulkanStreamGuest* vkStream,
const VkDisplayPropertiesKHR* forMarshaling)
{
- uint64_t cgen_var_200;
- vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->display, &cgen_var_200, 1);
- vkStream->write((uint64_t*)&cgen_var_200, 1 * 8);
+ uint64_t cgen_var_210;
+ vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->display, &cgen_var_210, 1);
+ vkStream->write((uint64_t*)&cgen_var_210, 1 * 8);
vkStream->putString(forMarshaling->displayName);
marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->physicalDimensions));
marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->physicalResolution));
@@ -7149,9 +7277,9 @@
VulkanStreamGuest* vkStream,
VkDisplayPropertiesKHR* forUnmarshaling)
{
- uint64_t cgen_var_201;
- vkStream->read((uint64_t*)&cgen_var_201, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_201, (VkDisplayKHR*)&forUnmarshaling->display, 1);
+ uint64_t cgen_var_211;
+ vkStream->read((uint64_t*)&cgen_var_211, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_211, (VkDisplayKHR*)&forUnmarshaling->display, 1);
vkStream->loadStringInPlace((char**)&forUnmarshaling->displayName);
unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->physicalDimensions));
unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->physicalResolution));
@@ -7180,9 +7308,9 @@
VulkanStreamGuest* vkStream,
const VkDisplayModePropertiesKHR* forMarshaling)
{
- uint64_t cgen_var_202;
- vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode, &cgen_var_202, 1);
- vkStream->write((uint64_t*)&cgen_var_202, 1 * 8);
+ uint64_t cgen_var_212;
+ vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode, &cgen_var_212, 1);
+ vkStream->write((uint64_t*)&cgen_var_212, 1 * 8);
marshal_VkDisplayModeParametersKHR(vkStream, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters));
}
@@ -7190,9 +7318,9 @@
VulkanStreamGuest* vkStream,
VkDisplayModePropertiesKHR* forUnmarshaling)
{
- uint64_t cgen_var_203;
- vkStream->read((uint64_t*)&cgen_var_203, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_203, (VkDisplayModeKHR*)&forUnmarshaling->displayMode, 1);
+ uint64_t cgen_var_213;
+ vkStream->read((uint64_t*)&cgen_var_213, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_213, (VkDisplayModeKHR*)&forUnmarshaling->displayMode, 1);
unmarshal_VkDisplayModeParametersKHR(vkStream, (VkDisplayModeParametersKHR*)(&forUnmarshaling->parameters));
}
@@ -7263,9 +7391,9 @@
VulkanStreamGuest* vkStream,
const VkDisplayPlanePropertiesKHR* forMarshaling)
{
- uint64_t cgen_var_204;
- vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->currentDisplay, &cgen_var_204, 1);
- vkStream->write((uint64_t*)&cgen_var_204, 1 * 8);
+ uint64_t cgen_var_214;
+ vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->currentDisplay, &cgen_var_214, 1);
+ vkStream->write((uint64_t*)&cgen_var_214, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->currentStackIndex, sizeof(uint32_t));
}
@@ -7273,9 +7401,9 @@
VulkanStreamGuest* vkStream,
VkDisplayPlanePropertiesKHR* forUnmarshaling)
{
- uint64_t cgen_var_205;
- vkStream->read((uint64_t*)&cgen_var_205, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_205, (VkDisplayKHR*)&forUnmarshaling->currentDisplay, 1);
+ uint64_t cgen_var_215;
+ vkStream->read((uint64_t*)&cgen_var_215, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_215, (VkDisplayKHR*)&forUnmarshaling->currentDisplay, 1);
vkStream->read((uint32_t*)&forUnmarshaling->currentStackIndex, sizeof(uint32_t));
}
@@ -7292,9 +7420,9 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
vkStream->write((VkDisplaySurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkDisplaySurfaceCreateFlagsKHR));
- uint64_t cgen_var_206;
- vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode, &cgen_var_206, 1);
- vkStream->write((uint64_t*)&cgen_var_206, 1 * 8);
+ uint64_t cgen_var_216;
+ vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode, &cgen_var_216, 1);
+ vkStream->write((uint64_t*)&cgen_var_216, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->planeIndex, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->planeStackIndex, sizeof(uint32_t));
vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
@@ -7317,9 +7445,9 @@
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
vkStream->read((VkDisplaySurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkDisplaySurfaceCreateFlagsKHR));
- uint64_t cgen_var_207;
- vkStream->read((uint64_t*)&cgen_var_207, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_207, (VkDisplayModeKHR*)&forUnmarshaling->displayMode, 1);
+ uint64_t cgen_var_217;
+ vkStream->read((uint64_t*)&cgen_var_217, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_217, (VkDisplayModeKHR*)&forUnmarshaling->displayMode, 1);
vkStream->read((uint32_t*)&forUnmarshaling->planeIndex, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->planeStackIndex, sizeof(uint32_t));
vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
@@ -7381,8 +7509,8 @@
}
vkStream->write((VkXlibSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkXlibSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
- uint64_t cgen_var_208 = (uint64_t)(uintptr_t)forMarshaling->dpy;
- vkStream->putBe64(cgen_var_208);
+ uint64_t cgen_var_218 = (uint64_t)(uintptr_t)forMarshaling->dpy;
+ vkStream->putBe64(cgen_var_218);
if (forMarshaling->dpy)
{
vkStream->write((Display*)forMarshaling->dpy, sizeof(Display));
@@ -7434,8 +7562,8 @@
}
vkStream->write((VkXcbSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkXcbSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
- uint64_t cgen_var_210 = (uint64_t)(uintptr_t)forMarshaling->connection;
- vkStream->putBe64(cgen_var_210);
+ uint64_t cgen_var_220 = (uint64_t)(uintptr_t)forMarshaling->connection;
+ vkStream->putBe64(cgen_var_220);
if (forMarshaling->connection)
{
vkStream->write((xcb_connection_t*)forMarshaling->connection, sizeof(xcb_connection_t));
@@ -7487,15 +7615,15 @@
}
vkStream->write((VkWaylandSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkWaylandSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
- uint64_t cgen_var_212 = (uint64_t)(uintptr_t)forMarshaling->display;
- vkStream->putBe64(cgen_var_212);
+ uint64_t cgen_var_222 = (uint64_t)(uintptr_t)forMarshaling->display;
+ vkStream->putBe64(cgen_var_222);
if (forMarshaling->display)
{
vkStream->write((wl_display*)forMarshaling->display, sizeof(wl_display));
}
// WARNING PTR CHECK
- uint64_t cgen_var_213 = (uint64_t)(uintptr_t)forMarshaling->surface;
- vkStream->putBe64(cgen_var_213);
+ uint64_t cgen_var_223 = (uint64_t)(uintptr_t)forMarshaling->surface;
+ vkStream->putBe64(cgen_var_223);
if (forMarshaling->surface)
{
vkStream->write((wl_surface*)forMarshaling->surface, sizeof(wl_surface));
@@ -7556,15 +7684,15 @@
}
vkStream->write((VkMirSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkMirSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
- uint64_t cgen_var_216 = (uint64_t)(uintptr_t)forMarshaling->connection;
- vkStream->putBe64(cgen_var_216);
+ uint64_t cgen_var_226 = (uint64_t)(uintptr_t)forMarshaling->connection;
+ vkStream->putBe64(cgen_var_226);
if (forMarshaling->connection)
{
vkStream->write((MirConnection*)forMarshaling->connection, sizeof(MirConnection));
}
// WARNING PTR CHECK
- uint64_t cgen_var_217 = (uint64_t)(uintptr_t)forMarshaling->mirSurface;
- vkStream->putBe64(cgen_var_217);
+ uint64_t cgen_var_227 = (uint64_t)(uintptr_t)forMarshaling->mirSurface;
+ vkStream->putBe64(cgen_var_227);
if (forMarshaling->mirSurface)
{
vkStream->write((MirSurface*)forMarshaling->mirSurface, sizeof(MirSurface));
@@ -7625,8 +7753,8 @@
}
vkStream->write((VkAndroidSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkAndroidSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
- uint64_t cgen_var_220 = (uint64_t)(uintptr_t)forMarshaling->window;
- vkStream->putBe64(cgen_var_220);
+ uint64_t cgen_var_230 = (uint64_t)(uintptr_t)forMarshaling->window;
+ vkStream->putBe64(cgen_var_230);
if (forMarshaling->window)
{
vkStream->write((ANativeWindow*)forMarshaling->window, sizeof(ANativeWindow));
@@ -7765,8 +7893,8 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
// WARNING PTR CHECK
- uint64_t cgen_var_222 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
- vkStream->putBe64(cgen_var_222);
+ uint64_t cgen_var_232 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+ vkStream->putBe64(cgen_var_232);
if (forMarshaling->pAttributes)
{
vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
@@ -7846,9 +7974,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_224;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_224, 1);
- vkStream->write((uint64_t*)&cgen_var_224, 1 * 8);
+ uint64_t cgen_var_234;
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_234, 1);
+ vkStream->write((uint64_t*)&cgen_var_234, 1 * 8);
vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
}
@@ -7865,9 +7993,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_225;
- vkStream->read((uint64_t*)&cgen_var_225, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_225, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ uint64_t cgen_var_235;
+ vkStream->read((uint64_t*)&cgen_var_235, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_235, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
}
@@ -7949,9 +8077,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_226;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_226, 1);
- vkStream->write((uint64_t*)&cgen_var_226, 1 * 8);
+ uint64_t cgen_var_236;
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_236, 1);
+ vkStream->write((uint64_t*)&cgen_var_236, 1 * 8);
vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
}
@@ -7968,9 +8096,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_227;
- vkStream->read((uint64_t*)&cgen_var_227, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_227, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ uint64_t cgen_var_237;
+ vkStream->read((uint64_t*)&cgen_var_237, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_237, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
}
@@ -7991,20 +8119,20 @@
vkStream->write((uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
if (forMarshaling->acquireCount)
{
- uint64_t* cgen_var_228;
- vkStream->alloc((void**)&cgen_var_228, forMarshaling->acquireCount * 8);
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pAcquireSyncs, cgen_var_228, forMarshaling->acquireCount);
- vkStream->write((uint64_t*)cgen_var_228, forMarshaling->acquireCount * 8);
+ uint64_t* cgen_var_238;
+ vkStream->alloc((void**)&cgen_var_238, forMarshaling->acquireCount * 8);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pAcquireSyncs, cgen_var_238, forMarshaling->acquireCount);
+ vkStream->write((uint64_t*)cgen_var_238, forMarshaling->acquireCount * 8);
}
vkStream->write((const uint64_t*)forMarshaling->pAcquireKeys, forMarshaling->acquireCount * sizeof(const uint64_t));
vkStream->write((const uint32_t*)forMarshaling->pAcquireTimeouts, forMarshaling->acquireCount * sizeof(const uint32_t));
vkStream->write((uint32_t*)&forMarshaling->releaseCount, sizeof(uint32_t));
if (forMarshaling->releaseCount)
{
- uint64_t* cgen_var_229;
- vkStream->alloc((void**)&cgen_var_229, forMarshaling->releaseCount * 8);
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pReleaseSyncs, cgen_var_229, forMarshaling->releaseCount);
- vkStream->write((uint64_t*)cgen_var_229, forMarshaling->releaseCount * 8);
+ uint64_t* cgen_var_239;
+ vkStream->alloc((void**)&cgen_var_239, forMarshaling->releaseCount * 8);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pReleaseSyncs, cgen_var_239, forMarshaling->releaseCount);
+ vkStream->write((uint64_t*)cgen_var_239, forMarshaling->releaseCount * 8);
}
vkStream->write((const uint64_t*)forMarshaling->pReleaseKeys, forMarshaling->releaseCount * sizeof(const uint64_t));
}
@@ -8025,20 +8153,20 @@
vkStream->read((uint32_t*)&forUnmarshaling->acquireCount, sizeof(uint32_t));
if (forUnmarshaling->acquireCount)
{
- uint64_t* cgen_var_230;
- vkStream->alloc((void**)&cgen_var_230, forUnmarshaling->acquireCount * 8);
- vkStream->read((uint64_t*)cgen_var_230, forUnmarshaling->acquireCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_230, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs, forUnmarshaling->acquireCount);
+ uint64_t* cgen_var_240;
+ vkStream->alloc((void**)&cgen_var_240, forUnmarshaling->acquireCount * 8);
+ vkStream->read((uint64_t*)cgen_var_240, forUnmarshaling->acquireCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_240, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs, forUnmarshaling->acquireCount);
}
vkStream->read((uint64_t*)forUnmarshaling->pAcquireKeys, forUnmarshaling->acquireCount * sizeof(const uint64_t));
vkStream->read((uint32_t*)forUnmarshaling->pAcquireTimeouts, forUnmarshaling->acquireCount * sizeof(const uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->releaseCount, sizeof(uint32_t));
if (forUnmarshaling->releaseCount)
{
- uint64_t* cgen_var_231;
- vkStream->alloc((void**)&cgen_var_231, forUnmarshaling->releaseCount * 8);
- vkStream->read((uint64_t*)cgen_var_231, forUnmarshaling->releaseCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_231, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs, forUnmarshaling->releaseCount);
+ uint64_t* cgen_var_241;
+ vkStream->alloc((void**)&cgen_var_241, forUnmarshaling->releaseCount * 8);
+ vkStream->read((uint64_t*)cgen_var_241, forUnmarshaling->releaseCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_241, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs, forUnmarshaling->releaseCount);
}
vkStream->read((uint64_t*)forUnmarshaling->pReleaseKeys, forUnmarshaling->releaseCount * sizeof(const uint64_t));
}
@@ -8061,9 +8189,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_232;
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_232, 1);
- vkStream->write((uint64_t*)&cgen_var_232, 1 * 8);
+ uint64_t cgen_var_242;
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_242, 1);
+ vkStream->write((uint64_t*)&cgen_var_242, 1 * 8);
vkStream->write((VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
@@ -8083,9 +8211,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_233;
- vkStream->read((uint64_t*)&cgen_var_233, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_233, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ uint64_t cgen_var_243;
+ vkStream->read((uint64_t*)&cgen_var_243, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_243, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
vkStream->read((VkSemaphoreImportFlags*)&forUnmarshaling->flags, sizeof(VkSemaphoreImportFlags));
vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
@@ -8105,8 +8233,8 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
// WARNING PTR CHECK
- uint64_t cgen_var_234 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
- vkStream->putBe64(cgen_var_234);
+ uint64_t cgen_var_244 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+ vkStream->putBe64(cgen_var_244);
if (forMarshaling->pAttributes)
{
vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
@@ -8157,16 +8285,16 @@
}
vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreValuesCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_236 = (uint64_t)(uintptr_t)forMarshaling->pWaitSemaphoreValues;
- vkStream->putBe64(cgen_var_236);
+ uint64_t cgen_var_246 = (uint64_t)(uintptr_t)forMarshaling->pWaitSemaphoreValues;
+ vkStream->putBe64(cgen_var_246);
if (forMarshaling->pWaitSemaphoreValues)
{
vkStream->write((const uint64_t*)forMarshaling->pWaitSemaphoreValues, forMarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t));
}
vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreValuesCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_237 = (uint64_t)(uintptr_t)forMarshaling->pSignalSemaphoreValues;
- vkStream->putBe64(cgen_var_237);
+ uint64_t cgen_var_247 = (uint64_t)(uintptr_t)forMarshaling->pSignalSemaphoreValues;
+ vkStream->putBe64(cgen_var_247);
if (forMarshaling->pSignalSemaphoreValues)
{
vkStream->write((const uint64_t*)forMarshaling->pSignalSemaphoreValues, forMarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
@@ -8224,9 +8352,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_240;
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_240, 1);
- vkStream->write((uint64_t*)&cgen_var_240, 1 * 8);
+ uint64_t cgen_var_250;
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_250, 1);
+ vkStream->write((uint64_t*)&cgen_var_250, 1 * 8);
vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}
@@ -8243,9 +8371,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_241;
- vkStream->read((uint64_t*)&cgen_var_241, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_241, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ uint64_t cgen_var_251;
+ vkStream->read((uint64_t*)&cgen_var_251, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_251, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}
@@ -8263,9 +8391,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_242;
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_242, 1);
- vkStream->write((uint64_t*)&cgen_var_242, 1 * 8);
+ uint64_t cgen_var_252;
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_252, 1);
+ vkStream->write((uint64_t*)&cgen_var_252, 1 * 8);
vkStream->write((VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
vkStream->write((int*)&forMarshaling->fd, sizeof(int));
@@ -8284,9 +8412,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_243;
- vkStream->read((uint64_t*)&cgen_var_243, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_243, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ uint64_t cgen_var_253;
+ vkStream->read((uint64_t*)&cgen_var_253, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_253, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
vkStream->read((VkSemaphoreImportFlags*)&forUnmarshaling->flags, sizeof(VkSemaphoreImportFlags));
vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
vkStream->read((int*)&forUnmarshaling->fd, sizeof(int));
@@ -8304,9 +8432,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_244;
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_244, 1);
- vkStream->write((uint64_t*)&cgen_var_244, 1 * 8);
+ uint64_t cgen_var_254;
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_254, 1);
+ vkStream->write((uint64_t*)&cgen_var_254, 1 * 8);
vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}
@@ -8323,9 +8451,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_245;
- vkStream->read((uint64_t*)&cgen_var_245, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_245, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ uint64_t cgen_var_255;
+ vkStream->read((uint64_t*)&cgen_var_255, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_255, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}
@@ -8390,8 +8518,8 @@
{
vkStream->write((uint32_t*)&forMarshaling->rectangleCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_246 = (uint64_t)(uintptr_t)forMarshaling->pRectangles;
- vkStream->putBe64(cgen_var_246);
+ uint64_t cgen_var_256 = (uint64_t)(uintptr_t)forMarshaling->pRectangles;
+ vkStream->putBe64(cgen_var_256);
if (forMarshaling->pRectangles)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->rectangleCount; ++i)
@@ -8436,8 +8564,8 @@
}
vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_248 = (uint64_t)(uintptr_t)forMarshaling->pRegions;
- vkStream->putBe64(cgen_var_248);
+ uint64_t cgen_var_258 = (uint64_t)(uintptr_t)forMarshaling->pRegions;
+ vkStream->putBe64(cgen_var_258);
if (forMarshaling->pRegions)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i)
@@ -8589,8 +8717,8 @@
marshal_VkAttachmentReference2KHR(vkStream, (const VkAttachmentReference2KHR*)(forMarshaling->pColorAttachments + i));
}
// WARNING PTR CHECK
- uint64_t cgen_var_250 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
- vkStream->putBe64(cgen_var_250);
+ uint64_t cgen_var_260 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
+ vkStream->putBe64(cgen_var_260);
if (forMarshaling->pResolveAttachments)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
@@ -8599,8 +8727,8 @@
}
}
// WARNING PTR CHECK
- uint64_t cgen_var_251 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
- vkStream->putBe64(cgen_var_251);
+ uint64_t cgen_var_261 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
+ vkStream->putBe64(cgen_var_261);
if (forMarshaling->pDepthStencilAttachment)
{
marshal_VkAttachmentReference2KHR(vkStream, (const VkAttachmentReference2KHR*)(forMarshaling->pDepthStencilAttachment));
@@ -8885,9 +9013,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_254;
- vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_254, 1);
- vkStream->write((uint64_t*)&cgen_var_254, 1 * 8);
+ uint64_t cgen_var_264;
+ vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_264, 1);
+ vkStream->write((uint64_t*)&cgen_var_264, 1 * 8);
vkStream->write((VkFenceImportFlags*)&forMarshaling->flags, sizeof(VkFenceImportFlags));
vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
@@ -8907,9 +9035,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_255;
- vkStream->read((uint64_t*)&cgen_var_255, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_255, (VkFence*)&forUnmarshaling->fence, 1);
+ uint64_t cgen_var_265;
+ vkStream->read((uint64_t*)&cgen_var_265, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_265, (VkFence*)&forUnmarshaling->fence, 1);
vkStream->read((VkFenceImportFlags*)&forUnmarshaling->flags, sizeof(VkFenceImportFlags));
vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
@@ -8929,8 +9057,8 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
// WARNING PTR CHECK
- uint64_t cgen_var_256 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
- vkStream->putBe64(cgen_var_256);
+ uint64_t cgen_var_266 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+ vkStream->putBe64(cgen_var_266);
if (forMarshaling->pAttributes)
{
vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
@@ -8979,9 +9107,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_258;
- vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_258, 1);
- vkStream->write((uint64_t*)&cgen_var_258, 1 * 8);
+ uint64_t cgen_var_268;
+ vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_268, 1);
+ vkStream->write((uint64_t*)&cgen_var_268, 1 * 8);
vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
}
@@ -8998,9 +9126,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_259;
- vkStream->read((uint64_t*)&cgen_var_259, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_259, (VkFence*)&forUnmarshaling->fence, 1);
+ uint64_t cgen_var_269;
+ vkStream->read((uint64_t*)&cgen_var_269, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_269, (VkFence*)&forUnmarshaling->fence, 1);
vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
}
@@ -9018,9 +9146,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_260;
- vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_260, 1);
- vkStream->write((uint64_t*)&cgen_var_260, 1 * 8);
+ uint64_t cgen_var_270;
+ vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_270, 1);
+ vkStream->write((uint64_t*)&cgen_var_270, 1 * 8);
vkStream->write((VkFenceImportFlags*)&forMarshaling->flags, sizeof(VkFenceImportFlags));
vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
vkStream->write((int*)&forMarshaling->fd, sizeof(int));
@@ -9039,9 +9167,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_261;
- vkStream->read((uint64_t*)&cgen_var_261, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_261, (VkFence*)&forUnmarshaling->fence, 1);
+ uint64_t cgen_var_271;
+ vkStream->read((uint64_t*)&cgen_var_271, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_271, (VkFence*)&forUnmarshaling->fence, 1);
vkStream->read((VkFenceImportFlags*)&forUnmarshaling->flags, sizeof(VkFenceImportFlags));
vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
vkStream->read((int*)&forUnmarshaling->fd, sizeof(int));
@@ -9059,9 +9187,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_262;
- vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_262, 1);
- vkStream->write((uint64_t*)&cgen_var_262, 1 * 8);
+ uint64_t cgen_var_272;
+ vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_272, 1);
+ vkStream->write((uint64_t*)&cgen_var_272, 1 * 8);
vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
}
@@ -9078,9 +9206,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_263;
- vkStream->read((uint64_t*)&cgen_var_263, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_263, (VkFence*)&forUnmarshaling->fence, 1);
+ uint64_t cgen_var_273;
+ vkStream->read((uint64_t*)&cgen_var_273, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_273, (VkFence*)&forUnmarshaling->fence, 1);
vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
}
@@ -9100,9 +9228,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_264;
- vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_264, 1);
- vkStream->write((uint64_t*)&cgen_var_264, 1 * 8);
+ uint64_t cgen_var_274;
+ vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_274, 1);
+ vkStream->write((uint64_t*)&cgen_var_274, 1 * 8);
}
void unmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
@@ -9118,9 +9246,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_265;
- vkStream->read((uint64_t*)&cgen_var_265, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_265, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
+ uint64_t cgen_var_275;
+ vkStream->read((uint64_t*)&cgen_var_275, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_275, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
}
void marshal_VkSurfaceCapabilities2KHR(
@@ -9294,9 +9422,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_266;
- vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->mode, &cgen_var_266, 1);
- vkStream->write((uint64_t*)&cgen_var_266, 1 * 8);
+ uint64_t cgen_var_276;
+ vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->mode, &cgen_var_276, 1);
+ vkStream->write((uint64_t*)&cgen_var_276, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->planeIndex, sizeof(uint32_t));
}
@@ -9313,9 +9441,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_267;
- vkStream->read((uint64_t*)&cgen_var_267, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_267, (VkDisplayModeKHR*)&forUnmarshaling->mode, 1);
+ uint64_t cgen_var_277;
+ vkStream->read((uint64_t*)&cgen_var_277, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_277, (VkDisplayModeKHR*)&forUnmarshaling->mode, 1);
vkStream->read((uint32_t*)&forUnmarshaling->planeIndex, sizeof(uint32_t));
}
@@ -9453,8 +9581,8 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
// WARNING PTR CHECK
- uint64_t cgen_var_268 = (uint64_t)(uintptr_t)forMarshaling->handle;
- vkStream->putBe64(cgen_var_268);
+ uint64_t cgen_var_278 = (uint64_t)(uintptr_t)forMarshaling->handle;
+ vkStream->putBe64(cgen_var_278);
if (forMarshaling->handle)
{
vkStream->write((const uint32_t*)forMarshaling->handle, sizeof(const uint32_t));
@@ -9512,11 +9640,11 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
vkStream->write((VkDebugReportFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugReportFlagsEXT));
- uint64_t cgen_var_270 = (uint64_t)forMarshaling->pfnCallback;
- vkStream->putBe64(cgen_var_270);
+ uint64_t cgen_var_280 = (uint64_t)forMarshaling->pfnCallback;
+ vkStream->putBe64(cgen_var_280);
// WARNING PTR CHECK
- uint64_t cgen_var_271 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
- vkStream->putBe64(cgen_var_271);
+ uint64_t cgen_var_281 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
+ vkStream->putBe64(cgen_var_281);
if (forMarshaling->pUserData)
{
vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
@@ -9646,8 +9774,8 @@
vkStream->write((VkDebugReportObjectTypeEXT*)&forMarshaling->objectType, sizeof(VkDebugReportObjectTypeEXT));
vkStream->write((uint64_t*)&forMarshaling->object, sizeof(uint64_t));
vkStream->write((uint64_t*)&forMarshaling->tagName, sizeof(uint64_t));
- uint64_t cgen_var_274 = (uint64_t)forMarshaling->tagSize;
- vkStream->putBe64(cgen_var_274);
+ uint64_t cgen_var_284 = (uint64_t)forMarshaling->tagSize;
+ vkStream->putBe64(cgen_var_284);
vkStream->write((const void*)forMarshaling->pTag, forMarshaling->tagSize * sizeof(const uint8_t));
}
@@ -9782,12 +9910,12 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_276;
- vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_276, 1);
- vkStream->write((uint64_t*)&cgen_var_276, 1 * 8);
- uint64_t cgen_var_277;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_277, 1);
- vkStream->write((uint64_t*)&cgen_var_277, 1 * 8);
+ uint64_t cgen_var_286;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_286, 1);
+ vkStream->write((uint64_t*)&cgen_var_286, 1 * 8);
+ uint64_t cgen_var_287;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_287, 1);
+ vkStream->write((uint64_t*)&cgen_var_287, 1 * 8);
}
void unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
@@ -9803,12 +9931,12 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_278;
- vkStream->read((uint64_t*)&cgen_var_278, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_278, (VkImage*)&forUnmarshaling->image, 1);
- uint64_t cgen_var_279;
- vkStream->read((uint64_t*)&cgen_var_279, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_279, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ uint64_t cgen_var_288;
+ vkStream->read((uint64_t*)&cgen_var_288, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_288, (VkImage*)&forUnmarshaling->image, 1);
+ uint64_t cgen_var_289;
+ vkStream->read((uint64_t*)&cgen_var_289, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_289, (VkBuffer*)&forUnmarshaling->buffer, 1);
}
#endif
@@ -9861,10 +9989,10 @@
vkStream->write((uint32_t*)&forMarshaling->numUsedVgprs, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->numUsedSgprs, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->ldsSizePerLocalWorkGroup, sizeof(uint32_t));
- uint64_t cgen_var_280 = (uint64_t)forMarshaling->ldsUsageSizeInBytes;
- vkStream->putBe64(cgen_var_280);
- uint64_t cgen_var_281 = (uint64_t)forMarshaling->scratchMemUsageInBytes;
- vkStream->putBe64(cgen_var_281);
+ uint64_t cgen_var_290 = (uint64_t)forMarshaling->ldsUsageSizeInBytes;
+ vkStream->putBe64(cgen_var_290);
+ uint64_t cgen_var_291 = (uint64_t)forMarshaling->scratchMemUsageInBytes;
+ vkStream->putBe64(cgen_var_291);
}
void unmarshal_VkShaderResourceUsageAMD(
@@ -10042,8 +10170,8 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
// WARNING PTR CHECK
- uint64_t cgen_var_284 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
- vkStream->putBe64(cgen_var_284);
+ uint64_t cgen_var_294 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+ vkStream->putBe64(cgen_var_294);
if (forMarshaling->pAttributes)
{
vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
@@ -10095,20 +10223,20 @@
vkStream->write((uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
if (forMarshaling->acquireCount)
{
- uint64_t* cgen_var_286;
- vkStream->alloc((void**)&cgen_var_286, forMarshaling->acquireCount * 8);
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pAcquireSyncs, cgen_var_286, forMarshaling->acquireCount);
- vkStream->write((uint64_t*)cgen_var_286, forMarshaling->acquireCount * 8);
+ uint64_t* cgen_var_296;
+ vkStream->alloc((void**)&cgen_var_296, forMarshaling->acquireCount * 8);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pAcquireSyncs, cgen_var_296, forMarshaling->acquireCount);
+ vkStream->write((uint64_t*)cgen_var_296, forMarshaling->acquireCount * 8);
}
vkStream->write((const uint64_t*)forMarshaling->pAcquireKeys, forMarshaling->acquireCount * sizeof(const uint64_t));
vkStream->write((const uint32_t*)forMarshaling->pAcquireTimeoutMilliseconds, forMarshaling->acquireCount * sizeof(const uint32_t));
vkStream->write((uint32_t*)&forMarshaling->releaseCount, sizeof(uint32_t));
if (forMarshaling->releaseCount)
{
- uint64_t* cgen_var_287;
- vkStream->alloc((void**)&cgen_var_287, forMarshaling->releaseCount * 8);
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pReleaseSyncs, cgen_var_287, forMarshaling->releaseCount);
- vkStream->write((uint64_t*)cgen_var_287, forMarshaling->releaseCount * 8);
+ uint64_t* cgen_var_297;
+ vkStream->alloc((void**)&cgen_var_297, forMarshaling->releaseCount * 8);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pReleaseSyncs, cgen_var_297, forMarshaling->releaseCount);
+ vkStream->write((uint64_t*)cgen_var_297, forMarshaling->releaseCount * 8);
}
vkStream->write((const uint64_t*)forMarshaling->pReleaseKeys, forMarshaling->releaseCount * sizeof(const uint64_t));
}
@@ -10129,20 +10257,20 @@
vkStream->read((uint32_t*)&forUnmarshaling->acquireCount, sizeof(uint32_t));
if (forUnmarshaling->acquireCount)
{
- uint64_t* cgen_var_288;
- vkStream->alloc((void**)&cgen_var_288, forUnmarshaling->acquireCount * 8);
- vkStream->read((uint64_t*)cgen_var_288, forUnmarshaling->acquireCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_288, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs, forUnmarshaling->acquireCount);
+ uint64_t* cgen_var_298;
+ vkStream->alloc((void**)&cgen_var_298, forUnmarshaling->acquireCount * 8);
+ vkStream->read((uint64_t*)cgen_var_298, forUnmarshaling->acquireCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_298, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs, forUnmarshaling->acquireCount);
}
vkStream->read((uint64_t*)forUnmarshaling->pAcquireKeys, forUnmarshaling->acquireCount * sizeof(const uint64_t));
vkStream->read((uint32_t*)forUnmarshaling->pAcquireTimeoutMilliseconds, forUnmarshaling->acquireCount * sizeof(const uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->releaseCount, sizeof(uint32_t));
if (forUnmarshaling->releaseCount)
{
- uint64_t* cgen_var_289;
- vkStream->alloc((void**)&cgen_var_289, forUnmarshaling->releaseCount * 8);
- vkStream->read((uint64_t*)cgen_var_289, forUnmarshaling->releaseCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_289, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs, forUnmarshaling->releaseCount);
+ uint64_t* cgen_var_299;
+ vkStream->alloc((void**)&cgen_var_299, forUnmarshaling->releaseCount * 8);
+ vkStream->read((uint64_t*)cgen_var_299, forUnmarshaling->releaseCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_299, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs, forUnmarshaling->releaseCount);
}
vkStream->read((uint64_t*)forUnmarshaling->pReleaseKeys, forUnmarshaling->releaseCount * sizeof(const uint64_t));
}
@@ -10198,8 +10326,8 @@
}
vkStream->write((VkViSurfaceCreateFlagsNN*)&forMarshaling->flags, sizeof(VkViSurfaceCreateFlagsNN));
// WARNING PTR CHECK
- uint64_t cgen_var_290 = (uint64_t)(uintptr_t)forMarshaling->window;
- vkStream->putBe64(cgen_var_290);
+ uint64_t cgen_var_300 = (uint64_t)(uintptr_t)forMarshaling->window;
+ vkStream->putBe64(cgen_var_300);
if (forMarshaling->window)
{
vkStream->write((void*)forMarshaling->window, sizeof(uint8_t));
@@ -10251,9 +10379,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_292;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_292, 1);
- vkStream->write((uint64_t*)&cgen_var_292, 1 * 8);
+ uint64_t cgen_var_302;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_302, 1);
+ vkStream->write((uint64_t*)&cgen_var_302, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
vkStream->write((VkConditionalRenderingFlagsEXT*)&forMarshaling->flags, sizeof(VkConditionalRenderingFlagsEXT));
}
@@ -10271,9 +10399,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_293;
- vkStream->read((uint64_t*)&cgen_var_293, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_293, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ uint64_t cgen_var_303;
+ vkStream->read((uint64_t*)&cgen_var_303, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_303, (VkBuffer*)&forUnmarshaling->buffer, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
vkStream->read((VkConditionalRenderingFlagsEXT*)&forUnmarshaling->flags, sizeof(VkConditionalRenderingFlagsEXT));
}
@@ -10419,9 +10547,9 @@
const VkIndirectCommandsTokenNVX* forMarshaling)
{
vkStream->write((VkIndirectCommandsTokenTypeNVX*)&forMarshaling->tokenType, sizeof(VkIndirectCommandsTokenTypeNVX));
- uint64_t cgen_var_294;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_294, 1);
- vkStream->write((uint64_t*)&cgen_var_294, 1 * 8);
+ uint64_t cgen_var_304;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_304, 1);
+ vkStream->write((uint64_t*)&cgen_var_304, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
}
@@ -10430,9 +10558,9 @@
VkIndirectCommandsTokenNVX* forUnmarshaling)
{
vkStream->read((VkIndirectCommandsTokenTypeNVX*)&forUnmarshaling->tokenType, sizeof(VkIndirectCommandsTokenTypeNVX));
- uint64_t cgen_var_295;
- vkStream->read((uint64_t*)&cgen_var_295, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_295, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ uint64_t cgen_var_305;
+ vkStream->read((uint64_t*)&cgen_var_305, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_305, (VkBuffer*)&forUnmarshaling->buffer, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
}
@@ -10511,28 +10639,28 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_296;
- vkStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&forMarshaling->objectTable, &cgen_var_296, 1);
- vkStream->write((uint64_t*)&cgen_var_296, 1 * 8);
- uint64_t cgen_var_297;
- vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&forMarshaling->indirectCommandsLayout, &cgen_var_297, 1);
- vkStream->write((uint64_t*)&cgen_var_297, 1 * 8);
+ uint64_t cgen_var_306;
+ vkStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&forMarshaling->objectTable, &cgen_var_306, 1);
+ vkStream->write((uint64_t*)&cgen_var_306, 1 * 8);
+ uint64_t cgen_var_307;
+ vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&forMarshaling->indirectCommandsLayout, &cgen_var_307, 1);
+ vkStream->write((uint64_t*)&cgen_var_307, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->indirectCommandsTokenCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)forMarshaling->indirectCommandsTokenCount; ++i)
{
marshal_VkIndirectCommandsTokenNVX(vkStream, (const VkIndirectCommandsTokenNVX*)(forMarshaling->pIndirectCommandsTokens + i));
}
vkStream->write((uint32_t*)&forMarshaling->maxSequencesCount, sizeof(uint32_t));
- uint64_t cgen_var_298;
- vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&forMarshaling->targetCommandBuffer, &cgen_var_298, 1);
- vkStream->write((uint64_t*)&cgen_var_298, 1 * 8);
- uint64_t cgen_var_299;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesCountBuffer, &cgen_var_299, 1);
- vkStream->write((uint64_t*)&cgen_var_299, 1 * 8);
+ uint64_t cgen_var_308;
+ vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&forMarshaling->targetCommandBuffer, &cgen_var_308, 1);
+ vkStream->write((uint64_t*)&cgen_var_308, 1 * 8);
+ uint64_t cgen_var_309;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesCountBuffer, &cgen_var_309, 1);
+ vkStream->write((uint64_t*)&cgen_var_309, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->sequencesCountOffset, sizeof(VkDeviceSize));
- uint64_t cgen_var_300;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesIndexBuffer, &cgen_var_300, 1);
- vkStream->write((uint64_t*)&cgen_var_300, 1 * 8);
+ uint64_t cgen_var_310;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesIndexBuffer, &cgen_var_310, 1);
+ vkStream->write((uint64_t*)&cgen_var_310, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->sequencesIndexOffset, sizeof(VkDeviceSize));
}
@@ -10549,28 +10677,28 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_301;
- vkStream->read((uint64_t*)&cgen_var_301, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_301, (VkObjectTableNVX*)&forUnmarshaling->objectTable, 1);
- uint64_t cgen_var_302;
- vkStream->read((uint64_t*)&cgen_var_302, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_302, (VkIndirectCommandsLayoutNVX*)&forUnmarshaling->indirectCommandsLayout, 1);
+ uint64_t cgen_var_311;
+ vkStream->read((uint64_t*)&cgen_var_311, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_311, (VkObjectTableNVX*)&forUnmarshaling->objectTable, 1);
+ uint64_t cgen_var_312;
+ vkStream->read((uint64_t*)&cgen_var_312, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_312, (VkIndirectCommandsLayoutNVX*)&forUnmarshaling->indirectCommandsLayout, 1);
vkStream->read((uint32_t*)&forUnmarshaling->indirectCommandsTokenCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->indirectCommandsTokenCount; ++i)
{
unmarshal_VkIndirectCommandsTokenNVX(vkStream, (VkIndirectCommandsTokenNVX*)(forUnmarshaling->pIndirectCommandsTokens + i));
}
vkStream->read((uint32_t*)&forUnmarshaling->maxSequencesCount, sizeof(uint32_t));
- uint64_t cgen_var_303;
- vkStream->read((uint64_t*)&cgen_var_303, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(&cgen_var_303, (VkCommandBuffer*)&forUnmarshaling->targetCommandBuffer, 1);
- uint64_t cgen_var_304;
- vkStream->read((uint64_t*)&cgen_var_304, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_304, (VkBuffer*)&forUnmarshaling->sequencesCountBuffer, 1);
+ uint64_t cgen_var_313;
+ vkStream->read((uint64_t*)&cgen_var_313, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(&cgen_var_313, (VkCommandBuffer*)&forUnmarshaling->targetCommandBuffer, 1);
+ uint64_t cgen_var_314;
+ vkStream->read((uint64_t*)&cgen_var_314, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_314, (VkBuffer*)&forUnmarshaling->sequencesCountBuffer, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->sequencesCountOffset, sizeof(VkDeviceSize));
- uint64_t cgen_var_305;
- vkStream->read((uint64_t*)&cgen_var_305, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_305, (VkBuffer*)&forUnmarshaling->sequencesIndexBuffer, 1);
+ uint64_t cgen_var_315;
+ vkStream->read((uint64_t*)&cgen_var_315, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_315, (VkBuffer*)&forUnmarshaling->sequencesIndexBuffer, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->sequencesIndexOffset, sizeof(VkDeviceSize));
}
@@ -10586,12 +10714,12 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_306;
- vkStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&forMarshaling->objectTable, &cgen_var_306, 1);
- vkStream->write((uint64_t*)&cgen_var_306, 1 * 8);
- uint64_t cgen_var_307;
- vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&forMarshaling->indirectCommandsLayout, &cgen_var_307, 1);
- vkStream->write((uint64_t*)&cgen_var_307, 1 * 8);
+ uint64_t cgen_var_316;
+ vkStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&forMarshaling->objectTable, &cgen_var_316, 1);
+ vkStream->write((uint64_t*)&cgen_var_316, 1 * 8);
+ uint64_t cgen_var_317;
+ vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&forMarshaling->indirectCommandsLayout, &cgen_var_317, 1);
+ vkStream->write((uint64_t*)&cgen_var_317, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->maxSequencesCount, sizeof(uint32_t));
}
@@ -10608,12 +10736,12 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_308;
- vkStream->read((uint64_t*)&cgen_var_308, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_308, (VkObjectTableNVX*)&forUnmarshaling->objectTable, 1);
- uint64_t cgen_var_309;
- vkStream->read((uint64_t*)&cgen_var_309, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_309, (VkIndirectCommandsLayoutNVX*)&forUnmarshaling->indirectCommandsLayout, 1);
+ uint64_t cgen_var_318;
+ vkStream->read((uint64_t*)&cgen_var_318, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_318, (VkObjectTableNVX*)&forUnmarshaling->objectTable, 1);
+ uint64_t cgen_var_319;
+ vkStream->read((uint64_t*)&cgen_var_319, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_319, (VkIndirectCommandsLayoutNVX*)&forUnmarshaling->indirectCommandsLayout, 1);
vkStream->read((uint32_t*)&forUnmarshaling->maxSequencesCount, sizeof(uint32_t));
}
@@ -10686,9 +10814,9 @@
{
vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_310;
- vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->pipeline, &cgen_var_310, 1);
- vkStream->write((uint64_t*)&cgen_var_310, 1 * 8);
+ uint64_t cgen_var_320;
+ vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->pipeline, &cgen_var_320, 1);
+ vkStream->write((uint64_t*)&cgen_var_320, 1 * 8);
}
void unmarshal_VkObjectTablePipelineEntryNVX(
@@ -10697,9 +10825,9 @@
{
vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_311;
- vkStream->read((uint64_t*)&cgen_var_311, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_311, (VkPipeline*)&forUnmarshaling->pipeline, 1);
+ uint64_t cgen_var_321;
+ vkStream->read((uint64_t*)&cgen_var_321, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_321, (VkPipeline*)&forUnmarshaling->pipeline, 1);
}
void marshal_VkObjectTableDescriptorSetEntryNVX(
@@ -10708,12 +10836,12 @@
{
vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_312;
- vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_312, 1);
- vkStream->write((uint64_t*)&cgen_var_312, 1 * 8);
- uint64_t cgen_var_313;
- vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->descriptorSet, &cgen_var_313, 1);
- vkStream->write((uint64_t*)&cgen_var_313, 1 * 8);
+ uint64_t cgen_var_322;
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_322, 1);
+ vkStream->write((uint64_t*)&cgen_var_322, 1 * 8);
+ uint64_t cgen_var_323;
+ vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->descriptorSet, &cgen_var_323, 1);
+ vkStream->write((uint64_t*)&cgen_var_323, 1 * 8);
}
void unmarshal_VkObjectTableDescriptorSetEntryNVX(
@@ -10722,12 +10850,12 @@
{
vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_314;
- vkStream->read((uint64_t*)&cgen_var_314, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_314, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
- uint64_t cgen_var_315;
- vkStream->read((uint64_t*)&cgen_var_315, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_315, (VkDescriptorSet*)&forUnmarshaling->descriptorSet, 1);
+ uint64_t cgen_var_324;
+ vkStream->read((uint64_t*)&cgen_var_324, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_324, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
+ uint64_t cgen_var_325;
+ vkStream->read((uint64_t*)&cgen_var_325, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_325, (VkDescriptorSet*)&forUnmarshaling->descriptorSet, 1);
}
void marshal_VkObjectTableVertexBufferEntryNVX(
@@ -10736,9 +10864,9 @@
{
vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_316;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_316, 1);
- vkStream->write((uint64_t*)&cgen_var_316, 1 * 8);
+ uint64_t cgen_var_326;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_326, 1);
+ vkStream->write((uint64_t*)&cgen_var_326, 1 * 8);
}
void unmarshal_VkObjectTableVertexBufferEntryNVX(
@@ -10747,9 +10875,9 @@
{
vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_317;
- vkStream->read((uint64_t*)&cgen_var_317, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_317, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ uint64_t cgen_var_327;
+ vkStream->read((uint64_t*)&cgen_var_327, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_327, (VkBuffer*)&forUnmarshaling->buffer, 1);
}
void marshal_VkObjectTableIndexBufferEntryNVX(
@@ -10758,9 +10886,9 @@
{
vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_318;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_318, 1);
- vkStream->write((uint64_t*)&cgen_var_318, 1 * 8);
+ uint64_t cgen_var_328;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_328, 1);
+ vkStream->write((uint64_t*)&cgen_var_328, 1 * 8);
vkStream->write((VkIndexType*)&forMarshaling->indexType, sizeof(VkIndexType));
}
@@ -10770,9 +10898,9 @@
{
vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_319;
- vkStream->read((uint64_t*)&cgen_var_319, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_319, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ uint64_t cgen_var_329;
+ vkStream->read((uint64_t*)&cgen_var_329, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_329, (VkBuffer*)&forUnmarshaling->buffer, 1);
vkStream->read((VkIndexType*)&forUnmarshaling->indexType, sizeof(VkIndexType));
}
@@ -10782,9 +10910,9 @@
{
vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_320;
- vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_320, 1);
- vkStream->write((uint64_t*)&cgen_var_320, 1 * 8);
+ uint64_t cgen_var_330;
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_330, 1);
+ vkStream->write((uint64_t*)&cgen_var_330, 1 * 8);
vkStream->write((VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
}
@@ -10794,9 +10922,9 @@
{
vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_321;
- vkStream->read((uint64_t*)&cgen_var_321, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_321, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
+ uint64_t cgen_var_331;
+ vkStream->read((uint64_t*)&cgen_var_331, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_331, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
vkStream->read((VkShaderStageFlags*)&forUnmarshaling->stageFlags, sizeof(VkShaderStageFlags));
}
@@ -10833,8 +10961,8 @@
vkStream->write((VkBool32*)&forMarshaling->viewportWScalingEnable, sizeof(VkBool32));
vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_322 = (uint64_t)(uintptr_t)forMarshaling->pViewportWScalings;
- vkStream->putBe64(cgen_var_322);
+ uint64_t cgen_var_332 = (uint64_t)(uintptr_t)forMarshaling->pViewportWScalings;
+ vkStream->putBe64(cgen_var_332);
if (forMarshaling->pViewportWScalings)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
@@ -11126,8 +11254,8 @@
}
vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_324 = (uint64_t)(uintptr_t)forMarshaling->pTimes;
- vkStream->putBe64(cgen_var_324);
+ uint64_t cgen_var_334 = (uint64_t)(uintptr_t)forMarshaling->pTimes;
+ vkStream->putBe64(cgen_var_334);
if (forMarshaling->pTimes)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i)
@@ -11243,8 +11371,8 @@
vkStream->write((VkPipelineViewportSwizzleStateCreateFlagsNV*)&forMarshaling->flags, sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV));
vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_326 = (uint64_t)(uintptr_t)forMarshaling->pViewportSwizzles;
- vkStream->putBe64(cgen_var_326);
+ uint64_t cgen_var_336 = (uint64_t)(uintptr_t)forMarshaling->pViewportSwizzles;
+ vkStream->putBe64(cgen_var_336);
if (forMarshaling->pViewportSwizzles)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
@@ -11334,8 +11462,8 @@
vkStream->write((VkDiscardRectangleModeEXT*)&forMarshaling->discardRectangleMode, sizeof(VkDiscardRectangleModeEXT));
vkStream->write((uint32_t*)&forMarshaling->discardRectangleCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_328 = (uint64_t)(uintptr_t)forMarshaling->pDiscardRectangles;
- vkStream->putBe64(cgen_var_328);
+ uint64_t cgen_var_338 = (uint64_t)(uintptr_t)forMarshaling->pDiscardRectangles;
+ vkStream->putBe64(cgen_var_338);
if (forMarshaling->pDiscardRectangles)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->discardRectangleCount; ++i)
@@ -11542,8 +11670,8 @@
}
vkStream->write((VkIOSSurfaceCreateFlagsMVK*)&forMarshaling->flags, sizeof(VkIOSSurfaceCreateFlagsMVK));
// WARNING PTR CHECK
- uint64_t cgen_var_330 = (uint64_t)(uintptr_t)forMarshaling->pView;
- vkStream->putBe64(cgen_var_330);
+ uint64_t cgen_var_340 = (uint64_t)(uintptr_t)forMarshaling->pView;
+ vkStream->putBe64(cgen_var_340);
if (forMarshaling->pView)
{
vkStream->write((const void*)forMarshaling->pView, sizeof(const uint8_t));
@@ -11593,8 +11721,8 @@
}
vkStream->write((VkMacOSSurfaceCreateFlagsMVK*)&forMarshaling->flags, sizeof(VkMacOSSurfaceCreateFlagsMVK));
// WARNING PTR CHECK
- uint64_t cgen_var_332 = (uint64_t)(uintptr_t)forMarshaling->pView;
- vkStream->putBe64(cgen_var_332);
+ uint64_t cgen_var_342 = (uint64_t)(uintptr_t)forMarshaling->pView;
+ vkStream->putBe64(cgen_var_342);
if (forMarshaling->pView)
{
vkStream->write((const void*)forMarshaling->pView, sizeof(const uint8_t));
@@ -11651,8 +11779,8 @@
if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
{
// WARNING PTR CHECK
- uint64_t cgen_var_334 = (uint64_t)(uintptr_t)forMarshaling->pObjectName;
- vkStream->putBe64(cgen_var_334);
+ uint64_t cgen_var_344 = (uint64_t)(uintptr_t)forMarshaling->pObjectName;
+ vkStream->putBe64(cgen_var_344);
if (forMarshaling->pObjectName)
{
vkStream->putString(forMarshaling->pObjectName);
@@ -11714,8 +11842,8 @@
vkStream->write((VkObjectType*)&forMarshaling->objectType, sizeof(VkObjectType));
vkStream->write((uint64_t*)&forMarshaling->objectHandle, sizeof(uint64_t));
vkStream->write((uint64_t*)&forMarshaling->tagName, sizeof(uint64_t));
- uint64_t cgen_var_336 = (uint64_t)forMarshaling->tagSize;
- vkStream->putBe64(cgen_var_336);
+ uint64_t cgen_var_346 = (uint64_t)forMarshaling->tagSize;
+ vkStream->putBe64(cgen_var_346);
vkStream->write((const void*)forMarshaling->pTag, forMarshaling->tagSize * sizeof(const uint8_t));
}
@@ -11788,8 +11916,8 @@
if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
{
// WARNING PTR CHECK
- uint64_t cgen_var_338 = (uint64_t)(uintptr_t)forMarshaling->pMessageIdName;
- vkStream->putBe64(cgen_var_338);
+ uint64_t cgen_var_348 = (uint64_t)(uintptr_t)forMarshaling->pMessageIdName;
+ vkStream->putBe64(cgen_var_348);
if (forMarshaling->pMessageIdName)
{
vkStream->putString(forMarshaling->pMessageIdName);
@@ -11803,8 +11931,8 @@
vkStream->putString(forMarshaling->pMessage);
vkStream->write((uint32_t*)&forMarshaling->queueLabelCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_339 = (uint64_t)(uintptr_t)forMarshaling->pQueueLabels;
- vkStream->putBe64(cgen_var_339);
+ uint64_t cgen_var_349 = (uint64_t)(uintptr_t)forMarshaling->pQueueLabels;
+ vkStream->putBe64(cgen_var_349);
if (forMarshaling->pQueueLabels)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueLabelCount; ++i)
@@ -11814,8 +11942,8 @@
}
vkStream->write((uint32_t*)&forMarshaling->cmdBufLabelCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_340 = (uint64_t)(uintptr_t)forMarshaling->pCmdBufLabels;
- vkStream->putBe64(cgen_var_340);
+ uint64_t cgen_var_350 = (uint64_t)(uintptr_t)forMarshaling->pCmdBufLabels;
+ vkStream->putBe64(cgen_var_350);
if (forMarshaling->pCmdBufLabels)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->cmdBufLabelCount; ++i)
@@ -11825,8 +11953,8 @@
}
vkStream->write((uint32_t*)&forMarshaling->objectCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_341 = (uint64_t)(uintptr_t)forMarshaling->pObjects;
- vkStream->putBe64(cgen_var_341);
+ uint64_t cgen_var_351 = (uint64_t)(uintptr_t)forMarshaling->pObjects;
+ vkStream->putBe64(cgen_var_351);
if (forMarshaling->pObjects)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->objectCount; ++i)
@@ -11932,11 +12060,11 @@
vkStream->write((VkDebugUtilsMessengerCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugUtilsMessengerCreateFlagsEXT));
vkStream->write((VkDebugUtilsMessageSeverityFlagsEXT*)&forMarshaling->messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagsEXT));
vkStream->write((VkDebugUtilsMessageTypeFlagsEXT*)&forMarshaling->messageType, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
- uint64_t cgen_var_346 = (uint64_t)forMarshaling->pfnUserCallback;
- vkStream->putBe64(cgen_var_346);
+ uint64_t cgen_var_356 = (uint64_t)forMarshaling->pfnUserCallback;
+ vkStream->putBe64(cgen_var_356);
// WARNING PTR CHECK
- uint64_t cgen_var_347 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
- vkStream->putBe64(cgen_var_347);
+ uint64_t cgen_var_357 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
+ vkStream->putBe64(cgen_var_357);
if (forMarshaling->pUserData)
{
vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
@@ -12127,9 +12255,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_350;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_350, 1);
- vkStream->write((uint64_t*)&cgen_var_350, 1 * 8);
+ uint64_t cgen_var_360;
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_360, 1);
+ vkStream->write((uint64_t*)&cgen_var_360, 1 * 8);
}
void unmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
@@ -12145,9 +12273,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_351;
- vkStream->read((uint64_t*)&cgen_var_351, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_351, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ uint64_t cgen_var_361;
+ vkStream->read((uint64_t*)&cgen_var_361, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_361, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
}
void marshal_VkExternalFormatANDROID(
@@ -12665,8 +12793,8 @@
vkStream->write((VkBool32*)&forMarshaling->coverageModulationTableEnable, sizeof(VkBool32));
vkStream->write((uint32_t*)&forMarshaling->coverageModulationTableCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_352 = (uint64_t)(uintptr_t)forMarshaling->pCoverageModulationTable;
- vkStream->putBe64(cgen_var_352);
+ uint64_t cgen_var_362 = (uint64_t)(uintptr_t)forMarshaling->pCoverageModulationTable;
+ vkStream->putBe64(cgen_var_362);
if (forMarshaling->pCoverageModulationTable)
{
vkStream->write((const float*)forMarshaling->pCoverageModulationTable, forMarshaling->coverageModulationTableCount * sizeof(const float));
@@ -12722,8 +12850,8 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
vkStream->write((VkValidationCacheCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkValidationCacheCreateFlagsEXT));
- uint64_t cgen_var_354 = (uint64_t)forMarshaling->initialDataSize;
- vkStream->putBe64(cgen_var_354);
+ uint64_t cgen_var_364 = (uint64_t)forMarshaling->initialDataSize;
+ vkStream->putBe64(cgen_var_364);
vkStream->write((const void*)forMarshaling->pInitialData, forMarshaling->initialDataSize * sizeof(const uint8_t));
}
@@ -12757,9 +12885,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_356;
- vkStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&forMarshaling->validationCache, &cgen_var_356, 1);
- vkStream->write((uint64_t*)&cgen_var_356, 1 * 8);
+ uint64_t cgen_var_366;
+ vkStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&forMarshaling->validationCache, &cgen_var_366, 1);
+ vkStream->write((uint64_t*)&cgen_var_366, 1 * 8);
}
void unmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
@@ -12775,9 +12903,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_357;
- vkStream->read((uint64_t*)&cgen_var_357, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(&cgen_var_357, (VkValidationCacheEXT*)&forUnmarshaling->validationCache, 1);
+ uint64_t cgen_var_367;
+ vkStream->read((uint64_t*)&cgen_var_367, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(&cgen_var_367, (VkValidationCacheEXT*)&forUnmarshaling->validationCache, 1);
}
#endif
@@ -13074,8 +13202,8 @@
}
vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
// WARNING PTR CHECK
- uint64_t cgen_var_358 = (uint64_t)(uintptr_t)forMarshaling->pHostPointer;
- vkStream->putBe64(cgen_var_358);
+ uint64_t cgen_var_368 = (uint64_t)(uintptr_t)forMarshaling->pHostPointer;
+ vkStream->putBe64(cgen_var_368);
if (forMarshaling->pHostPointer)
{
vkStream->write((void*)forMarshaling->pHostPointer, sizeof(uint8_t));
@@ -13369,8 +13497,8 @@
}
vkStream->write((VkPipelineStageFlagBits*)&forMarshaling->stage, sizeof(VkPipelineStageFlagBits));
// WARNING PTR CHECK
- uint64_t cgen_var_360 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
- vkStream->putBe64(cgen_var_360);
+ uint64_t cgen_var_370 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
+ vkStream->putBe64(cgen_var_370);
if (forMarshaling->pCheckpointMarker)
{
vkStream->write((void*)forMarshaling->pCheckpointMarker, sizeof(uint8_t));
diff --git a/system/vulkan_enc/goldfish_vk_private_defs.h b/system/vulkan_enc/goldfish_vk_private_defs.h
index 21eb730..b967d89 100644
--- a/system/vulkan_enc/goldfish_vk_private_defs.h
+++ b/system/vulkan_enc/goldfish_vk_private_defs.h
@@ -17,6 +17,7 @@
#include <vulkan/vulkan.h>
#ifdef __cplusplus
+#include <algorithm>
extern "C" {
#endif
@@ -534,9 +535,20 @@
// VulkanStream features
#define VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT (1 << 0)
+#define VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT (1 << 1)
#define VK_YCBCR_CONVERSION_DO_NOTHING ((VkSamplerYcbcrConversion)0x1111111111111111)
#ifdef __cplusplus
} // extern "C"
#endif
+
+#ifdef __cplusplus
+
+template<class T, typename F>
+bool arrayany(const T* arr, uint32_t begin, uint32_t end, const F& func) {
+ const T* e = arr + end;
+ return std::find_if(arr + begin, e, func) != e;
+}
+
+#endif
