Snap for 5735642 from c9a07f2ee969eb0d0769d793a9dba7e01f346ce3 to sdk-release
Change-Id: I7e66d667be26a6e72c08262ad758739970105113
diff --git a/host/include/libOpenglRender/IOStream.h b/host/include/libOpenglRender/IOStream.h
index d06440e..ad82072 100644
--- a/host/include/libOpenglRender/IOStream.h
+++ b/host/include/libOpenglRender/IOStream.h
@@ -33,6 +33,7 @@
virtual void *allocBuffer(size_t minSize) = 0;
virtual int commitBuffer(size_t size) = 0;
virtual const unsigned char *readFully( void *buf, size_t len) = 0;
+ virtual const unsigned char *commitBufferAndReadFully(size_t size, void *buf, size_t len) = 0;
virtual const unsigned char *read( void *buf, size_t *inout_len) = 0;
virtual int writeFully(const void* buf, size_t len) = 0;
@@ -79,7 +80,12 @@
}
const unsigned char *readback(void *buf, size_t len) {
- flush();
+ if (m_buf && m_free != m_bufsize) {
+ size_t size = m_bufsize - m_free;
+ m_buf = NULL;
+ m_free = 0;
+ return commitBufferAndReadFully(size, buf, len);
+ }
return readFully(buf, len);
}
diff --git a/shared/OpenglCodecCommon/SocketStream.cpp b/shared/OpenglCodecCommon/SocketStream.cpp
index e813142..d6d31c0 100644
--- a/shared/OpenglCodecCommon/SocketStream.cpp
+++ b/shared/OpenglCodecCommon/SocketStream.cpp
@@ -130,6 +130,11 @@
return (const unsigned char *)buf;
}
+const unsigned char *SocketStream::commitBufferAndReadFully(size_t size, void *buf, size_t len)
+{
+ return commitBuffer(size) ? NULL : readFully(buf, len);
+}
+
const unsigned char *SocketStream::read( void *buf, size_t *inout_len)
{
if (!valid()) return NULL;
diff --git a/shared/OpenglCodecCommon/SocketStream.h b/shared/OpenglCodecCommon/SocketStream.h
index 3a501b4..3d8f5f5 100644
--- a/shared/OpenglCodecCommon/SocketStream.h
+++ b/shared/OpenglCodecCommon/SocketStream.h
@@ -33,6 +33,7 @@
virtual void *allocBuffer(size_t minSize);
virtual int commitBuffer(size_t size);
virtual const unsigned char *readFully(void *buf, size_t len);
+ virtual const unsigned char *commitBufferAndReadFully(size_t size, void *buf, size_t len);
virtual const unsigned char *read(void *buf, size_t *inout_len);
bool valid() { return m_sock >= 0; }
diff --git a/shared/OpenglCodecCommon/goldfish_address_space.cpp b/shared/OpenglCodecCommon/goldfish_address_space.cpp
index 2502c13..7bb628c 100644
--- a/shared/OpenglCodecCommon/goldfish_address_space.cpp
+++ b/shared/OpenglCodecCommon/goldfish_address_space.cpp
@@ -13,122 +13,14 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-#if PLATFORM_SDK_VERSION < 26
-#include <cutils/log.h>
+#if defined(HOST_BUILD)
+#include "goldfish_address_space_host.impl"
+#elif defined(__Fuchsia__)
+#include "goldfish_address_space_fuchsia.impl"
#else
-#include <log/log.h>
+#include "goldfish_address_space_android.impl"
#endif
-#include "goldfish_address_space.h"
-
-#ifdef HOST_BUILD
-
-#include "android/emulation/hostdevices/HostAddressSpace.h"
-
-using android::HostAddressSpaceDevice;
-
-GoldfishAddressSpaceBlockProvider::GoldfishAddressSpaceBlockProvider()
- : m_handle(HostAddressSpaceDevice::get()->open()) { }
-
-GoldfishAddressSpaceBlockProvider::~GoldfishAddressSpaceBlockProvider()
-{
- HostAddressSpaceDevice::get()->close(m_handle);
-}
-
-GoldfishAddressSpaceBlock::GoldfishAddressSpaceBlock()
- : m_mmaped_ptr(NULL)
- , m_phys_addr(0)
- , m_host_addr(0)
- , m_offset(0)
- , m_size(0)
- , m_handle(0) {}
-
-GoldfishAddressSpaceBlock::~GoldfishAddressSpaceBlock()
-{
- destroy();
-}
-
-GoldfishAddressSpaceBlock &GoldfishAddressSpaceBlock::operator=(const GoldfishAddressSpaceBlock &rhs)
-{
- m_mmaped_ptr = rhs.m_mmaped_ptr;
- m_phys_addr = rhs.m_phys_addr;
- m_host_addr = rhs.m_host_addr;
- m_offset = rhs.m_offset;
- m_size = rhs.m_size;
- m_handle = rhs.m_handle;
-
- return *this;
-}
-
-bool GoldfishAddressSpaceBlock::allocate(GoldfishAddressSpaceBlockProvider *provider, size_t size)
-{
-
- ALOGD("%s: Ask for block of size 0x%llx\n", __func__,
- (unsigned long long)size);
-
- destroy();
-
- if (!provider->is_opened()) {
- return false;
- }
-
- m_size = size;
- m_offset =
- HostAddressSpaceDevice::get()->allocBlock(
- provider->m_handle, size, &m_phys_addr);
- m_handle = provider->m_handle;
-
- return true;
-}
-
-uint64_t GoldfishAddressSpaceBlock::physAddr() const
-{
- return m_phys_addr;
-}
-
-uint64_t GoldfishAddressSpaceBlock::hostAddr() const
-{
- return m_host_addr;
-}
-
-void *GoldfishAddressSpaceBlock::mmap(uint64_t host_addr)
-{
- if (m_size == 0) {
- ALOGE("%s: called with zero size\n", __func__);
- return NULL;
- }
-
- if (m_mmaped_ptr != nullptr) {
- ALOGE("'mmap' called for an already mmaped address block 0x%llx %d", (unsigned long long)m_mmaped_ptr, nullptr == m_mmaped_ptr);
- ::abort();
- }
-
- m_mmaped_ptr = (void*)(uintptr_t)(host_addr & (~(PAGE_SIZE - 1)));
- m_host_addr = host_addr;
-
- return guestPtr();
-}
-
-void *GoldfishAddressSpaceBlock::guestPtr() const
-{
- return reinterpret_cast<char *>(m_mmaped_ptr) + (m_host_addr & (PAGE_SIZE - 1));
-}
-
-void GoldfishAddressSpaceBlock::destroy()
-{
- if (m_mmaped_ptr && m_size) {
- m_mmaped_ptr = NULL;
- }
-
- if (m_size) {
- HostAddressSpaceDevice::get()->freeBlock(m_handle, m_offset);
- m_phys_addr = 0;
- m_host_addr = 0;
- m_offset = 0;
- m_size = 0;
- }
-}
-
void GoldfishAddressSpaceBlock::replace(GoldfishAddressSpaceBlock *other)
{
destroy();
@@ -138,349 +30,3 @@
*other = GoldfishAddressSpaceBlock();
}
}
-
-bool GoldfishAddressSpaceBlockProvider::is_opened()
-{
- return m_handle > 0;
-}
-
-#elif __Fuchsia__
-#include <fcntl.h>
-#include <lib/fdio/fdio.h>
-#include <lib/zx/channel.h>
-#include <lib/zx/vmo.h>
-#include <stdlib.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <zircon/process.h>
-#include <zircon/syscalls.h>
-#include <zircon/syscalls/object.h>
-
-GoldfishAddressSpaceBlockProvider::GoldfishAddressSpaceBlockProvider() {
- zx::channel channel;
- zx_status_t status =
- fdio_get_service_handle(::open(GOLDFISH_ADDRESS_SPACE_DEVICE_NAME, O_RDWR),
- channel.reset_and_get_address());
- if (status != ZX_OK) {
- ALOGE("%s: failed to get service handle for " GOLDFISH_ADDRESS_SPACE_DEVICE_NAME ": %d",
- __FUNCTION__, status);
- return;
- }
- m_device.Bind(std::move(channel));
-}
-
-GoldfishAddressSpaceBlockProvider::~GoldfishAddressSpaceBlockProvider()
-{
-}
-
-GoldfishAddressSpaceBlock::GoldfishAddressSpaceBlock()
- : m_device(NULL)
- , m_vmo(ZX_HANDLE_INVALID)
- , m_mmaped_ptr(NULL)
- , m_phys_addr(0)
- , m_host_addr(0)
- , m_offset(0)
- , m_size(0) {}
-
-GoldfishAddressSpaceBlock::~GoldfishAddressSpaceBlock()
-{
- destroy();
-}
-
-GoldfishAddressSpaceBlock &GoldfishAddressSpaceBlock::operator=(const GoldfishAddressSpaceBlock &rhs)
-{
- m_vmo = rhs.m_vmo;
- m_mmaped_ptr = rhs.m_mmaped_ptr;
- m_phys_addr = rhs.m_phys_addr;
- m_host_addr = rhs.m_host_addr;
- m_offset = rhs.m_offset;
- m_size = rhs.m_size;
- m_device = rhs.m_device;
-
- return *this;
-}
-
-bool GoldfishAddressSpaceBlock::allocate(GoldfishAddressSpaceBlockProvider *provider, size_t size)
-{
- ALOGD("%s: Ask for block of size 0x%llx\n", __func__,
- (unsigned long long)size);
-
- destroy();
-
- if (!provider->is_opened()) {
- return false;
- }
-
- fuchsia::hardware::goldfish::address::space::DeviceSyncPtr* device = &provider->m_device;
-
- int32_t res = ZX_OK;
- zx::vmo vmo;
- zx_status_t status = (*device)->AllocateBlock(size, &res, &m_phys_addr, &vmo);
- if (status != ZX_OK || res != ZX_OK) {
- ALOGE("%s: allocate block failed: %d:%d", __func__, status, res);
- return false;
- }
-
- m_offset = 0;
- m_size = size;
- m_vmo = vmo.release();
-
- ALOGD("%s: allocate returned offset 0x%llx size 0x%llx\n", __func__,
- (unsigned long long)m_offset,
- (unsigned long long)m_size);
-
- m_device = device;
- return true;
-}
-
-uint64_t GoldfishAddressSpaceBlock::physAddr() const
-{
- return m_phys_addr;
-}
-
-uint64_t GoldfishAddressSpaceBlock::hostAddr() const
-{
- return m_host_addr;
-}
-
-void *GoldfishAddressSpaceBlock::mmap(uint64_t host_addr)
-{
- if (m_size == 0) {
- ALOGE("%s: called with zero size\n", __func__);
- return NULL;
- }
- if (m_mmaped_ptr) {
- ALOGE("'mmap' called for an already mmaped address block");
- ::abort();
- }
-
- zx_vaddr_t ptr = 0;
- zx_status_t status = zx_vmar_map(zx_vmar_root_self(),
- ZX_VM_PERM_READ | ZX_VM_PERM_WRITE,
- 0, m_vmo,
- m_offset,
- m_size,
- &ptr);
- if (status != ZX_OK) {
- ALOGE("%s: host memory map failed with size 0x%llx "
- "off 0x%llx status %d\n",
- __func__,
- (unsigned long long)m_size,
- (unsigned long long)m_offset, status);
- return NULL;
- } else {
- m_mmaped_ptr = (void*)ptr;
- m_host_addr = host_addr;
- return guestPtr();
- }
-}
-
-void *GoldfishAddressSpaceBlock::guestPtr() const
-{
- return reinterpret_cast<char *>(m_mmaped_ptr) + (m_host_addr & (PAGE_SIZE - 1));
-}
-
-void GoldfishAddressSpaceBlock::destroy()
-{
- if (m_mmaped_ptr && m_size) {
- zx_vmar_unmap(zx_vmar_root_self(),
- (zx_vaddr_t)m_mmaped_ptr,
- m_size);
- m_mmaped_ptr = NULL;
- }
-
- if (m_size) {
- zx_handle_close(m_vmo);
- m_vmo = ZX_HANDLE_INVALID;
- int32_t res = ZX_OK;
- zx_status_t status = (*m_device)->DeallocateBlock(m_phys_addr, &res);
- if (status != ZX_OK || res != ZX_OK) {
- ALOGE("%s: deallocate block failed: %d:%d", __func__, status, res);
- }
- m_device = NULL;
- m_phys_addr = 0;
- m_host_addr = 0;
- m_offset = 0;
- m_size = 0;
- }
-}
-
-void GoldfishAddressSpaceBlock::replace(GoldfishAddressSpaceBlock *other)
-{
- destroy();
-
- if (other) {
- *this = *other;
- *other = GoldfishAddressSpaceBlock();
- }
-}
-
-bool GoldfishAddressSpaceBlockProvider::is_opened()
-{
- return m_device.is_bound();
-}
-#else
-#include <linux/types.h>
-#include <linux/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/mman.h>
-#include <sys/ioctl.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <cstdlib>
-#include <errno.h>
-
-struct goldfish_address_space_allocate_block {
- __u64 size;
- __u64 offset;
- __u64 phys_addr;
-};
-
-#define GOLDFISH_ADDRESS_SPACE_IOCTL_MAGIC 'G'
-#define GOLDFISH_ADDRESS_SPACE_IOCTL_OP(OP, T) _IOWR(GOLDFISH_ADDRESS_SPACE_IOCTL_MAGIC, OP, T)
-#define GOLDFISH_ADDRESS_SPACE_IOCTL_ALLOCATE_BLOCK GOLDFISH_ADDRESS_SPACE_IOCTL_OP(10, struct goldfish_address_space_allocate_block)
-#define GOLDFISH_ADDRESS_SPACE_IOCTL_DEALLOCATE_BLOCK GOLDFISH_ADDRESS_SPACE_IOCTL_OP(11, __u64)
-
-const char GOLDFISH_ADDRESS_SPACE_DEVICE_NAME[] = "/dev/goldfish_address_space";
-
-GoldfishAddressSpaceBlockProvider::GoldfishAddressSpaceBlockProvider()
- : m_fd(::open(GOLDFISH_ADDRESS_SPACE_DEVICE_NAME, O_RDWR)) {}
-
-GoldfishAddressSpaceBlockProvider::~GoldfishAddressSpaceBlockProvider()
-{
- ::close(m_fd);
-}
-
-GoldfishAddressSpaceBlock::GoldfishAddressSpaceBlock()
- : m_mmaped_ptr(NULL)
- , m_phys_addr(0)
- , m_host_addr(0)
- , m_offset(0)
- , m_size(0)
- , m_fd(-1) {}
-
-GoldfishAddressSpaceBlock::~GoldfishAddressSpaceBlock()
-{
- destroy();
-}
-
-GoldfishAddressSpaceBlock &GoldfishAddressSpaceBlock::operator=(const GoldfishAddressSpaceBlock &rhs)
-{
- m_mmaped_ptr = rhs.m_mmaped_ptr;
- m_phys_addr = rhs.m_phys_addr;
- m_host_addr = rhs.m_host_addr;
- m_offset = rhs.m_offset;
- m_size = rhs.m_size;
- m_fd = rhs.m_fd;
-
- return *this;
-}
-
-bool GoldfishAddressSpaceBlock::allocate(GoldfishAddressSpaceBlockProvider *provider, size_t size)
-{
-
- ALOGD("%s: Ask for block of size 0x%llx\n", __func__,
- (unsigned long long)size);
-
- destroy();
-
- if (!provider->is_opened()) {
- return false;
- }
-
- struct goldfish_address_space_allocate_block request;
- long res;
-
- request.size = size;
- res = ::ioctl(provider->m_fd, GOLDFISH_ADDRESS_SPACE_IOCTL_ALLOCATE_BLOCK, &request);
- if (res) {
- return false;
- } else {
- m_phys_addr = request.phys_addr;
-
- m_offset = request.offset;
- m_size = request.size;
-
- ALOGD("%s: ioctl allocate returned offset 0x%llx size 0x%llx\n", __func__,
- (unsigned long long)m_offset,
- (unsigned long long)m_size);
-
- m_fd = provider->m_fd;
- return true;
- }
-}
-
-uint64_t GoldfishAddressSpaceBlock::physAddr() const
-{
- return m_phys_addr;
-}
-
-uint64_t GoldfishAddressSpaceBlock::hostAddr() const
-{
- return m_host_addr;
-}
-
-void *GoldfishAddressSpaceBlock::mmap(uint64_t host_addr)
-{
- if (m_size == 0) {
- ALOGE("%s: called with zero size\n", __func__);
- return NULL;
- }
- if (m_mmaped_ptr) {
- ALOGE("'mmap' called for an already mmaped address block");
- ::abort();
- }
-
- void *result = ::mmap64(NULL, m_size, PROT_WRITE, MAP_SHARED, m_fd, m_offset);
- if (result == MAP_FAILED) {
- ALOGE("%s: host memory map failed with size 0x%llx "
- "off 0x%llx errno %d\n",
- __func__,
- (unsigned long long)m_size,
- (unsigned long long)m_offset, errno);
- return NULL;
- } else {
- m_mmaped_ptr = result;
- m_host_addr = host_addr;
- return guestPtr();
- }
-}
-
-void *GoldfishAddressSpaceBlock::guestPtr() const
-{
- return reinterpret_cast<char *>(m_mmaped_ptr) + (m_host_addr & (PAGE_SIZE - 1));
-}
-
-void GoldfishAddressSpaceBlock::destroy()
-{
- if (m_mmaped_ptr && m_size) {
- ::munmap(m_mmaped_ptr, m_size);
- m_mmaped_ptr = NULL;
- }
-
- if (m_size) {
- ::ioctl(m_fd, GOLDFISH_ADDRESS_SPACE_IOCTL_DEALLOCATE_BLOCK, &m_offset);
- m_phys_addr = 0;
- m_host_addr = 0;
- m_offset = 0;
- m_size = 0;
- }
-}
-
-void GoldfishAddressSpaceBlock::replace(GoldfishAddressSpaceBlock *other)
-{
- destroy();
-
- if (other) {
- *this = *other;
- *other = GoldfishAddressSpaceBlock();
- }
-}
-
-bool GoldfishAddressSpaceBlockProvider::is_opened()
-{
- return m_fd >= 0;
-}
-#endif
diff --git a/shared/OpenglCodecCommon/goldfish_address_space.h b/shared/OpenglCodecCommon/goldfish_address_space.h
index a5c0d77..f527152 100644
--- a/shared/OpenglCodecCommon/goldfish_address_space.h
+++ b/shared/OpenglCodecCommon/goldfish_address_space.h
@@ -23,6 +23,7 @@
#endif
class GoldfishAddressSpaceBlock;
+class GoldfishAddressSpaceHostMemoryAllocator;
#ifdef HOST_BUILD
@@ -40,21 +41,23 @@
~GoldfishAddressSpaceBlockProvider();
private:
- GoldfishAddressSpaceBlockProvider(const GoldfishAddressSpaceBlockProvider &rhs);
- GoldfishAddressSpaceBlockProvider &operator=(const GoldfishAddressSpaceBlockProvider &rhs);
+ GoldfishAddressSpaceBlockProvider(const GoldfishAddressSpaceBlockProvider &rhs);
+ GoldfishAddressSpaceBlockProvider &operator=(const GoldfishAddressSpaceBlockProvider &rhs);
- bool is_opened();
+ bool is_opened() const;
+ void close();
#ifdef HOST_BUILD
- uint32_t m_handle;
+ uint32_t m_handle;
#else // HOST_BUILD
#ifdef __Fuchsia__
- fuchsia::hardware::goldfish::address::space::DeviceSyncPtr m_device;
+ fuchsia::hardware::goldfish::address::space::DeviceSyncPtr m_device;
#else // __Fuchsia__
- int m_fd;
+ int m_fd;
#endif // !__Fuchsia__
#endif // !HOST_BUILD
- friend class GoldfishAddressSpaceBlock;
+ friend class GoldfishAddressSpaceBlock;
+ friend class GoldfishAddressSpaceHostMemoryAllocator;
};
class GoldfishAddressSpaceBlock {
@@ -65,9 +68,11 @@
bool allocate(GoldfishAddressSpaceBlockProvider *provider, size_t size);
uint64_t physAddr() const;
uint64_t hostAddr() const;
+ uint64_t offset() const { return m_offset; }
+ size_t size() const { return m_size; }
void *mmap(uint64_t opaque);
void *guestPtr() const;
- void replace(GoldfishAddressSpaceBlock *x);
+ void replace(GoldfishAddressSpaceBlock *other);
private:
void destroy();
@@ -92,7 +97,18 @@
uint64_t m_phys_addr;
uint64_t m_host_addr;
uint64_t m_offset;
- size_t m_size;
+ uint64_t m_size;
};
-#endif
+class GoldfishAddressSpaceHostMemoryAllocator {
+public:
+ GoldfishAddressSpaceHostMemoryAllocator();
+
+ long hostMalloc(GoldfishAddressSpaceBlock *block, size_t size);
+ void hostFree(GoldfishAddressSpaceBlock *block);
+
+private:
+ GoldfishAddressSpaceBlockProvider m_provider;
+};
+
+#endif // #ifndef ANDROID_INCLUDE_HARDWARE_GOLDFISH_ADDRESS_SPACE_H
diff --git a/shared/OpenglCodecCommon/goldfish_address_space_android.impl b/shared/OpenglCodecCommon/goldfish_address_space_android.impl
new file mode 100644
index 0000000..4926cf9
--- /dev/null
+++ b/shared/OpenglCodecCommon/goldfish_address_space_android.impl
@@ -0,0 +1,297 @@
+// Copyright (C) 2019 The Android Open Source Project
+// Copyright (C) 2019 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <linux/types.h>
+#include <linux/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <cstdlib>
+#include <errno.h>
+#include <memory>
+
+#if PLATFORM_SDK_VERSION < 26
+#include <cutils/log.h>
+#else
+#include <log/log.h>
+#endif
+
+#include "goldfish_address_space.h"
+
+namespace {
+
+struct goldfish_address_space_allocate_block {
+ __u64 size;
+ __u64 offset;
+ __u64 phys_addr;
+};
+
+struct goldfish_address_space_ping {
+ __u64 offset;
+ __u64 size;
+ __u64 metadata;
+ __u64 wait_offset;
+ __u32 wait_flags;
+ __u32 direction;
+};
+
+#define GOLDFISH_ADDRESS_SPACE_IOCTL_MAGIC 'G'
+#define GOLDFISH_ADDRESS_SPACE_IOCTL_OP(OP, T) _IOWR(GOLDFISH_ADDRESS_SPACE_IOCTL_MAGIC, OP, T)
+#define GOLDFISH_ADDRESS_SPACE_IOCTL_ALLOCATE_BLOCK GOLDFISH_ADDRESS_SPACE_IOCTL_OP(10, struct goldfish_address_space_allocate_block)
+#define GOLDFISH_ADDRESS_SPACE_IOCTL_DEALLOCATE_BLOCK GOLDFISH_ADDRESS_SPACE_IOCTL_OP(11, __u64)
+#define GOLDFISH_ADDRESS_SPACE_IOCTL_PING GOLDFISH_ADDRESS_SPACE_IOCTL_OP(12, struct goldfish_address_space_ping)
+
+const char GOLDFISH_ADDRESS_SPACE_DEVICE_NAME[] = "/dev/goldfish_address_space";
+
+const int DEVICE_TYPE_HOST_MEMORY_ALLOCATOR_ID = 5;
+const int HOST_MEMORY_ALLOCATOR_COMMAND_ALLOCATE_ID = 1;
+const int HOST_MEMORY_ALLOCATOR_COMMAND_UNALLOCATE_ID = 2;
+
+long ioctl_allocate(int fd, struct goldfish_address_space_allocate_block *request)
+{
+ return ::ioctl(fd, GOLDFISH_ADDRESS_SPACE_IOCTL_ALLOCATE_BLOCK, request);
+}
+
+long ioctl_deallocate(int fd, uint64_t offset)
+{
+ return ::ioctl(fd, GOLDFISH_ADDRESS_SPACE_IOCTL_DEALLOCATE_BLOCK, &offset);
+}
+
+long ioctl_ping(int fd, struct goldfish_address_space_ping *request)
+{
+ return ::ioctl(fd, GOLDFISH_ADDRESS_SPACE_IOCTL_PING, request);
+}
+
+} // namespace
+
+GoldfishAddressSpaceBlockProvider::GoldfishAddressSpaceBlockProvider()
+ : m_fd(::open(GOLDFISH_ADDRESS_SPACE_DEVICE_NAME, O_RDWR)) {}
+
+GoldfishAddressSpaceBlockProvider::~GoldfishAddressSpaceBlockProvider()
+{
+ ::close(m_fd);
+}
+
+bool GoldfishAddressSpaceBlockProvider::is_opened() const
+{
+ return m_fd >= 0;
+}
+
+void GoldfishAddressSpaceBlockProvider::close()
+{
+ if (is_opened()) {
+ ::close(m_fd);
+ m_fd = -1;
+ }
+}
+
+GoldfishAddressSpaceBlock::GoldfishAddressSpaceBlock()
+ : m_fd(-1)
+ , m_mmaped_ptr(NULL)
+ , m_phys_addr(0)
+ , m_host_addr(0)
+ , m_offset(0)
+ , m_size(0) {}
+
+GoldfishAddressSpaceBlock::~GoldfishAddressSpaceBlock()
+{
+ destroy();
+}
+
+GoldfishAddressSpaceBlock &GoldfishAddressSpaceBlock::operator=(const GoldfishAddressSpaceBlock &rhs)
+{
+ m_mmaped_ptr = rhs.m_mmaped_ptr;
+ m_phys_addr = rhs.m_phys_addr;
+ m_host_addr = rhs.m_host_addr;
+ m_offset = rhs.m_offset;
+ m_size = rhs.m_size;
+ m_fd = rhs.m_fd;
+
+ return *this;
+}
+
+bool GoldfishAddressSpaceBlock::allocate(GoldfishAddressSpaceBlockProvider *provider, size_t size)
+{
+ ALOGD("%s: Ask for block of size 0x%llx\n", __func__,
+ (unsigned long long)size);
+
+ destroy();
+
+ if (!provider->is_opened()) {
+ return false;
+ }
+
+ struct goldfish_address_space_allocate_block request;
+ ::memset(&request, 0, sizeof(request));
+ request.size = size;
+
+ long res = ioctl_allocate(provider->m_fd, &request);
+ if (res) {
+ return false;
+ } else {
+ m_phys_addr = request.phys_addr;
+ m_offset = request.offset;
+ m_size = request.size;
+ m_fd = provider->m_fd;
+
+ ALOGD("%s: ioctl allocate returned offset 0x%llx size 0x%llx\n", __func__,
+ (unsigned long long)m_offset,
+ (unsigned long long)m_size);
+
+ return true;
+ }
+}
+
+uint64_t GoldfishAddressSpaceBlock::physAddr() const
+{
+ return m_phys_addr;
+}
+
+uint64_t GoldfishAddressSpaceBlock::hostAddr() const
+{
+ return m_host_addr;
+}
+
+void *GoldfishAddressSpaceBlock::mmap(uint64_t host_addr)
+{
+ if (m_size == 0) {
+ ALOGE("%s: called with zero size\n", __func__);
+ return NULL;
+ }
+ if (m_mmaped_ptr) {
+ ALOGE("'mmap' called for an already mmaped address block");
+ ::abort();
+ }
+
+ void *result = ::mmap64(NULL, m_size, PROT_WRITE, MAP_SHARED, m_fd, m_offset);
+ if (result == MAP_FAILED) {
+ ALOGE("%s: host memory map failed with size 0x%llx "
+ "off 0x%llx errno %d\n",
+ __func__,
+ (unsigned long long)m_size,
+ (unsigned long long)m_offset, errno);
+ return NULL;
+ } else {
+ m_mmaped_ptr = result;
+ m_host_addr = host_addr;
+ return guestPtr();
+ }
+}
+
+void *GoldfishAddressSpaceBlock::guestPtr() const
+{
+ return reinterpret_cast<char *>(m_mmaped_ptr) + (m_host_addr & (PAGE_SIZE - 1));
+}
+
+void GoldfishAddressSpaceBlock::destroy()
+{
+ if (m_mmaped_ptr && m_size) {
+ ::munmap(m_mmaped_ptr, m_size);
+ m_mmaped_ptr = NULL;
+ }
+
+ if (m_size) {
+ const long res = ioctl_deallocate(m_fd, m_offset);
+ if (res) {
+ ALOGE("ioctl_deallocate failed, res=%ld", res);
+ ::abort();
+ }
+
+ m_phys_addr = 0;
+ m_host_addr = 0;
+ m_offset = 0;
+ m_size = 0;
+ }
+}
+
+GoldfishAddressSpaceHostMemoryAllocator::GoldfishAddressSpaceHostMemoryAllocator()
+{
+ if (m_provider.is_opened()) {
+ struct goldfish_address_space_ping request;
+ ::memset(&request, 0, sizeof(request));
+ request.metadata = DEVICE_TYPE_HOST_MEMORY_ALLOCATOR_ID;
+
+ const long ret = ioctl_ping(m_provider.m_fd, &request);
+ if (ret) {
+ ALOGE("%s: ioctl_ping failed for device_type=%llu, ret=%ld",
+ __func__, DEVICE_TYPE_HOST_MEMORY_ALLOCATOR_ID, ret);
+ m_provider.close();
+ }
+ }
+}
+
+long GoldfishAddressSpaceHostMemoryAllocator::hostMalloc(GoldfishAddressSpaceBlock *block, size_t size)
+{
+ if (size == 0) {
+ return -EINVAL;
+ }
+ if (block->size() > 0) {
+ return -EINVAL;
+ }
+ if (!m_provider.is_opened()) {
+ return -ENODEV;
+ }
+ if (!block->allocate(&m_provider, size)) {
+ return -ENOMEM;
+ }
+
+ struct goldfish_address_space_ping request;
+ ::memset(&request, 0, sizeof(request));
+ request.offset = block->offset();
+ request.size = block->size();
+ request.metadata = HOST_MEMORY_ALLOCATOR_COMMAND_ALLOCATE_ID;
+
+ long ret = ioctl_ping(m_provider.m_fd, &request);
+ if (ret) {
+ return ret;
+ }
+ ret = static_cast<long>(request.metadata);
+ if (ret) {
+ return ret;
+ }
+
+ block->mmap(0);
+ return 0;
+}
+
+void GoldfishAddressSpaceHostMemoryAllocator::hostFree(GoldfishAddressSpaceBlock *block)
+{
+ if (block->size() == 0) {
+ return;
+ }
+
+ if (!m_provider.is_opened()) {
+ ALOGE("%s: device is not available", __func__);
+ ::abort();
+ }
+
+ if (block->guestPtr()) {
+ struct goldfish_address_space_ping request;
+ ::memset(&request, 0, sizeof(request));
+ request.offset = block->offset();
+ request.metadata = HOST_MEMORY_ALLOCATOR_COMMAND_UNALLOCATE_ID;
+
+ const long ret = ioctl_ping(m_provider.m_fd, &request);
+ if (ret) {
+ ALOGE("%s: ioctl_ping failed, ret=%ld", __func__, ret);
+ ::abort();
+ }
+ }
+
+ block->replace(NULL);
+}
diff --git a/shared/OpenglCodecCommon/goldfish_address_space_fuchsia.impl b/shared/OpenglCodecCommon/goldfish_address_space_fuchsia.impl
new file mode 100644
index 0000000..6a10ca6
--- /dev/null
+++ b/shared/OpenglCodecCommon/goldfish_address_space_fuchsia.impl
@@ -0,0 +1,199 @@
+// Copyright (C) 2019 The Android Open Source Project
+// Copyright (C) 2019 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <memory>
+#include <fcntl.h>
+#include <lib/fdio/fdio.h>
+#include <lib/zx/channel.h>
+#include <lib/zx/vmo.h>
+#include <log/log.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <zircon/process.h>
+#include <zircon/syscalls.h>
+#include <zircon/syscalls/object.h>
+
+#include "goldfish_address_space.h"
+
+GoldfishAddressSpaceBlockProvider::GoldfishAddressSpaceBlockProvider() {
+ zx::channel channel;
+ zx_status_t status =
+ fdio_get_service_handle(::open(GOLDFISH_ADDRESS_SPACE_DEVICE_NAME, O_RDWR),
+ channel.reset_and_get_address());
+ if (status != ZX_OK) {
+ ALOGE("%s: failed to get service handle for " GOLDFISH_ADDRESS_SPACE_DEVICE_NAME ": %d",
+ __FUNCTION__, status);
+ return;
+ }
+ m_device.Bind(std::move(channel));
+}
+
+GoldfishAddressSpaceBlockProvider::~GoldfishAddressSpaceBlockProvider()
+{
+}
+
+bool GoldfishAddressSpaceBlockProvider::is_opened() const
+{
+ return m_device.is_bound();
+}
+
+// void GoldfishAddressSpaceBlockProvider::close() - not implemented
+
+GoldfishAddressSpaceBlock::GoldfishAddressSpaceBlock()
+ : m_device(NULL)
+ , m_vmo(ZX_HANDLE_INVALID)
+ , m_mmaped_ptr(NULL)
+ , m_phys_addr(0)
+ , m_host_addr(0)
+ , m_offset(0)
+ , m_size(0) {}
+
+GoldfishAddressSpaceBlock::~GoldfishAddressSpaceBlock()
+{
+ destroy();
+}
+
+GoldfishAddressSpaceBlock &GoldfishAddressSpaceBlock::operator=(const GoldfishAddressSpaceBlock &rhs)
+{
+ m_vmo = rhs.m_vmo;
+ m_mmaped_ptr = rhs.m_mmaped_ptr;
+ m_phys_addr = rhs.m_phys_addr;
+ m_host_addr = rhs.m_host_addr;
+ m_offset = rhs.m_offset;
+ m_size = rhs.m_size;
+ m_device = rhs.m_device;
+
+ return *this;
+}
+
+bool GoldfishAddressSpaceBlock::allocate(GoldfishAddressSpaceBlockProvider *provider, size_t size)
+{
+ ALOGD("%s: Ask for block of size 0x%llx\n", __func__,
+ (unsigned long long)size);
+
+ destroy();
+
+ if (!provider->is_opened()) {
+ return false;
+ }
+
+ fuchsia::hardware::goldfish::address::space::DeviceSyncPtr* device = &provider->m_device;
+
+ int32_t res = ZX_OK;
+ zx::vmo vmo;
+ zx_status_t status = (*device)->AllocateBlock(size, &res, &m_phys_addr, &vmo);
+ if (status != ZX_OK || res != ZX_OK) {
+ ALOGE("%s: allocate block failed: %d:%d", __func__, status, res);
+ return false;
+ }
+
+ m_offset = 0;
+ m_size = size;
+ m_vmo = vmo.release();
+
+ ALOGD("%s: allocate returned offset 0x%llx size 0x%llx\n", __func__,
+ (unsigned long long)m_offset,
+ (unsigned long long)m_size);
+
+ m_device = device;
+ return true;
+}
+
+uint64_t GoldfishAddressSpaceBlock::physAddr() const
+{
+ return m_phys_addr;
+}
+
+uint64_t GoldfishAddressSpaceBlock::hostAddr() const
+{
+ return m_host_addr;
+}
+
+void *GoldfishAddressSpaceBlock::mmap(uint64_t host_addr)
+{
+ if (m_size == 0) {
+ ALOGE("%s: called with zero size\n", __func__);
+ return NULL;
+ }
+ if (m_mmaped_ptr) {
+ ALOGE("'mmap' called for an already mmaped address block");
+ ::abort();
+ }
+
+ zx_vaddr_t ptr = 0;
+ zx_status_t status = zx_vmar_map(zx_vmar_root_self(),
+ ZX_VM_PERM_READ | ZX_VM_PERM_WRITE,
+ 0, m_vmo,
+ m_offset,
+ m_size,
+ &ptr);
+ if (status != ZX_OK) {
+ ALOGE("%s: host memory map failed with size 0x%llx "
+ "off 0x%llx status %d\n",
+ __func__,
+ (unsigned long long)m_size,
+ (unsigned long long)m_offset, status);
+ return NULL;
+ } else {
+ m_mmaped_ptr = (void*)ptr;
+ m_host_addr = host_addr;
+ return guestPtr();
+ }
+}
+
+void *GoldfishAddressSpaceBlock::guestPtr() const
+{
+ return reinterpret_cast<char *>(m_mmaped_ptr) + (m_host_addr & (PAGE_SIZE - 1));
+}
+
+void GoldfishAddressSpaceBlock::destroy()
+{
+ if (m_mmaped_ptr && m_size) {
+ zx_vmar_unmap(zx_vmar_root_self(),
+ (zx_vaddr_t)m_mmaped_ptr,
+ m_size);
+ m_mmaped_ptr = NULL;
+ }
+
+ if (m_size) {
+ zx_handle_close(m_vmo);
+ m_vmo = ZX_HANDLE_INVALID;
+ int32_t res = ZX_OK;
+ zx_status_t status = (*m_device)->DeallocateBlock(m_phys_addr, &res);
+ if (status != ZX_OK || res != ZX_OK) {
+ ALOGE("%s: deallocate block failed: %d:%d", __func__, status, res);
+ }
+ m_device = NULL;
+ m_phys_addr = 0;
+ m_host_addr = 0;
+ m_offset = 0;
+ m_size = 0;
+ }
+}
+
+GoldfishAddressSpaceHostMemoryAllocator::GoldfishAddressSpaceHostMemoryAllocator()
+{
+}
+
+long GoldfishAddressSpaceHostMemoryAllocator::hostMalloc(GoldfishAddressSpaceBlock *block, size_t size)
+{
+ return 0;
+}
+
+void GoldfishAddressSpaceHostMemoryAllocator::hostFree(GoldfishAddressSpaceBlock *block)
+{
+}
diff --git a/shared/OpenglCodecCommon/goldfish_address_space_host.impl b/shared/OpenglCodecCommon/goldfish_address_space_host.impl
new file mode 100644
index 0000000..1c7b4e2
--- /dev/null
+++ b/shared/OpenglCodecCommon/goldfish_address_space_host.impl
@@ -0,0 +1,213 @@
+// Copyright (C) 2019 The Android Open Source Project
+// Copyright (C) 2019 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <memory>
+#include "android/emulation/hostdevices/HostAddressSpace.h"
+
+#if PLATFORM_SDK_VERSION < 26
+#include <cutils/log.h>
+#else
+#include <log/log.h>
+#endif
+
+#include "goldfish_address_space.h"
+
+namespace {
+
+const int DEVICE_TYPE_HOST_MEMORY_ALLOCATOR_ID = 5;
+const int HOST_MEMORY_ALLOCATOR_COMMAND_ALLOCATE_ID = 1;
+const int HOST_MEMORY_ALLOCATOR_COMMAND_UNALLOCATE_ID = 2;
+
+} // namsepace
+
+using android::HostAddressSpaceDevice;
+using android::emulation::AddressSpaceDevicePingInfo;
+
+GoldfishAddressSpaceBlockProvider::GoldfishAddressSpaceBlockProvider()
+ : m_handle(HostAddressSpaceDevice::get()->open()) {}
+
+GoldfishAddressSpaceBlockProvider::~GoldfishAddressSpaceBlockProvider()
+{
+ HostAddressSpaceDevice::get()->close(m_handle);
+}
+
+bool GoldfishAddressSpaceBlockProvider::is_opened() const
+{
+ return m_handle > 0;
+}
+
+void GoldfishAddressSpaceBlockProvider::close()
+{
+ if (is_opened()) {
+ HostAddressSpaceDevice::get()->close(m_handle);
+ m_handle = 0;
+ }
+}
+
+GoldfishAddressSpaceBlock::GoldfishAddressSpaceBlock()
+ : m_handle(0)
+ , m_mmaped_ptr(NULL)
+ , m_phys_addr(0)
+ , m_host_addr(0)
+ , m_offset(0)
+ , m_size(0) {}
+
+GoldfishAddressSpaceBlock::~GoldfishAddressSpaceBlock()
+{
+ destroy();
+}
+
+GoldfishAddressSpaceBlock &GoldfishAddressSpaceBlock::operator=(const GoldfishAddressSpaceBlock &rhs)
+{
+ m_mmaped_ptr = rhs.m_mmaped_ptr;
+ m_phys_addr = rhs.m_phys_addr;
+ m_host_addr = rhs.m_host_addr;
+ m_offset = rhs.m_offset;
+ m_size = rhs.m_size;
+ m_handle = rhs.m_handle;
+ return *this;
+}
+
+bool GoldfishAddressSpaceBlock::allocate(GoldfishAddressSpaceBlockProvider *provider, size_t size)
+{
+ ALOGD("%s: Ask for block of size 0x%llx\n", __func__,
+ (unsigned long long)size);
+
+ destroy();
+
+ if (!provider->is_opened()) {
+ return false;
+ }
+
+ m_size = size;
+ m_offset =
+ HostAddressSpaceDevice::get()->allocBlock(
+ provider->m_handle, size, &m_phys_addr);
+ m_handle = provider->m_handle;
+
+ return true;
+}
+
+uint64_t GoldfishAddressSpaceBlock::physAddr() const
+{
+ return m_phys_addr;
+}
+
+uint64_t GoldfishAddressSpaceBlock::hostAddr() const
+{
+ return m_host_addr;
+}
+
+void *GoldfishAddressSpaceBlock::mmap(uint64_t host_addr)
+{
+ if (m_size == 0) {
+ ALOGE("%s: called with zero size\n", __func__);
+ return NULL;
+ }
+
+ if (m_mmaped_ptr != nullptr) {
+ ALOGE("'mmap' called for an already mmaped address block 0x%llx %d", (unsigned long long)m_mmaped_ptr, nullptr == m_mmaped_ptr);
+ ::abort();
+ }
+
+ m_mmaped_ptr = (void*)(uintptr_t)(host_addr & (~(PAGE_SIZE - 1)));
+ m_host_addr = host_addr;
+
+ return guestPtr();
+}
+
+void *GoldfishAddressSpaceBlock::guestPtr() const
+{
+ return reinterpret_cast<char *>(m_mmaped_ptr) + (m_host_addr & (PAGE_SIZE - 1));
+}
+
+void GoldfishAddressSpaceBlock::destroy()
+{
+ if (m_mmaped_ptr && m_size) {
+ m_mmaped_ptr = NULL;
+ }
+
+ if (m_size) {
+ HostAddressSpaceDevice::get()->freeBlock(m_handle, m_offset);
+ m_phys_addr = 0;
+ m_host_addr = 0;
+ m_offset = 0;
+ m_size = 0;
+ }
+}
+
+GoldfishAddressSpaceHostMemoryAllocator::GoldfishAddressSpaceHostMemoryAllocator()
+{
+ if (m_provider.is_opened()) {
+ AddressSpaceDevicePingInfo request;
+ ::memset(&request, 0, sizeof(request));
+ request.metadata = DEVICE_TYPE_HOST_MEMORY_ALLOCATOR_ID;
+
+ HostAddressSpaceDevice::get()->ping(m_provider.m_handle, &request);
+ }
+}
+
+long GoldfishAddressSpaceHostMemoryAllocator::hostMalloc(GoldfishAddressSpaceBlock *block, size_t size)
+{
+ if (size == 0) {
+ return -EINVAL;
+ }
+ if (block->size() > 0) {
+ return -EINVAL;
+ }
+ if (!m_provider.is_opened()) {
+ return -ENODEV;
+ }
+ if (!block->allocate(&m_provider, size)) {
+ return -ENOMEM;
+ }
+
+ AddressSpaceDevicePingInfo request;
+ ::memset(&request, 0, sizeof(request));
+ request.phys_addr = block->physAddr();
+ request.size = block->size();
+ request.metadata = HOST_MEMORY_ALLOCATOR_COMMAND_ALLOCATE_ID;
+
+ HostAddressSpaceDevice::get()->ping(m_provider.m_handle, &request);
+
+ void *hostPtr = HostAddressSpaceDevice::get()->getHostAddr(block->physAddr());
+ block->mmap(static_cast<uint64_t>(reinterpret_cast<uintptr_t>(hostPtr)));
+
+ return 0;
+}
+
+void GoldfishAddressSpaceHostMemoryAllocator::hostFree(GoldfishAddressSpaceBlock *block)
+{
+ if (block->size() == 0) {
+ return;
+ }
+
+ if (!m_provider.is_opened()) {
+ ALOGE("%s: device is not available", __func__);
+ ::abort();
+ }
+
+ if (block->guestPtr()) {
+ AddressSpaceDevicePingInfo request;
+ ::memset(&request, 0, sizeof(request));
+ request.phys_addr = block->physAddr();
+ request.metadata = HOST_MEMORY_ALLOCATOR_COMMAND_UNALLOCATE_ID;
+
+ HostAddressSpaceDevice::get()->ping(m_provider.m_handle, &request);
+ }
+
+ block->replace(NULL);
+}
+
diff --git a/shared/OpenglCodecCommon/qemu_pipe.h b/shared/OpenglCodecCommon/qemu_pipe.h
index 429b3fe..82c4a94 100644
--- a/shared/OpenglCodecCommon/qemu_pipe.h
+++ b/shared/OpenglCodecCommon/qemu_pipe.h
@@ -41,6 +41,16 @@
#define QEMU_PIPE_INVALID_HANDLE (-1)
+#ifndef QEMU_PIPE_RETRY
+#define QEMU_PIPE_RETRY(exp) ({ \
+ __typeof__(exp) _rc; \
+ do { \
+ _rc = (exp); \
+ } while (_rc == -1 && (errno == EINTR || errno == EAGAIN)); \
+ _rc; }) \
+
+#endif
+
#ifndef QEMU_PIPE_PATH
#define QEMU_PIPE_PATH "/dev/qemu_pipe"
#endif
@@ -80,7 +90,7 @@
const uint8_t* p = (const uint8_t*)(data);
size_t remaining = byte_count;
while (remaining > 0) {
- ssize_t n = TEMP_FAILURE_RETRY(write(fd, p, remaining));
+ ssize_t n = QEMU_PIPE_RETRY(write(fd, p, remaining));
if (n == -1) return false;
p += n;
remaining -= n;
@@ -123,9 +133,10 @@
snprintf(buff, sizeof buff, "pipe:%s", pipeName);
- fd = TEMP_FAILURE_RETRY(open(QEMU_PIPE_PATH, O_RDWR));
- if (fd < 0 && errno == ENOENT)
- fd = TEMP_FAILURE_RETRY(open("/dev/goldfish_pipe", O_RDWR));
+ fd = QEMU_PIPE_RETRY(open(QEMU_PIPE_PATH, O_RDWR | O_NONBLOCK));
+ if (fd < 0 && errno == ENOENT) {
+ fd = QEMU_PIPE_RETRY(open("/dev/goldfish_pipe", O_RDWR | O_NONBLOCK));
+ }
if (fd < 0) {
D("%s: Could not open " QEMU_PIPE_PATH ": %s", __FUNCTION__, strerror(errno));
//errno = ENOSYS;
@@ -159,7 +170,7 @@
static __inline__ bool
qemu_pipe_try_again() {
- return errno == EINTR;
+ return errno == EINTR || errno == EAGAIN;
}
static __inline__ bool
diff --git a/system/GLESv2_enc/GL2Encoder.cpp b/system/GLESv2_enc/GL2Encoder.cpp
index 44264d9..573c3df 100755
--- a/system/GLESv2_enc/GL2Encoder.cpp
+++ b/system/GLESv2_enc/GL2Encoder.cpp
@@ -4503,9 +4503,9 @@
GL2Encoder *ctx = (GL2Encoder *)self;
GLClientState* state = ctx->m_state;
- bool validateColor = mask | GL_COLOR_BUFFER_BIT;
- bool validateDepth = mask | GL_DEPTH_BUFFER_BIT;
- bool validateStencil = mask | GL_STENCIL_BUFFER_BIT;
+ bool validateColor = mask & GL_COLOR_BUFFER_BIT;
+ bool validateDepth = mask & GL_DEPTH_BUFFER_BIT;
+ bool validateStencil = mask & GL_STENCIL_BUFFER_BIT;
FboFormatInfo read_fbo_format_info;
FboFormatInfo draw_fbo_format_info;
diff --git a/system/GLESv2_enc/GLESv2Validation.cpp b/system/GLESv2_enc/GLESv2Validation.cpp
index 098091f..9f72853 100644
--- a/system/GLESv2_enc/GLESv2Validation.cpp
+++ b/system/GLESv2_enc/GLESv2Validation.cpp
@@ -731,6 +731,7 @@
return false;
}
#define LIST_VALID_TEX_INTERNALFORMATS(f) \
+ f(GL_BGRA8_EXT) \
f(GL_R8) \
f(GL_R8_SNORM) \
f(GL_R16F) \
diff --git a/system/OpenglSystemCommon/EmulatorFeatureInfo.h b/system/OpenglSystemCommon/EmulatorFeatureInfo.h
index 518273a..95b3e60 100644
--- a/system/OpenglSystemCommon/EmulatorFeatureInfo.h
+++ b/system/OpenglSystemCommon/EmulatorFeatureInfo.h
@@ -79,6 +79,18 @@
// Deferred Vulkan commands
static const char kDeferredVulkanCommands[] = "ANDROID_EMU_deferred_vulkan_commands";
+// Vulkan null optional strings
+static const char kVulkanNullOptionalStrings[] = "ANDROID_EMU_vulkan_null_optional_strings";
+
+// Vulkan create resources with requirements
+static const char kVulkanCreateResourcesWithRequirements[] = "ANDROID_EMU_vulkan_create_resources_with_requirements";
+
+// YUV420_888 to NV21
+static const char kYUV420888toNV21[] = "ANDROID_EMU_YUV420_888_to_NV21";
+
+// YUV host cache
+static const char kYUVCache[] = "ANDROID_EMU_YUV_Cache";
+
// Struct describing available emulator features
struct EmulatorFeatureInfo {
@@ -89,7 +101,11 @@
glesMaxVersion(GLES_MAX_VERSION_2),
hasDirectMem(false),
hasVulkan(false),
- hasDeferredVulkanCommands(false) { }
+ hasDeferredVulkanCommands(false),
+ hasVulkanNullOptionalStrings(false),
+ hasVulkanCreateResourcesWithRequirements(false),
+ hasYUV420888toNV21(false),
+ hasYUVCache (false) { }
SyncImpl syncImpl;
DmaImpl dmaImpl;
@@ -98,6 +114,10 @@
bool hasDirectMem;
bool hasVulkan;
bool hasDeferredVulkanCommands;
+ bool hasVulkanNullOptionalStrings;
+ bool hasVulkanCreateResourcesWithRequirements;
+ bool hasYUV420888toNV21;
+ bool hasYUVCache;
};
#endif // __COMMON_EMULATOR_FEATURE_INFO_H
diff --git a/system/OpenglSystemCommon/FormatConversions.cpp b/system/OpenglSystemCommon/FormatConversions.cpp
index 53f0e83..4b5c31c 100644
--- a/system/OpenglSystemCommon/FormatConversions.cpp
+++ b/system/OpenglSystemCommon/FormatConversions.cpp
@@ -20,6 +20,7 @@
#include <log/log.h>
#endif
#include <string.h>
+#include <stdio.h>
#define DEBUG 0
@@ -54,9 +55,9 @@
uint32_t* totalSz_out) {
uint32_t align = 1;
uint32_t yStride = (width + (align - 1)) & ~(align-1);
- uint32_t uvStride = (yStride / 2 + (align - 1)) & ~(align-1);
+ uint32_t uvStride = yStride;
uint32_t uvHeight = height / 2;
- uint32_t sz = yStride * height + 2 * (uvHeight * uvStride);
+ uint32_t sz = yStride * height + uvHeight * uvStride;
if (yStride_out) *yStride_out = yStride;
if (cStride_out) *cStride_out = uvStride;
@@ -90,7 +91,7 @@
uint8_t *yv12_y = yv12_y0 + j * yStride;
uint8_t *yv12_v = yv12_v0 + (j/2) * cStride;
uint8_t *yv12_u = yv12_v + cSize;
- uint16_t *rgb_ptr = rgb_ptr0 + get_rgb_offset(j, width, rgb_stride);
+ uint16_t *rgb_ptr = rgb_ptr0 + get_rgb_offset(j, width, rgb_stride) / 2;
bool jeven = (j & 1) == 0;
for (int i = left; i <= right; ++i) {
uint8_t r = ((rgb_ptr[i]) >> 11) & 0x01f;
@@ -127,12 +128,26 @@
uint8_t *rgb_ptr0 = (uint8_t *)src;
uint8_t *yv12_y0 = (uint8_t *)dest;
+ uint8_t *yv12_u0 = yv12_y0 + yStride * height + cSize;
uint8_t *yv12_v0 = yv12_y0 + yStride * height;
+#if DEBUG
+ char mybuf[1024];
+ snprintf(mybuf, sizeof(mybuf), "/sdcard/raw_%d_%d_rgb.ppm", width, height);
+ FILE *myfp = fopen(mybuf, "wb"); /* b - binary mode */
+ (void) fprintf(myfp, "P6\n%d %d\n255\n", width, height);
+
+ if (myfp == NULL) {
+ DD("failed to open /sdcard/raw_rgb888.ppm");
+ } else {
+ fwrite(rgb_ptr0, width * height * rgb_stride, 1, myfp);
+ fclose(myfp);
+ }
+#endif
+
+ int uvcount = 0;
for (int j = top; j <= bottom; ++j) {
uint8_t *yv12_y = yv12_y0 + j * yStride;
- uint8_t *yv12_v = yv12_v0 + (j/2) * cStride;
- uint8_t *yv12_u = yv12_v + cSize;
uint8_t *rgb_ptr = rgb_ptr0 + get_rgb_offset(j, width, rgb_stride);
bool jeven = (j & 1) == 0;
for (int i = left; i <= right; ++i) {
@@ -140,15 +155,32 @@
uint8_t G = rgb_ptr[i*rgb_stride+1];
uint8_t B = rgb_ptr[i*rgb_stride+2];
// convert to YV12
- // frameworks/base/core/jni/android_hardware_camera2_legacy_LegacyCameraDevice.cpp
- yv12_y[i] = clamp_rgb((77 * R + 150 * G + 29 * B) >> 8);
+ // https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion
+ // but scale up U by 1/0.96
+ yv12_y[i] = clamp_rgb(1.0 * ((0.25678823529411765 * R) + (0.5041294117647058 * G) + (0.09790588235294118 * B)) + 16);
bool ieven = (i & 1) == 0;
if (jeven && ieven) {
- yv12_u[i] = clamp_rgb((( -43 * R - 85 * G + 128 * B) >> 8) + 128);
- yv12_v[i] = clamp_rgb((( 128 * R - 107 * G - 21 * B) >> 8) + 128);
+ yv12_u0[uvcount] = clamp_rgb((1/0.96) * (-(0.1482235294117647 * R) - (0.2909921568627451 * G) + (0.4392156862745098 * B)) + 128);
+ yv12_v0[uvcount] = clamp_rgb((1.0)* ((0.4392156862745098 * R) - (0.36778823529411764 * G) - (0.07142745098039215 * B)) + 128);
+ uvcount ++;
}
}
+ if (jeven) {
+ yv12_u0 += cStride;
+ yv12_v0 += cStride;
+ uvcount = 0;
+ }
}
+
+#if DEBUG
+ snprintf(mybuf, sizeof(mybuf), "/sdcard/raw_%d_%d_yv12.yuv", width, height);
+ FILE *yuvfp = fopen(mybuf, "wb"); /* b - binary mode */
+ if (yuvfp != NULL) {
+ fwrite(yv12_y0, yStride * height + 2 * cSize, 1, yuvfp);
+ fclose(yuvfp);
+ }
+#endif
+
}
void rgb888_to_yuv420p(char* dest, char* src, int width, int height,
@@ -186,6 +218,44 @@
}
}
}
+
+//HAL_PIXEL_FORMAT_YCbCr_420_888, or yuv420p is treated as NV21 across our
+//gralloc and camera module when feature YUV420888toNV21 enabled
+void rgb888_to_nv21(char* dest, char* src, int width, int height,
+ int left, int top, int right, int bottom) {
+ const int rgb_stride = 3;
+
+ DD("%s convert %d by %d", __func__, width, height);
+ int yStride = width;
+ int cStride = yStride;
+ int yOffset = 0;
+
+ uint8_t *rgb_ptr0 = (uint8_t *)src;
+ uint8_t *nv21_y0 = (uint8_t *)dest;
+ uint8_t *nv21_v0 = nv21_y0 + yStride * height;
+
+ for (int j = top; j <= bottom; ++j) {
+ uint8_t *nv21_y = nv21_y0 + j * yStride;
+ uint8_t *nv21_v = nv21_v0 + (j/2) * cStride;
+ uint8_t *nv21_u = nv21_v + 1;
+ uint8_t *rgb_ptr = rgb_ptr0 + get_rgb_offset(j, width, rgb_stride);
+ bool jeven = (j & 1) == 0;
+ for (int i = left; i <= right; ++i) {
+ uint8_t R = rgb_ptr[i*rgb_stride];
+ uint8_t G = rgb_ptr[i*rgb_stride+1];
+ uint8_t B = rgb_ptr[i*rgb_stride+2];
+ // convert to YV12
+ // frameworks/base/core/jni/android_hardware_camera2_legacy_LegacyCameraDevice.cpp
+ nv21_y[i] = clamp_rgb((77 * R + 150 * G + 29 * B) >> 8);
+ bool ieven = (i & 1) == 0;
+ if (jeven && ieven) {
+ nv21_u[i] = clamp_rgb((( -43 * R - 85 * G + 128 * B) >> 8) + 128);
+ nv21_v[i] = clamp_rgb((( 128 * R - 107 * G - 21 * B) >> 8) + 128);
+ }
+ }
+ }
+}
+
// YV12 is aka YUV420Planar, or YUV420p; the only difference is that YV12 has
// certain stride requirements for Y and UV respectively.
void yv12_to_rgb565(char* dest, char* src, int width, int height,
@@ -256,20 +326,15 @@
uint8_t *rgb_ptr = rgb_ptr0 + get_rgb_offset(j - top, right - left + 1, rgb_stride);
for (int i = left; i <= right; ++i) {
// convert to rgb
- // frameworks/av/media/libstagefright/colorconversion/ColorConverter.cpp
+ // https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion
+ // but scale down U by 0.96 to mitigate rgb over/under flow
signed y1 = (signed)yv12_y[i] - 16;
signed u = (signed)yv12_u[i / 2] - 128;
signed v = (signed)yv12_v[i / 2] - 128;
- signed u_b = u * 517;
- signed u_g = -u * 100;
- signed v_g = -v * 208;
- signed v_r = v * 409;
-
- signed tmp1 = y1 * 298;
- signed b1 = clamp_rgb((tmp1 + u_b) / 256);
- signed g1 = clamp_rgb((tmp1 + v_g + u_g) / 256);
- signed r1 = clamp_rgb((tmp1 + v_r) / 256);
+ signed r1 = clamp_rgb(1 * (1.1643835616438356 * y1 + 1.5960267857142856 * v));
+ signed g1 = clamp_rgb(1 * (1.1643835616438356 * y1 - 0.39176229009491365 * u * 0.97 - 0.8129676472377708 * v));
+ signed b1 = clamp_rgb(1 * (1.1643835616438356 * y1 + 2.017232142857143 * u * 0.97));
rgb_ptr[(i-left)*rgb_stride] = r1;
rgb_ptr[(i-left)*rgb_stride+1] = g1;
@@ -278,8 +343,6 @@
}
}
-// YV12 is aka YUV420Planar, or YUV420p; the only difference is that YV12 has
-// certain stride requirements for Y and UV respectively.
void yuv420p_to_rgb888(char* dest, char* src, int width, int height,
int left, int top, int right, int bottom) {
const int rgb_stride = 3;
@@ -323,6 +386,50 @@
}
}
+//HAL_PIXEL_FORMAT_YCbCr_420_888, or yuv420p is treated as NV21 across our
+//gralloc and camera module when feature YUV420888toNV21 enabled
+void nv21_to_rgb888(char* dest, char* src, int width, int height,
+ int left, int top, int right, int bottom) {
+ const int rgb_stride = 3;
+
+ DD("%s convert %d by %d", __func__, width, height);
+ int yStride = width;
+ int cStride = yStride;
+ int yOffset = 0;
+
+ uint8_t *rgb_ptr0 = (uint8_t *)dest;
+ uint8_t *nv21_y0 = (uint8_t *)src;
+ uint8_t *nv21_v0 = nv21_y0 + yStride * height;
+
+ for (int j = top; j <= bottom; ++j) {
+ uint8_t *nv21_y = nv21_y0 + j * yStride;
+ uint8_t *nv21_v = nv21_v0 + (j/2) * cStride;
+ uint8_t *nv21_u = nv21_v + 1;
+ uint8_t *rgb_ptr = rgb_ptr0 + get_rgb_offset(j - top, right - left + 1, rgb_stride);
+ for (int i = left; i <= right; ++i) {
+ // convert to rgb
+ // frameworks/av/media/libstagefright/colorconversion/ColorConverter.cpp
+ signed y1 = (signed)nv21_y[i] - 16;
+ signed u = (signed)nv21_u[i / 2] - 128;
+ signed v = (signed)nv21_v[i / 2] - 128;
+
+ signed u_b = u * 517;
+ signed u_g = -u * 100;
+ signed v_g = -v * 208;
+ signed v_r = v * 409;
+
+ signed tmp1 = y1 * 298;
+ signed b1 = clamp_rgb((tmp1 + u_b) / 256);
+ signed g1 = clamp_rgb((tmp1 + v_g + u_g) / 256);
+ signed r1 = clamp_rgb((tmp1 + v_r) / 256);
+
+ rgb_ptr[(i-left)*rgb_stride] = r1;
+ rgb_ptr[(i-left)*rgb_stride+1] = g1;
+ rgb_ptr[(i-left)*rgb_stride+2] = b1;
+ }
+ }
+}
+
void copy_rgb_buffer_from_unlocked(
char* _dst, char* raw_data,
int unlockedWidth,
diff --git a/system/OpenglSystemCommon/FormatConversions.h b/system/OpenglSystemCommon/FormatConversions.h
index 6e15f36..196ca37 100644
--- a/system/OpenglSystemCommon/FormatConversions.h
+++ b/system/OpenglSystemCommon/FormatConversions.h
@@ -33,12 +33,16 @@
int left, int top, int right, int bottom);
void rgb888_to_yuv420p(char* dest, char* src, int width, int height,
int left, int top, int right, int bottom);
+void rgb888_to_nv21(char* dest, char* src, int width, int height,
+ int left, int top, int right, int bottom);
void yv12_to_rgb565(char* dest, char* src, int width, int height,
int left, int top, int right, int bottom);
void yv12_to_rgb888(char* dest, char* src, int width, int height,
int left, int top, int right, int bottom);
void yuv420p_to_rgb888(char* dest, char* src, int width, int height,
int left, int top, int right, int bottom);
+void nv21_to_rgb888(char* dest, char* src, int width, int height,
+ int left, int top, int right, int bottom);
void copy_rgb_buffer_from_unlocked(char* _dst, char* raw_data,
int unlockedWidth,
int width, int height, int top, int left,
diff --git a/system/OpenglSystemCommon/HostConnection.cpp b/system/OpenglSystemCommon/HostConnection.cpp
index b6d465c..5e81ead 100644
--- a/system/OpenglSystemCommon/HostConnection.cpp
+++ b/system/OpenglSystemCommon/HostConnection.cpp
@@ -292,6 +292,11 @@
queryAndSetHostCompositionImpl(m_rcEnc);
queryAndSetDirectMemSupport(m_rcEnc);
queryAndSetVulkanSupport(m_rcEnc);
+ queryAndSetDeferredVulkanCommandsSupport(m_rcEnc);
+ queryAndSetVulkanNullOptionalStringsSupport(m_rcEnc);
+ queryAndSetVulkanCreateResourcesWithRequirementsSupport(m_rcEnc);
+ queryAndSetYUV420888toNV21(m_rcEnc);
+ queryAndSetYUVCache(m_rcEnc);
if (m_processPipe) {
m_processPipe->processPipeInit(m_rcEnc);
}
@@ -447,3 +452,31 @@
rcEnc->featureInfo()->hasDeferredVulkanCommands = true;
}
}
+
+void HostConnection::queryAndSetVulkanNullOptionalStringsSupport(ExtendedRCEncoderContext* rcEnc) {
+ std::string glExtensions = queryGLExtensions(rcEnc);
+ if (glExtensions.find(kVulkanNullOptionalStrings) != std::string::npos) {
+ rcEnc->featureInfo()->hasVulkanNullOptionalStrings = true;
+ }
+}
+
+void HostConnection::queryAndSetVulkanCreateResourcesWithRequirementsSupport(ExtendedRCEncoderContext* rcEnc) {
+ std::string glExtensions = queryGLExtensions(rcEnc);
+ if (glExtensions.find(kVulkanCreateResourcesWithRequirements) != std::string::npos) {
+ rcEnc->featureInfo()->hasVulkanCreateResourcesWithRequirements = true;
+ }
+}
+
+void HostConnection::queryAndSetYUV420888toNV21(ExtendedRCEncoderContext* rcEnc) {
+ std::string glExtensions = queryGLExtensions(rcEnc);
+ if (glExtensions.find(kYUV420888toNV21) != std::string::npos) {
+ rcEnc->featureInfo()->hasYUV420888toNV21 = true;
+ }
+}
+
+void HostConnection::queryAndSetYUVCache(ExtendedRCEncoderContext* rcEnc) {
+ std::string glExtensions = queryGLExtensions(rcEnc);
+ if (glExtensions.find(kYUVCache) != std::string::npos) {
+ rcEnc->featureInfo()->hasYUVCache = true;
+ }
+}
diff --git a/system/OpenglSystemCommon/HostConnection.h b/system/OpenglSystemCommon/HostConnection.h
index 922c35c..22b36b0 100644
--- a/system/OpenglSystemCommon/HostConnection.h
+++ b/system/OpenglSystemCommon/HostConnection.h
@@ -21,6 +21,7 @@
#include "renderControl_enc.h"
#include "ChecksumCalculator.h"
#include "goldfish_dma.h"
+#include "goldfish_address_space.h"
#include <cutils/native_handle.h>
@@ -47,7 +48,7 @@
public:
ExtendedRCEncoderContext(IOStream *stream, ChecksumCalculator *checksumCalculator)
: renderControl_encoder_context_t(stream, checksumCalculator),
- m_dmaCxt(NULL) { }
+ m_dmaCxt(NULL), m_addressSpaceBlock(NULL) { }
void setSyncImpl(SyncImpl syncImpl) { m_featureInfo.syncImpl = syncImpl; }
void setDmaImpl(DmaImpl dmaImpl) { m_featureInfo.dmaImpl = dmaImpl; }
void setHostComposition(HostComposition hostComposition) {
@@ -56,11 +57,20 @@
bool hasNativeSyncV3() const { return m_featureInfo.syncImpl >= SYNC_IMPL_NATIVE_SYNC_V3; }
bool hasHostCompositionV1() const {
return m_featureInfo.hostComposition == HOST_COMPOSITION_V1; }
+ bool hasYUV420toNV21() const {
+ return m_featureInfo.hasYUV420888toNV21; }
+ bool hasYUVCache() const {
+ return m_featureInfo.hasYUVCache; }
DmaImpl getDmaVersion() const { return m_featureInfo.dmaImpl; }
void bindDmaContext(struct goldfish_dma_context* cxt) { m_dmaCxt = cxt; }
+ void bindAddressSpaceBlock(GoldfishAddressSpaceBlock* block) {
+ m_addressSpaceBlock = block;
+ }
virtual uint64_t lockAndWriteDma(void* data, uint32_t size) {
- if (m_dmaCxt) {
- return lockAndWriteGoldfishDma(data, size, m_dmaCxt);
+ if (m_addressSpaceBlock) {
+ return writeAddressSpaceBlock(data, size, m_addressSpaceBlock);
+ } else if (m_dmaCxt) {
+ return writeGoldfishDma(data, size, m_dmaCxt);
} else {
ALOGE("%s: ERROR: No DMA context bound!", __func__);
return 0;
@@ -68,12 +78,20 @@
}
void setGLESMaxVersion(GLESMaxVersion ver) { m_featureInfo.glesMaxVersion = ver; }
GLESMaxVersion getGLESMaxVersion() const { return m_featureInfo.glesMaxVersion; }
+ bool hasDirectMem() const {
+#ifdef HOST_BUILD
+ // unit tests do not support restoring "guest" ram because there is no VM
+ return false;
+#else
+ return m_featureInfo.hasDirectMem;
+#endif
+ }
const EmulatorFeatureInfo* featureInfo_const() const { return &m_featureInfo; }
EmulatorFeatureInfo* featureInfo() { return &m_featureInfo; }
private:
- static uint64_t lockAndWriteGoldfishDma(void* data, uint32_t size,
- struct goldfish_dma_context* dmaCxt) {
+ static uint64_t writeGoldfishDma(void* data, uint32_t size,
+ struct goldfish_dma_context* dmaCxt) {
ALOGV("%s(data=%p, size=%u): call", __func__, data, size);
goldfish_dma_write(dmaCxt, data, size);
@@ -83,8 +101,20 @@
return paddr;
}
+ static uint64_t writeAddressSpaceBlock(void* data, uint32_t size,
+ GoldfishAddressSpaceBlock* block) {
+ ALOGV("%s(data=%p, size=%u): call", __func__, data, size);
+
+ memcpy(block->guestPtr(), data, size);
+ const uint64_t paddr = block->physAddr();
+
+ ALOGV("%s: paddr=0x%llx", __func__, (unsigned long long)paddr);
+ return paddr;
+ }
+
EmulatorFeatureInfo m_featureInfo;
struct goldfish_dma_context* m_dmaCxt;
+ GoldfishAddressSpaceBlock* m_addressSpaceBlock;
};
// Abstraction for gralloc handle conversion
@@ -166,6 +196,10 @@
void queryAndSetDirectMemSupport(ExtendedRCEncoderContext *rcEnc);
void queryAndSetVulkanSupport(ExtendedRCEncoderContext *rcEnc);
void queryAndSetDeferredVulkanCommandsSupport(ExtendedRCEncoderContext *rcEnc);
+ void queryAndSetVulkanNullOptionalStringsSupport(ExtendedRCEncoderContext *rcEnc);
+ void queryAndSetVulkanCreateResourcesWithRequirementsSupport(ExtendedRCEncoderContext *rcEnc);
+ void queryAndSetYUV420888toNV21(ExtendedRCEncoderContext *mrcEnc);
+ void queryAndSetYUVCache(ExtendedRCEncoderContext *mrcEnc);
private:
IOStream *m_stream;
diff --git a/system/OpenglSystemCommon/ProcessPipe.cpp b/system/OpenglSystemCommon/ProcessPipe.cpp
index 5fe9fa3..e04d153 100644
--- a/system/OpenglSystemCommon/ProcessPipe.cpp
+++ b/system/OpenglSystemCommon/ProcessPipe.cpp
@@ -29,6 +29,7 @@
#include <fuchsia/hardware/goldfish/pipe/cpp/fidl.h>
#include <lib/fdio/fdio.h>
#include <lib/zx/vmo.h>
+static QEMU_PIPE_HANDLE sProcDevice = 0;
#endif
static QEMU_PIPE_HANDLE sProcPipe = 0;
@@ -66,9 +67,12 @@
fuchsia::hardware::goldfish::pipe::DeviceSyncPtr device;
device.Bind(std::move(channel));
+ fuchsia::hardware::goldfish::pipe::PipeSyncPtr pipe;
+ device->OpenPipe(pipe.NewRequest());
+
zx_status_t status2 = ZX_OK;
zx::vmo vmo;
- status = device->GetBuffer(&status2, &vmo);
+ status = pipe->GetBuffer(&status2, &vmo);
if (status != ZX_OK || status2 != ZX_OK) {
ALOGE("%s: failed to get buffer: %d:%d", __FUNCTION__, status, status2);
return;
@@ -81,31 +85,23 @@
return;
}
uint64_t actual;
- status = device->Write(len + 1, 0, &status2, &actual);
+ status = pipe->Write(len + 1, 0, &status2, &actual);
if (status != ZX_OK || status2 != ZX_OK) {
ALOGD("%s: connecting to pipe service failed: %d:%d", __FUNCTION__,
status, status2);
return;
}
- // Send a confirmation int to the host
+ // Send a confirmation int to the host and get per-process unique ID back
int32_t confirmInt = 100;
status = vmo.write(&confirmInt, 0, sizeof(confirmInt));
if (status != ZX_OK) {
ALOGE("%s: failed write confirm int", __FUNCTION__);
return;
}
- status = device->Write(sizeof(confirmInt), 0, &status2, &actual);
+ status = pipe->Call(sizeof(confirmInt), 0, sizeof(sProcUID), 0, &status2, &actual);
if (status != ZX_OK || status2 != ZX_OK) {
- ALOGD("%s: failed to send confirm value: %d:%d", __FUNCTION__,
- status, status2);
- return;
- }
-
- // Ask the host for per-process unique ID
- status = device->Read(sizeof(sProcUID), 0, &status2, &actual);
- if (status != ZX_OK || status2 != ZX_OK) {
- ALOGD("%s: failed to recv per-process ID: %d:%d", __FUNCTION__,
+ ALOGD("%s: failed to get per-process ID: %d:%d", __FUNCTION__,
status, status2);
return;
}
@@ -114,7 +110,8 @@
ALOGE("%s: failed read per-process ID: %d", __FUNCTION__, status);
return;
}
- sProcPipe = device.Unbind().TakeChannel().release();
+ sProcDevice = device.Unbind().TakeChannel().release();
+ sProcPipe = pipe.Unbind().TakeChannel().release();
}
#else
static void processPipeInitOnce() {
@@ -145,7 +142,7 @@
stat =
qemu_pipe_read(sProcPipe, (char*)&sProcUID,
sizeof(sProcUID));
- } while (stat < 0 && errno == EINTR);
+ } while (stat < 0 && (errno == EINTR || errno == EAGAIN));
if (stat != sizeof(sProcUID)) {
qemu_pipe_close(sProcPipe);
diff --git a/system/OpenglSystemCommon/QemuPipeStream.cpp b/system/OpenglSystemCommon/QemuPipeStream.cpp
index fb515c9..4f5bd24 100644
--- a/system/OpenglSystemCommon/QemuPipeStream.cpp
+++ b/system/OpenglSystemCommon/QemuPipeStream.cpp
@@ -26,11 +26,16 @@
#include <unistd.h>
#include <string.h>
+static const size_t kReadSize = 512 * 1024;
+static const size_t kWriteOffset = kReadSize;
+
QemuPipeStream::QemuPipeStream(size_t bufSize) :
IOStream(bufSize),
m_sock((QEMU_PIPE_HANDLE)(-1)),
m_bufsize(bufSize),
- m_buf(NULL)
+ m_buf(NULL),
+ m_read(0),
+ m_readLeft(0)
{
}
@@ -38,7 +43,9 @@
IOStream(bufSize),
m_sock(sock),
m_bufsize(bufSize),
- m_buf(NULL)
+ m_buf(NULL),
+ m_read(0),
+ m_readLeft(0)
{
}
@@ -67,6 +74,9 @@
void *QemuPipeStream::allocBuffer(size_t minSize)
{
+ // Add dedicated read buffer space at the front of the buffer.
+ minSize += kReadSize;
+
size_t allocSize = (m_bufsize < minSize ? minSize : m_bufsize);
if (!m_buf) {
m_buf = (unsigned char *)malloc(allocSize);
@@ -84,13 +94,13 @@
}
}
- return m_buf;
+ return m_buf + kWriteOffset;
};
int QemuPipeStream::commitBuffer(size_t size)
{
if (size == 0) return 0;
- return writeFully(m_buf, size);
+ return writeFully(m_buf + kWriteOffset, size);
}
int QemuPipeStream::writeFully(const void *buf, size_t len)
@@ -140,39 +150,96 @@
const unsigned char *QemuPipeStream::readFully(void *buf, size_t len)
{
- //DBG(">> QemuPipeStream::readFully %d\n", len);
+ return commitBufferAndReadFully(0, buf, len);
+}
+
+const unsigned char *QemuPipeStream::commitBufferAndReadFully(size_t writeSize, void *userReadBufPtr, size_t totalReadSize) {
+
+ unsigned char* userReadBuf = static_cast<unsigned char*>(userReadBufPtr);
+
if (!valid()) return NULL;
- if (!buf) {
- if (len > 0) {
- // If len is non-zero, buf must not be NULL. Otherwise the pipe would be
- // in a corrupted state, which is lethal for the emulator.
- ERR("QemuPipeStream::readFully failed, buf=NULL, len %zu, lethal"
- " error, exiting.", len);
+
+ if (!userReadBuf) {
+ if (totalReadSize > 0) {
+ ALOGE("QemuPipeStream::commitBufferAndReadFully failed, userReadBuf=NULL, totalReadSize %zu, lethal"
+ " error, exiting.", totalReadSize);
abort();
}
- return NULL; // do not allow NULL buf in that implementation
- }
- size_t res = len;
- while (res > 0) {
- ssize_t stat = qemu_pipe_read(m_sock, (char *)(buf) + len - res, res);
- if (stat == 0) {
- // client shutdown;
+ if (!writeSize) {
return NULL;
- } else if (stat < 0) {
- if (qemu_pipe_try_again()) {
- continue;
- } else {
- ERR("QemuPipeStream::readFully failed (buf %p, len %zu"
- ", res %zu): %s, lethal error, exiting.", buf, len, res,
- strerror(errno));
- abort();
- }
- } else {
- res -= stat;
}
}
- //DBG("<< QemuPipeStream::readFully %d\n", len);
- return (const unsigned char *)buf;
+
+ // Advance buffered read if not yet consumed.
+ size_t remaining = totalReadSize;
+ size_t bufferedReadSize = m_readLeft < remaining ? m_readLeft : remaining;
+ if (bufferedReadSize) {
+ memcpy(userReadBuf, m_buf + (m_read - m_readLeft), bufferedReadSize);
+ remaining -= bufferedReadSize;
+ m_readLeft -= bufferedReadSize;
+ }
+
+ // Early out if nothing left to do.
+ if (!writeSize && !remaining) {
+ return userReadBuf;
+ }
+
+ int writeFullyRes = writeFully(m_buf + kWriteOffset, writeSize);
+
+ // Now done writing. Early out if no reading left to do.
+ if (!remaining) {
+ return userReadBuf;
+ }
+
+ // Read up to kReadSize bytes if all buffered read has been consumed.
+ size_t maxRead = m_readLeft ? 0 : kReadSize;
+
+ ssize_t actual = 0;
+
+ if (maxRead) {
+ actual = qemu_pipe_read(m_sock, m_buf, maxRead);
+ // Updated buffered read size.
+ if (actual > 0) {
+ m_read = m_readLeft = actual;
+ }
+
+ if (actual == 0) {
+ ALOGD("%s: end of pipe", __FUNCTION__);
+ return NULL;
+ }
+ }
+
+ // Consume buffered read and read more if necessary.
+ while (remaining) {
+ bufferedReadSize = m_readLeft < remaining ? m_readLeft : remaining;
+ if (bufferedReadSize) {
+ memcpy(userReadBuf + (totalReadSize - remaining),
+ m_buf + (m_read - m_readLeft),
+ bufferedReadSize);
+ remaining -= bufferedReadSize;
+ m_readLeft -= bufferedReadSize;
+ continue;
+ }
+
+ actual = qemu_pipe_read(m_sock, m_buf, kReadSize);
+
+ if (actual == 0) {
+ ALOGD("%s: Failed reading from pipe: %d", __FUNCTION__, errno);
+ return NULL;
+ }
+
+ if (actual > 0) {
+ m_read = m_readLeft = actual;
+ continue;
+ }
+
+ if (!qemu_pipe_try_again()) {
+ ALOGD("%s: Error reading from pipe: %d", __FUNCTION__, errno);
+ return NULL;
+ }
+ }
+
+ return userReadBuf;
}
const unsigned char *QemuPipeStream::read( void *buf, size_t *inout_len)
@@ -211,8 +278,9 @@
if (res == 0) { /* EOF */
break;
}
- if (qemu_pipe_try_again())
+ if (qemu_pipe_try_again()) {
continue;
+ }
/* A real error */
if (ret == 0)
diff --git a/system/OpenglSystemCommon/QemuPipeStream.h b/system/OpenglSystemCommon/QemuPipeStream.h
index a6a3d88..65755da 100644
--- a/system/OpenglSystemCommon/QemuPipeStream.h
+++ b/system/OpenglSystemCommon/QemuPipeStream.h
@@ -42,6 +42,7 @@
virtual void *allocBuffer(size_t minSize);
virtual int commitBuffer(size_t size);
virtual const unsigned char *readFully( void *buf, size_t len);
+ virtual const unsigned char *commitBufferAndReadFully(size_t size, void *buf, size_t len);
virtual const unsigned char *read( void *buf, size_t *inout_len);
bool valid() { return qemu_pipe_valid(m_sock); }
@@ -54,8 +55,11 @@
QEMU_PIPE_HANDLE m_sock;
size_t m_bufsize;
unsigned char *m_buf;
+ size_t m_read;
+ size_t m_readLeft;
#ifdef __Fuchsia__
fuchsia::hardware::goldfish::pipe::DeviceSyncPtr m_device;
+ fuchsia::hardware::goldfish::pipe::PipeSyncPtr m_pipe;
zx::event m_event;
zx::vmo m_vmo;
#endif
diff --git a/system/OpenglSystemCommon/QemuPipeStreamFuchsia.cpp b/system/OpenglSystemCommon/QemuPipeStreamFuchsia.cpp
index 4377d40..8b22719 100644
--- a/system/OpenglSystemCommon/QemuPipeStreamFuchsia.cpp
+++ b/system/OpenglSystemCommon/QemuPipeStreamFuchsia.cpp
@@ -27,11 +27,16 @@
#include <utility>
+constexpr size_t kReadSize = 512 * 1024;
+constexpr size_t kWriteOffset = kReadSize;
+
QemuPipeStream::QemuPipeStream(size_t bufSize) :
IOStream(bufSize),
m_sock(-1),
m_bufsize(bufSize),
- m_buf(nullptr)
+ m_buf(nullptr),
+ m_read(0),
+ m_readLeft(0)
{
}
@@ -39,7 +44,9 @@
IOStream(bufSize),
m_sock(sock),
m_bufsize(bufSize),
- m_buf(nullptr)
+ m_buf(nullptr),
+ m_read(0),
+ m_readLeft(0)
{
}
@@ -78,6 +85,7 @@
return -1;
}
m_device.Bind(std::move(channel));
+ m_device->OpenPipe(m_pipe.NewRequest());
zx::event event;
status = zx::event::create(0, &event);
@@ -92,29 +100,27 @@
return -1;
}
- status = m_device->SetEvent(std::move(event_copy));
+ status = m_pipe->SetEvent(std::move(event_copy));
if (status != ZX_OK) {
ALOGE("%s: failed to set event: %d:%d", __FUNCTION__, status);
return -1;
}
- zx_status_t status2 = ZX_OK;
- zx::vmo vmo;
- status = m_device->GetBuffer(&status2, &vmo);
- if (status != ZX_OK || status2 != ZX_OK) {
- ALOGE("%s: failed to get buffer: %d:%d", __FUNCTION__, status, status2);
+ if (!allocBuffer(m_bufsize)) {
+ ALOGE("%s: failed allocate initial buffer", __FUNCTION__);
return -1;
}
size_t len = strlen("pipe:opengles");
- status = vmo.write("pipe:opengles", 0, len + 1);
+ status = m_vmo.write("pipe:opengles", 0, len + 1);
if (status != ZX_OK) {
ALOGE("%s: failed write pipe name", __FUNCTION__);
return -1;
}
uint64_t actual;
- status = m_device->Write(len + 1, 0, &status2, &actual);
+ zx_status_t status2 = ZX_OK;
+ status = m_pipe->Write(len + 1, 0, &status2, &actual);
if (status != ZX_OK || status2 != ZX_OK) {
ALOGD("%s: connecting to pipe service failed: %d:%d", __FUNCTION__,
status, status2);
@@ -122,16 +128,18 @@
}
m_event = std::move(event);
- m_vmo = std::move(vmo);
return 0;
}
void *QemuPipeStream::allocBuffer(size_t minSize)
{
+ // Add dedicated read buffer space at the front of buffer.
+ minSize += kReadSize;
+
zx_status_t status;
if (m_buf) {
if (minSize <= m_bufsize) {
- return m_buf;
+ return m_buf + kWriteOffset;
}
status = zx_vmar_unmap(zx_vmar_root_self(),
reinterpret_cast<zx_vaddr_t>(m_buf),
@@ -146,14 +154,14 @@
size_t allocSize = m_bufsize < minSize ? minSize : m_bufsize;
zx_status_t status2 = ZX_OK;
- status = m_device->SetBufferSize(allocSize, &status2);
+ status = m_pipe->SetBufferSize(allocSize, &status2);
if (status != ZX_OK || status2 != ZX_OK) {
ALOGE("%s: failed to get buffer: %d:%d", __FUNCTION__, status, status2);
return nullptr;
}
zx::vmo vmo;
- status = m_device->GetBuffer(&status2, &vmo);
+ status = m_pipe->GetBuffer(&status2, &vmo);
if (status != ZX_OK || status2 != ZX_OK) {
ALOGE("%s: failed to get buffer: %d:%d", __FUNCTION__, status, status2);
return nullptr;
@@ -171,44 +179,19 @@
m_buf = reinterpret_cast<unsigned char*>(mapped_addr);
m_bufsize = allocSize;
m_vmo = std::move(vmo);
- return m_buf;
+ return m_buf + kWriteOffset;
}
int QemuPipeStream::commitBuffer(size_t size)
{
if (size == 0) return 0;
- size_t remaining = size;
- while (remaining) {
- zx_status_t status2 = ZX_OK;
- uint64_t actual = 0;
- zx_status_t status = m_device->Write(
- remaining, size - remaining, &status2, &actual);
- if (status != ZX_OK) {
- ALOGD("%s: Failed writing to pipe: %d", __FUNCTION__, status);
- return -1;
- }
- if (actual) {
- remaining -= actual;
- continue;
- }
- if (status2 != ZX_ERR_SHOULD_WAIT) {
- ALOGD("%s: Error writing to pipe: %d", __FUNCTION__, status2);
- return -1;
- }
- zx_signals_t observed = ZX_SIGNAL_NONE;
- status = m_event.wait_one(
- fuchsia::hardware::goldfish::pipe::SIGNAL_WRITABLE |
- fuchsia::hardware::goldfish::pipe::SIGNAL_HANGUP,
- zx::time::infinite(), &observed);
- if (status != ZX_OK) {
- ALOGD("%s: wait_one failed: %d", __FUNCTION__, status);
- return -1;
- }
- if (observed & fuchsia::hardware::goldfish::pipe::SIGNAL_HANGUP) {
- ALOGD("%s: Remote end hungup", __FUNCTION__);
- return -1;
- }
+ uint64_t actual = 0;
+ zx_status_t status2 = ZX_OK;
+ zx_status_t status = m_pipe->Call(size, kWriteOffset, 0, 0, &status2, &actual);
+ if (status != ZX_OK || status2 != ZX_OK) {
+ ALOGD("%s: Pipe call failed: %d:%d", __FUNCTION__, status, status2);
+ return -1;
}
return 0;
@@ -227,30 +210,74 @@
const unsigned char *QemuPipeStream::readFully(void *buf, size_t len)
{
+ return commitBufferAndReadFully(0, buf, len);
+}
+
+const unsigned char *QemuPipeStream::commitBufferAndReadFully(size_t size, void *buf, size_t len)
+{
if (!m_device.is_bound()) return nullptr;
if (!buf) {
if (len > 0) {
- ALOGE("QemuPipeStream::readFully failed, buf=NULL, len %zu, lethal"
+ ALOGE("QemuPipeStream::commitBufferAndReadFully failed, buf=NULL, len %zu, lethal"
" error, exiting.", len);
abort();
}
+ if (!size) {
+ return nullptr;
+ }
+ }
+
+ // Advance buffered read if not yet consumed.
+ size_t remaining = len;
+ size_t readSize = m_readLeft < remaining ? m_readLeft : remaining;
+ if (readSize) {
+ memcpy(static_cast<char*>(buf), m_buf + (m_read - m_readLeft), readSize);
+ remaining -= readSize;
+ m_readLeft -= readSize;
+ }
+
+ // Early out if nothing left to do.
+ if (!size && !remaining) {
+ return static_cast<const unsigned char *>(buf);
+ }
+
+ // Read up to kReadSize bytes if all buffered read has been consumed.
+ size_t maxRead = (m_readLeft || !remaining) ? 0 : kReadSize;
+ uint64_t actual = 0;
+ zx_status_t status2 = ZX_OK;
+ zx_status_t status = m_pipe->Call(size, kWriteOffset, maxRead, 0, &status2, &actual);
+ if (status != ZX_OK) {
+ ALOGD("%s: Pipe call failed: %d", __FUNCTION__, status);
return nullptr;
}
- size_t remaining = len;
+ // Updated buffered read size.
+ if (actual) {
+ m_read = m_readLeft = actual;
+ }
+
+ // Consume buffered read and read more if neccessary.
while (remaining) {
- size_t readSize = m_bufsize < remaining ? m_bufsize : remaining;
- zx_status_t status2 = ZX_OK;
- uint64_t actual = 0;
- zx_status_t status = m_device->Read(readSize, 0, &status2, &actual);
+ readSize = m_readLeft < remaining ? m_readLeft : remaining;
+ if (readSize) {
+ memcpy(static_cast<char*>(buf) + (len - remaining),
+ m_buf + (m_read - m_readLeft),
+ readSize);
+ remaining -= readSize;
+ m_readLeft -= readSize;
+ continue;
+ }
+
+ status2 = ZX_OK;
+ actual = 0;
+ status = m_pipe->Read(kReadSize, 0, &status2, &actual);
if (status != ZX_OK) {
ALOGD("%s: Failed reading from pipe: %d", __FUNCTION__, status);
return nullptr;
}
if (actual) {
- m_vmo.read(static_cast<char *>(buf) + (len - remaining), 0, actual);
- remaining -= actual;
+ m_read = m_readLeft = actual;
continue;
}
if (status2 != ZX_ERR_SHOULD_WAIT) {
diff --git a/system/OpenglSystemCommon/VirtioGpuStream.h b/system/OpenglSystemCommon/VirtioGpuStream.h
index 9d6faa5..0be50e6 100644
--- a/system/OpenglSystemCommon/VirtioGpuStream.h
+++ b/system/OpenglSystemCommon/VirtioGpuStream.h
@@ -69,6 +69,10 @@
virtual int writeFully(const void *buf, size_t len);
virtual const unsigned char *readFully(void *buf, size_t len);
virtual int commitBuffer(size_t size);
+ virtual const unsigned char* commitBufferAndReadFully(size_t size, void *buf, size_t len)
+ {
+ return commitBuffer(size) ? nullptr : readFully(buf, len);
+ }
virtual const unsigned char *read(void *buf, size_t *inout_len) final
{
return readFully(buf, *inout_len);
diff --git a/system/gralloc/gralloc.cpp b/system/gralloc/gralloc.cpp
index 3d08158..39e7e16 100644
--- a/system/gralloc/gralloc.cpp
+++ b/system/gralloc/gralloc.cpp
@@ -29,6 +29,7 @@
#endif
#include "goldfish_dma.h"
+#include "goldfish_address_space.h"
#include "FormatConversions.h"
#include "HostConnection.h"
#include "ProcessPipe.h"
@@ -125,13 +126,20 @@
#define INITIAL_DMA_REGION_SIZE 4096
struct gralloc_dmaregion_t {
gralloc_dmaregion_t(ExtendedRCEncoderContext *rcEnc)
- : sz(0), refcount(0), bigbufCount(0) {
+ : sz(INITIAL_DMA_REGION_SIZE), refcount(0), bigbufCount(0) {
+ memset(&goldfish_dma, 0, sizeof(goldfish_dma));
pthread_mutex_init(&lock, NULL);
- sz = INITIAL_DMA_REGION_SIZE;
- goldfish_dma_create_region(sz, &goldfish_dma);
+
+ if (rcEnc->hasDirectMem()) {
+ host_memory_allocator.hostMalloc(&address_space_block, sz);
+ } else if (rcEnc->getDmaVersion() > 0) {
+ goldfish_dma_create_region(sz, &goldfish_dma);
+ }
}
goldfish_dma_context goldfish_dma;
+ GoldfishAddressSpaceHostMemoryAllocator host_memory_allocator;
+ GoldfishAddressSpaceBlock address_space_block;
uint32_t sz;
uint32_t refcount;
pthread_mutex_t lock;
@@ -149,6 +157,10 @@
return s_memregions;
}
+static bool has_DMA_support(const ExtendedRCEncoderContext *rcEnc) {
+ return rcEnc->getDmaVersion() > 0 || rcEnc->hasDirectMem();
+}
+
static gralloc_dmaregion_t* init_gralloc_dmaregion(ExtendedRCEncoderContext *rcEnc) {
D("%s: call\n", __func__);
if (!s_grdma) {
@@ -178,6 +190,15 @@
// max dma size: 2x 4K rgba8888
#define MAX_DMA_SIZE 66355200
+static bool put_gralloc_region_direct_mem_locked(gralloc_dmaregion_t* grdma, uint32_t sz) {
+ const bool shouldDelete = !grdma->refcount;
+ if (shouldDelete) {
+ grdma->host_memory_allocator.hostFree(&grdma->address_space_block);
+ }
+
+ return shouldDelete;
+}
+
static bool put_gralloc_region_dma_locked(gralloc_dmaregion_t* grdma, uint32_t sz) {
D("%s: call. refcount before: %u\n", __func__, grdma->refcount);
grdma->refcount--;
@@ -199,20 +220,36 @@
gralloc_dmaregion_t* grdma = init_gralloc_dmaregion(rcEnc);
pthread_mutex_lock(&grdma->lock);
- shouldDelete = put_gralloc_region_dma_locked(grdma, sz);
+ if (rcEnc->hasDirectMem()) {
+ shouldDelete = put_gralloc_region_direct_mem_locked(grdma, sz);
+ } else if (rcEnc->getDmaVersion() > 0) {
+ shouldDelete = put_gralloc_region_dma_locked(grdma, sz);
+ } else {
+ shouldDelete = false;
+ }
pthread_mutex_unlock(&grdma->lock);
return shouldDelete;
}
-static void gralloc_dmaregion_register_ashmem_dma(gralloc_dmaregion_t* grdma, uint32_t new_sz) {
+static void gralloc_dmaregion_register_ashmem_direct_mem_locked(gralloc_dmaregion_t* grdma, uint32_t new_sz) {
+ if (new_sz == grdma->sz) return;
+
+ GoldfishAddressSpaceHostMemoryAllocator* allocator = &grdma->host_memory_allocator;
+ GoldfishAddressSpaceBlock* block = &grdma->address_space_block;
+ allocator->hostFree(block);
+ allocator->hostMalloc(block, new_sz);
+ grdma->sz = new_sz;
+}
+
+static void gralloc_dmaregion_register_ashmem_dma_locked(gralloc_dmaregion_t* grdma, uint32_t new_sz) {
if (new_sz != grdma->sz) {
if (new_sz > MAX_DMA_SIZE) {
D("%s: requested sz %u too large (limit %u), set to fallback.",
- __func__, sz, MAX_DMA_SIZE);
+ __func__, new_sz, MAX_DMA_SIZE);
grdma->bigbufCount++;
} else {
- D("%s: change sz from %u to %u", __func__, grdma->sz, sz);
+ D("%s: change sz from %u to %u", __func__, grdma->sz, new_sz);
resize_gralloc_dmaregion_locked(grdma, new_sz);
}
}
@@ -227,7 +264,15 @@
pthread_mutex_lock(&grdma->lock);
D("%s: for sz %u, refcount %u", __func__, sz, grdma->refcount);
const uint32_t new_sz = std::max(grdma->sz, sz);
- gralloc_dmaregion_register_ashmem_dma(grdma, new_sz);
+
+ if (rcEnc->hasDirectMem()) {
+ gralloc_dmaregion_register_ashmem_direct_mem_locked(grdma, new_sz);
+ } else if (rcEnc->getDmaVersion() > 0) {
+ gralloc_dmaregion_register_ashmem_dma_locked(grdma, new_sz);
+ } else {
+ ALOGE("%s: unexpected DMA type", __func__);
+ }
+
pthread_mutex_unlock(&grdma->lock);
}
@@ -389,37 +434,40 @@
cb->frameworkFormat != HAL_PIXEL_FORMAT_YCbCr_420_888;
std::vector<char> convertedBuf;
- if ((doLocked && is_rgb_format) ||
- (!grdma && (doLocked || !is_rgb_format))) {
- convertedBuf.resize(rgbSz);
- to_send = &convertedBuf.front();
- send_buffer_size = rgbSz;
- }
if (doLocked && is_rgb_format) {
+ convertedBuf.resize(rgbSz);
+ to_send = &convertedBuf.front();
copy_rgb_buffer_from_unlocked(
to_send, pixels,
cb->width,
width, height, top, left, bpp);
}
- const bool hasDMA = rcEnc->getDmaVersion() > 0;
+ const bool hasDMA = has_DMA_support(rcEnc);
if (hasDMA && grdma->bigbufCount) {
D("%s: there are big buffers alive, use fallback (count %u)", __FUNCTION__,
grdma->bigbufCount);
}
if (hasDMA && !grdma->bigbufCount) {
- if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YV12) {
- get_yv12_offsets(width, height, NULL, NULL,
- &send_buffer_size);
- }
- if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YCbCr_420_888) {
- get_yuv420p_offsets(width, height, NULL, NULL,
- &send_buffer_size);
+ switch (cb->frameworkFormat) {
+ case HAL_PIXEL_FORMAT_YV12:
+ get_yv12_offsets(width, height, NULL, NULL, &send_buffer_size);
+ break;
+
+ case HAL_PIXEL_FORMAT_YCbCr_420_888:
+ get_yuv420p_offsets(width, height, NULL, NULL, &send_buffer_size);
+ break;
}
- rcEnc->bindDmaContext(&grdma->goldfish_dma);
+ if (grdma->address_space_block.guestPtr()) {
+ rcEnc->bindAddressSpaceBlock(&grdma->address_space_block);
+ } else if (grdma->goldfish_dma.mapped_addr) {
+ rcEnc->bindDmaContext(&grdma->goldfish_dma);
+ } else {
+ ALOGE("%s: Unexpected DMA", __func__);
+ }
D("%s: call. dma update with sz=%u", __func__, send_buffer_size);
pthread_mutex_lock(&grdma->lock);
@@ -429,15 +477,29 @@
to_send, send_buffer_size);
pthread_mutex_unlock(&grdma->lock);
} else {
- if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YV12) {
+ switch (cb->frameworkFormat) {
+ case HAL_PIXEL_FORMAT_YV12:
+ convertedBuf.resize(rgbSz);
+ to_send = &convertedBuf.front();
+ D("convert yv12 to rgb888 here");
yv12_to_rgb888(to_send, pixels,
width, height, left, top,
left + width - 1, top + height - 1);
- }
- if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YCbCr_420_888) {
- yuv420p_to_rgb888(to_send, pixels,
- width, height, left, top,
- left + width - 1, top + height - 1);
+ break;
+
+ case HAL_PIXEL_FORMAT_YCbCr_420_888:
+ convertedBuf.resize(rgbSz);
+ to_send = &convertedBuf.front();
+ if (rcEnc->hasYUV420toNV21()) {
+ nv21_to_rgb888(to_send, pixels,
+ width, height, left, top,
+ left + width - 1, top + height - 1);
+ } else {
+ yuv420p_to_rgb888(to_send, pixels,
+ width, height, left, top,
+ left + width - 1, top + height - 1);
+ }
+ break;
}
rcEnc->rcUpdateColorBuffer(rcEnc, cb->hostHandle,
left, top, width, height,
@@ -738,6 +800,8 @@
cb->setFd(fd);
}
+ const bool hasDMA = has_DMA_support(rcEnc);
+
if (needHostCb) {
if (hostCon && rcEnc) {
GLenum allocFormat = glFormat;
@@ -750,9 +814,8 @@
allocFormat = GL_RGB;
}
- gralloc_dmaregion_t* grdma = init_gralloc_dmaregion(rcEnc);
hostCon->lock();
- if (rcEnc->getDmaVersion() > 0) {
+ if (hasDMA) {
cb->hostHandle = rcEnc->rcCreateColorBufferDMA(rcEnc, w, h, allocFormat, cb->emuFrameworkFormat);
} else {
cb->hostHandle = rcEnc->rcCreateColorBuffer(rcEnc, w, h, allocFormat);
@@ -764,7 +827,7 @@
// Could not create colorbuffer on host !!!
close(fd);
delete cb;
- ALOGD("%s: failed to create host cb! -EIO", __FUNCTION__);
+ ALOGE("%s: failed to create host cb! -EIO", __FUNCTION__);
return -EIO;
} else {
QEMU_PIPE_HANDLE refcountPipeFd = qemu_pipe_open("refcount");
@@ -798,7 +861,7 @@
}
hostCon->lock();
- if (rcEnc->getDmaVersion() > 0) {
+ if (hasDMA) {
get_gralloc_region(rcEnc); // map_buffer(cb, ...) refers here
}
hostCon->unlock();
@@ -1025,13 +1088,6 @@
int32_t* openCountPtr = getOpenCountPtr(cb);
if (!*openCountPtr) *openCountPtr = 1;
}
-
- hostCon->lock();
- if (rcEnc->getDmaVersion() > 0) {
- gralloc_dmaregion_register_ashmem(rcEnc, cb->ashmemSize);
- }
- hostCon->unlock();
-
}
if (cb->ashmemSize > 0) {
@@ -1205,27 +1261,53 @@
// camera delivers bits to the buffer directly and does not require
// an explicit read, it also writes in YUV_420 (interleaved)
if (sw_read & !(usage & GRALLOC_USAGE_HW_CAMERA_MASK)) {
+ D("gralloc_lock read back color buffer %d %d ashmem base %p sz %d\n",
+ cb->width, cb->height, cb->ashmemBase, cb->ashmemSize);
void* rgb_addr = cpu_addr;
char* tmpBuf = 0;
if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YV12 ||
cb->frameworkFormat == HAL_PIXEL_FORMAT_YCbCr_420_888) {
- // We are using RGB888
- tmpBuf = new char[cb->width * cb->height * 3];
- rgb_addr = tmpBuf;
- }
- D("gralloc_lock read back color buffer %d %d ashmem base %p sz %d\n",
- cb->width, cb->height, cb->ashmemBase, cb->ashmemSize);
- rcEnc->rcReadColorBuffer(rcEnc, cb->hostHandle,
- 0, 0, cb->width, cb->height, cb->glFormat, cb->glType, rgb_addr);
- if (tmpBuf) {
- if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YV12) {
- rgb888_to_yv12((char*)cpu_addr, tmpBuf, cb->width, cb->height, l, t, l+w-1, t+h-1);
- } else if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YCbCr_420_888) {
- rgb888_to_yuv420p((char*)cpu_addr, tmpBuf, cb->width, cb->height, l, t, l+w-1, t+h-1);
+ if (rcEnc->hasYUVCache()) {
+ uint32_t buffer_size;
+ if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YV12) {
+ get_yv12_offsets(cb->width, cb->height, NULL, NULL,
+ &buffer_size);
+ } else {
+ get_yuv420p_offsets(cb->width, cb->height, NULL, NULL,
+ &buffer_size);
+ }
+ D("read YUV copy from host");
+ rcEnc->rcReadColorBufferYUV(rcEnc, cb->hostHandle,
+ 0, 0, cb->width, cb->height,
+ rgb_addr, buffer_size);
+ } else {
+ // We are using RGB888
+ tmpBuf = new char[cb->width * cb->height * 3];
+ rcEnc->rcReadColorBuffer(rcEnc, cb->hostHandle,
+ 0, 0, cb->width, cb->height, cb->glFormat, cb->glType, tmpBuf);
+ if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YV12) {
+ D("convert rgb888 to yv12 here");
+ rgb888_to_yv12((char*)cpu_addr, tmpBuf, cb->width, cb->height, l, t, l+w-1, t+h-1);
+ } else if (cb->frameworkFormat == HAL_PIXEL_FORMAT_YCbCr_420_888) {
+ if (rcEnc->hasYUV420toNV21()) {
+ D("convert rgb888 to nv21 here");
+ rgb888_to_nv21((char*)cpu_addr, tmpBuf, cb->width, cb->height, l, t, l+w-1, t+h-1);
+ } else {
+ D("convert rgb888 to yuv420p here");
+ rgb888_to_yuv420p((char*)cpu_addr, tmpBuf, cb->width, cb->height, l, t, l+w-1, t+h-1);
+ }
+ }
+ delete [] tmpBuf;
}
- delete [] tmpBuf;
+ } else {
+ rcEnc->rcReadColorBuffer(rcEnc, cb->hostHandle,
+ 0, 0, cb->width, cb->height, cb->glFormat, cb->glType, rgb_addr);
}
}
+
+ if (has_DMA_support(rcEnc)) {
+ gralloc_dmaregion_register_ashmem(rcEnc, cb->ashmemSize);
+ }
hostCon->unlock();
}
@@ -1367,8 +1449,9 @@
uOffset = vOffset + cSize;
cStep = 1;
break;
- case HAL_PIXEL_FORMAT_YCbCr_420_888:
- if (usage & GRALLOC_USAGE_HW_CAMERA_MASK) {
+ case HAL_PIXEL_FORMAT_YCbCr_420_888: {
+ DEFINE_AND_VALIDATE_HOST_CONNECTION
+ if (rcEnc->hasYUV420toNV21()) {
yStride = cb->width;
cStride = cb->width;
yOffset = 0;
@@ -1376,14 +1459,24 @@
uOffset = vOffset + 1;
cStep = 2;
} else {
- yStride = cb->width;
- cStride = yStride / 2;
- yOffset = 0;
- uOffset = cb->height * yStride;
- vOffset = uOffset + cStride * cb->height / 2;
- cStep = 1;
+ if (usage & GRALLOC_USAGE_HW_CAMERA_MASK) {
+ yStride = cb->width;
+ cStride = cb->width;
+ yOffset = 0;
+ vOffset = yStride * cb->height;
+ uOffset = vOffset + 1;
+ cStep = 2;
+ } else {
+ yStride = cb->width;
+ cStride = yStride / 2;
+ yOffset = 0;
+ uOffset = cb->height * yStride;
+ vOffset = uOffset + cStride * cb->height / 2;
+ cStep = 1;
+ }
}
break;
+ }
default:
ALOGE("gralloc_lock_ycbcr unexpected internal format %x",
cb->format);
@@ -1553,6 +1646,10 @@
lock: gralloc_lock,
unlock: gralloc_unlock,
perform: NULL,
+#if PLATFORM_SDK_VERSION >= 29 // For Q and later
+ validateBufferSize: NULL,
+ getTransportSize: NULL,
+#endif // PLATFORM_SDK_VERSION >= 29
#if PLATFORM_SDK_VERSION >= 18
lock_ycbcr: gralloc_lock_ycbcr,
#endif // PLATFORM_SDK_VERSION >= 18
diff --git a/system/hwc2/EmuHWC2.cpp b/system/hwc2/EmuHWC2.cpp
index 84fd7b6..00b7a21 100644
--- a/system/hwc2/EmuHWC2.cpp
+++ b/system/hwc2/EmuHWC2.cpp
@@ -416,7 +416,7 @@
mSetColorTransform(false),
mStateMutex()
{
- mVsyncThread.run("", HAL_PRIORITY_URGENT_DISPLAY);
+ mVsyncThread.run("", -19 /* ANDROID_PRIORITY_URGENT_AUDIO */);
}
Error EmuHWC2::Display::acceptChanges() {
diff --git a/system/renderControl_enc/renderControl_client_context.cpp b/system/renderControl_enc/renderControl_client_context.cpp
index 6da72fc..476d0da 100644
--- a/system/renderControl_enc/renderControl_client_context.cpp
+++ b/system/renderControl_enc/renderControl_client_context.cpp
@@ -56,6 +56,7 @@
rcGetDisplayPose = (rcGetDisplayPose_client_proc_t) getProc("rcGetDisplayPose", userData);
rcSetDisplayPose = (rcSetDisplayPose_client_proc_t) getProc("rcSetDisplayPose", userData);
rcSetColorBufferVulkanMode = (rcSetColorBufferVulkanMode_client_proc_t) getProc("rcSetColorBufferVulkanMode", userData);
+ rcReadColorBufferYUV = (rcReadColorBufferYUV_client_proc_t) getProc("rcReadColorBufferYUV", userData);
return 0;
}
diff --git a/system/renderControl_enc/renderControl_client_context.h b/system/renderControl_enc/renderControl_client_context.h
index d05fee1..8905afa 100644
--- a/system/renderControl_enc/renderControl_client_context.h
+++ b/system/renderControl_enc/renderControl_client_context.h
@@ -56,6 +56,7 @@
rcGetDisplayPose_client_proc_t rcGetDisplayPose;
rcSetDisplayPose_client_proc_t rcSetDisplayPose;
rcSetColorBufferVulkanMode_client_proc_t rcSetColorBufferVulkanMode;
+ rcReadColorBufferYUV_client_proc_t rcReadColorBufferYUV;
virtual ~renderControl_client_context_t() {}
typedef renderControl_client_context_t *CONTEXT_ACCESSOR_TYPE(void);
diff --git a/system/renderControl_enc/renderControl_client_proc.h b/system/renderControl_enc/renderControl_client_proc.h
index f9690b6..6bba308 100644
--- a/system/renderControl_enc/renderControl_client_proc.h
+++ b/system/renderControl_enc/renderControl_client_proc.h
@@ -50,14 +50,15 @@
typedef uint32_t (renderControl_APIENTRY *rcCreateColorBufferDMA_client_proc_t) (void * ctx, uint32_t, uint32_t, GLenum, int);
typedef void (renderControl_APIENTRY *rcWaitSyncKHR_client_proc_t) (void * ctx, uint64_t, EGLint);
typedef GLint (renderControl_APIENTRY *rcCompose_client_proc_t) (void * ctx, uint32_t, void*);
-typedef GLint (renderControl_APIENTRY *rcCreateDisplay_client_proc_t) (void * ctx, uint32_t*);
-typedef GLint (renderControl_APIENTRY *rcDestroyDisplay_client_proc_t) (void * ctx, uint32_t);
-typedef GLint (renderControl_APIENTRY *rcSetDisplayColorBuffer_client_proc_t) (void * ctx, uint32_t, uint32_t);
-typedef GLint (renderControl_APIENTRY *rcGetDisplayColorBuffer_client_proc_t) (void * ctx, uint32_t, uint32_t*);
-typedef GLint (renderControl_APIENTRY *rcGetColorBufferDisplay_client_proc_t) (void * ctx, uint32_t, uint32_t*);
-typedef GLint (renderControl_APIENTRY *rcGetDisplayPose_client_proc_t) (void * ctx, uint32_t, uint32_t*, uint32_t*, uint32_t*, uint32_t*);
-typedef GLint (renderControl_APIENTRY *rcSetDisplayPose_client_proc_t) (void * ctx, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t);
+typedef int (renderControl_APIENTRY *rcCreateDisplay_client_proc_t) (void * ctx, uint32_t*);
+typedef int (renderControl_APIENTRY *rcDestroyDisplay_client_proc_t) (void * ctx, uint32_t);
+typedef int (renderControl_APIENTRY *rcSetDisplayColorBuffer_client_proc_t) (void * ctx, uint32_t, uint32_t);
+typedef int (renderControl_APIENTRY *rcGetDisplayColorBuffer_client_proc_t) (void * ctx, uint32_t, uint32_t*);
+typedef int (renderControl_APIENTRY *rcGetColorBufferDisplay_client_proc_t) (void * ctx, uint32_t, uint32_t*);
+typedef int (renderControl_APIENTRY *rcGetDisplayPose_client_proc_t) (void * ctx, uint32_t, GLint*, GLint*, uint32_t*, uint32_t*);
+typedef int (renderControl_APIENTRY *rcSetDisplayPose_client_proc_t) (void * ctx, uint32_t, GLint, GLint, uint32_t, uint32_t);
typedef GLint (renderControl_APIENTRY *rcSetColorBufferVulkanMode_client_proc_t) (void * ctx, uint32_t, uint32_t);
+typedef void (renderControl_APIENTRY *rcReadColorBufferYUV_client_proc_t) (void * ctx, uint32_t, GLint, GLint, GLint, GLint, void*, uint32_t);
#endif
diff --git a/system/renderControl_enc/renderControl_enc.cpp b/system/renderControl_enc/renderControl_enc.cpp
index a2d765f..fab8a15 100644
--- a/system/renderControl_enc/renderControl_enc.cpp
+++ b/system/renderControl_enc/renderControl_enc.cpp
@@ -1436,7 +1436,7 @@
return retval;
}
-GLint rcCreateDisplay_enc(void *self , uint32_t* displayId)
+int rcCreateDisplay_enc(void *self , uint32_t* displayId)
{
renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
@@ -1463,7 +1463,7 @@
stream->readback(displayId, __size_displayId);
if (useChecksum) checksumCalculator->addBuffer(displayId, __size_displayId);
- GLint retval;
+ int retval;
stream->readback(&retval, 4);
if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
if (useChecksum) {
@@ -1479,7 +1479,7 @@
return retval;
}
-GLint rcDestroyDisplay_enc(void *self , uint32_t displayId)
+int rcDestroyDisplay_enc(void *self , uint32_t displayId)
{
renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
@@ -1503,7 +1503,7 @@
if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
- GLint retval;
+ int retval;
stream->readback(&retval, 4);
if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
if (useChecksum) {
@@ -1519,7 +1519,7 @@
return retval;
}
-GLint rcSetDisplayColorBuffer_enc(void *self , uint32_t displayId, uint32_t colorBuffer)
+int rcSetDisplayColorBuffer_enc(void *self , uint32_t displayId, uint32_t colorBuffer)
{
renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
@@ -1544,7 +1544,7 @@
if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
- GLint retval;
+ int retval;
stream->readback(&retval, 4);
if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
if (useChecksum) {
@@ -1560,7 +1560,7 @@
return retval;
}
-GLint rcGetDisplayColorBuffer_enc(void *self , uint32_t displayId, uint32_t* colorBuffer)
+int rcGetDisplayColorBuffer_enc(void *self , uint32_t displayId, uint32_t* colorBuffer)
{
renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
@@ -1588,7 +1588,7 @@
stream->readback(colorBuffer, __size_colorBuffer);
if (useChecksum) checksumCalculator->addBuffer(colorBuffer, __size_colorBuffer);
- GLint retval;
+ int retval;
stream->readback(&retval, 4);
if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
if (useChecksum) {
@@ -1604,7 +1604,7 @@
return retval;
}
-GLint rcGetColorBufferDisplay_enc(void *self , uint32_t colorBuffer, uint32_t* displayId)
+int rcGetColorBufferDisplay_enc(void *self , uint32_t colorBuffer, uint32_t* displayId)
{
renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
@@ -1632,7 +1632,7 @@
stream->readback(displayId, __size_displayId);
if (useChecksum) checksumCalculator->addBuffer(displayId, __size_displayId);
- GLint retval;
+ int retval;
stream->readback(&retval, 4);
if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
if (useChecksum) {
@@ -1648,7 +1648,7 @@
return retval;
}
-GLint rcGetDisplayPose_enc(void *self , uint32_t displayId, uint32_t* x, uint32_t* y, uint32_t* w, uint32_t* h)
+int rcGetDisplayPose_enc(void *self , uint32_t displayId, GLint* x, GLint* y, uint32_t* w, uint32_t* h)
{
renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
@@ -1688,7 +1688,7 @@
stream->readback(h, __size_h);
if (useChecksum) checksumCalculator->addBuffer(h, __size_h);
- GLint retval;
+ int retval;
stream->readback(&retval, 4);
if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
if (useChecksum) {
@@ -1704,7 +1704,7 @@
return retval;
}
-GLint rcSetDisplayPose_enc(void *self , uint32_t displayId, uint32_t x, uint32_t y, uint32_t w, uint32_t h)
+int rcSetDisplayPose_enc(void *self , uint32_t displayId, GLint x, GLint y, uint32_t w, uint32_t h)
{
renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
@@ -1732,7 +1732,7 @@
if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
- GLint retval;
+ int retval;
stream->readback(&retval, 4);
if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
if (useChecksum) {
@@ -1789,6 +1789,50 @@
return retval;
}
+void rcReadColorBufferYUV_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, void* pixels, uint32_t pixels_size)
+{
+
+ renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_pixels = pixels_size;
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4 + 0 + 4 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_rcReadColorBufferYUV;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &colorbuffer, 4); ptr += 4;
+ memcpy(ptr, &x, 4); ptr += 4;
+ memcpy(ptr, &y, 4); ptr += 4;
+ memcpy(ptr, &width, 4); ptr += 4;
+ memcpy(ptr, &height, 4); ptr += 4;
+ *(unsigned int *)(ptr) = __size_pixels; ptr += 4;
+ memcpy(ptr, &pixels_size, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(pixels, __size_pixels);
+ if (useChecksum) checksumCalculator->addBuffer(pixels, __size_pixels);
+ if (useChecksum) {
+ unsigned char *checksumBufPtr = NULL;
+ unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
+ if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
+ stream->readback(checksumBufPtr, checksumSize);
+ if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
+ ALOGE("rcReadColorBufferYUV: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+}
+
} // namespace
renderControl_encoder_context_t::renderControl_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator)
@@ -1842,5 +1886,6 @@
this->rcGetDisplayPose = &rcGetDisplayPose_enc;
this->rcSetDisplayPose = &rcSetDisplayPose_enc;
this->rcSetColorBufferVulkanMode = &rcSetColorBufferVulkanMode_enc;
+ this->rcReadColorBufferYUV = &rcReadColorBufferYUV_enc;
}
diff --git a/system/renderControl_enc/renderControl_entry.cpp b/system/renderControl_enc/renderControl_entry.cpp
index 1314c7d..0974a96 100644
--- a/system/renderControl_enc/renderControl_entry.cpp
+++ b/system/renderControl_enc/renderControl_entry.cpp
@@ -43,14 +43,15 @@
uint32_t rcCreateColorBufferDMA(uint32_t width, uint32_t height, GLenum internalFormat, int frameworkFormat);
void rcWaitSyncKHR(uint64_t sync, EGLint flags);
GLint rcCompose(uint32_t bufferSize, void* buffer);
- GLint rcCreateDisplay(uint32_t* displayId);
- GLint rcDestroyDisplay(uint32_t displayId);
- GLint rcSetDisplayColorBuffer(uint32_t displayId, uint32_t colorBuffer);
- GLint rcGetDisplayColorBuffer(uint32_t displayId, uint32_t* colorBuffer);
- GLint rcGetColorBufferDisplay(uint32_t colorBuffer, uint32_t* displayId);
- GLint rcGetDisplayPose(uint32_t displayId, uint32_t* x, uint32_t* y, uint32_t* w, uint32_t* h);
- GLint rcSetDisplayPose(uint32_t displayId, uint32_t x, uint32_t y, uint32_t w, uint32_t h);
+ int rcCreateDisplay(uint32_t* displayId);
+ int rcDestroyDisplay(uint32_t displayId);
+ int rcSetDisplayColorBuffer(uint32_t displayId, uint32_t colorBuffer);
+ int rcGetDisplayColorBuffer(uint32_t displayId, uint32_t* colorBuffer);
+ int rcGetColorBufferDisplay(uint32_t colorBuffer, uint32_t* displayId);
+ int rcGetDisplayPose(uint32_t displayId, GLint* x, GLint* y, uint32_t* w, uint32_t* h);
+ int rcSetDisplayPose(uint32_t displayId, GLint x, GLint y, uint32_t w, uint32_t h);
GLint rcSetColorBufferVulkanMode(uint32_t colorBuffer, uint32_t mode);
+ void rcReadColorBufferYUV(uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, void* pixels, uint32_t pixels_size);
};
#ifndef GET_CONTEXT
@@ -287,43 +288,43 @@
return ctx->rcCompose(ctx, bufferSize, buffer);
}
-GLint rcCreateDisplay(uint32_t* displayId)
+int rcCreateDisplay(uint32_t* displayId)
{
GET_CONTEXT;
return ctx->rcCreateDisplay(ctx, displayId);
}
-GLint rcDestroyDisplay(uint32_t displayId)
+int rcDestroyDisplay(uint32_t displayId)
{
GET_CONTEXT;
return ctx->rcDestroyDisplay(ctx, displayId);
}
-GLint rcSetDisplayColorBuffer(uint32_t displayId, uint32_t colorBuffer)
+int rcSetDisplayColorBuffer(uint32_t displayId, uint32_t colorBuffer)
{
GET_CONTEXT;
return ctx->rcSetDisplayColorBuffer(ctx, displayId, colorBuffer);
}
-GLint rcGetDisplayColorBuffer(uint32_t displayId, uint32_t* colorBuffer)
+int rcGetDisplayColorBuffer(uint32_t displayId, uint32_t* colorBuffer)
{
GET_CONTEXT;
return ctx->rcGetDisplayColorBuffer(ctx, displayId, colorBuffer);
}
-GLint rcGetColorBufferDisplay(uint32_t colorBuffer, uint32_t* displayId)
+int rcGetColorBufferDisplay(uint32_t colorBuffer, uint32_t* displayId)
{
GET_CONTEXT;
return ctx->rcGetColorBufferDisplay(ctx, colorBuffer, displayId);
}
-GLint rcGetDisplayPose(uint32_t displayId, uint32_t* x, uint32_t* y, uint32_t* w, uint32_t* h)
+int rcGetDisplayPose(uint32_t displayId, GLint* x, GLint* y, uint32_t* w, uint32_t* h)
{
GET_CONTEXT;
return ctx->rcGetDisplayPose(ctx, displayId, x, y, w, h);
}
-GLint rcSetDisplayPose(uint32_t displayId, uint32_t x, uint32_t y, uint32_t w, uint32_t h)
+int rcSetDisplayPose(uint32_t displayId, GLint x, GLint y, uint32_t w, uint32_t h)
{
GET_CONTEXT;
return ctx->rcSetDisplayPose(ctx, displayId, x, y, w, h);
@@ -335,3 +336,9 @@
return ctx->rcSetColorBufferVulkanMode(ctx, colorBuffer, mode);
}
+void rcReadColorBufferYUV(uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, void* pixels, uint32_t pixels_size)
+{
+ GET_CONTEXT;
+ ctx->rcReadColorBufferYUV(ctx, colorbuffer, x, y, width, height, pixels, pixels_size);
+}
+
diff --git a/system/renderControl_enc/renderControl_ftable.h b/system/renderControl_enc/renderControl_ftable.h
index 035dfac..da58a04 100644
--- a/system/renderControl_enc/renderControl_ftable.h
+++ b/system/renderControl_enc/renderControl_ftable.h
@@ -54,6 +54,7 @@
{"rcGetDisplayPose", (void*)rcGetDisplayPose},
{"rcSetDisplayPose", (void*)rcSetDisplayPose},
{"rcSetColorBufferVulkanMode", (void*)rcSetColorBufferVulkanMode},
+ {"rcReadColorBufferYUV", (void*)rcReadColorBufferYUV},
};
static const int renderControl_num_funcs = sizeof(renderControl_funcs_by_name) / sizeof(struct _renderControl_funcs_by_name);
diff --git a/system/renderControl_enc/renderControl_opcodes.h b/system/renderControl_enc/renderControl_opcodes.h
index d2927d2..2c3780b 100644
--- a/system/renderControl_enc/renderControl_opcodes.h
+++ b/system/renderControl_enc/renderControl_opcodes.h
@@ -49,7 +49,8 @@
#define OP_rcGetDisplayPose 10043
#define OP_rcSetDisplayPose 10044
#define OP_rcSetColorBufferVulkanMode 10045
-#define OP_last 10046
+#define OP_rcReadColorBufferYUV 10046
+#define OP_last 10047
#endif
diff --git a/system/vulkan/func_table.cpp b/system/vulkan/func_table.cpp
index f5b380e..962184f 100644
--- a/system/vulkan/func_table.cpp
+++ b/system/vulkan/func_table.cpp
@@ -812,7 +812,8 @@
AEMU_SCOPED_TRACE("vkCreateSampler");
auto vkEnc = HostConnection::get()->vkEncoder();
VkResult vkCreateSampler_VkResult_return = (VkResult)0;
- vkCreateSampler_VkResult_return = vkEnc->vkCreateSampler(device, pCreateInfo, pAllocator, pSampler);
+ auto resources = ResourceTracker::get();
+ vkCreateSampler_VkResult_return = resources->on_vkCreateSampler(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSampler);
return vkCreateSampler_VkResult_return;
}
static void entry_vkDestroySampler(
@@ -1021,6 +1022,7 @@
{
AEMU_SCOPED_TRACE("vkBeginCommandBuffer");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkBeginCommandBuffer_VkResult_return = resources->on_vkBeginCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, pBeginInfo);
@@ -1031,6 +1033,7 @@
{
AEMU_SCOPED_TRACE("vkEndCommandBuffer");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkEndCommandBuffer_VkResult_return = resources->on_vkEndCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer);
@@ -1042,6 +1045,7 @@
{
AEMU_SCOPED_TRACE("vkResetCommandBuffer");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
vkResetCommandBuffer_VkResult_return = resources->on_vkResetCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, flags);
@@ -1054,6 +1058,7 @@
{
AEMU_SCOPED_TRACE("vkCmdBindPipeline");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
}
static void entry_vkCmdSetViewport(
@@ -1064,6 +1069,7 @@
{
AEMU_SCOPED_TRACE("vkCmdSetViewport");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
}
static void entry_vkCmdSetScissor(
@@ -1074,6 +1080,7 @@
{
AEMU_SCOPED_TRACE("vkCmdSetScissor");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
}
static void entry_vkCmdSetLineWidth(
@@ -1082,6 +1089,7 @@
{
AEMU_SCOPED_TRACE("vkCmdSetLineWidth");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetLineWidth(commandBuffer, lineWidth);
}
static void entry_vkCmdSetDepthBias(
@@ -1092,6 +1100,7 @@
{
AEMU_SCOPED_TRACE("vkCmdSetDepthBias");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
}
static void entry_vkCmdSetBlendConstants(
@@ -1100,6 +1109,7 @@
{
AEMU_SCOPED_TRACE("vkCmdSetBlendConstants");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetBlendConstants(commandBuffer, blendConstants);
}
static void entry_vkCmdSetDepthBounds(
@@ -1109,6 +1119,7 @@
{
AEMU_SCOPED_TRACE("vkCmdSetDepthBounds");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
}
static void entry_vkCmdSetStencilCompareMask(
@@ -1118,6 +1129,7 @@
{
AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
}
static void entry_vkCmdSetStencilWriteMask(
@@ -1127,6 +1139,7 @@
{
AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
}
static void entry_vkCmdSetStencilReference(
@@ -1136,6 +1149,7 @@
{
AEMU_SCOPED_TRACE("vkCmdSetStencilReference");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetStencilReference(commandBuffer, faceMask, reference);
}
static void entry_vkCmdBindDescriptorSets(
@@ -1150,6 +1164,7 @@
{
AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
}
static void entry_vkCmdBindIndexBuffer(
@@ -1160,6 +1175,7 @@
{
AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
}
static void entry_vkCmdBindVertexBuffers(
@@ -1171,6 +1187,7 @@
{
AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
}
static void entry_vkCmdDraw(
@@ -1182,6 +1199,7 @@
{
AEMU_SCOPED_TRACE("vkCmdDraw");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
}
static void entry_vkCmdDrawIndexed(
@@ -1194,6 +1212,7 @@
{
AEMU_SCOPED_TRACE("vkCmdDrawIndexed");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
}
static void entry_vkCmdDrawIndirect(
@@ -1205,6 +1224,7 @@
{
AEMU_SCOPED_TRACE("vkCmdDrawIndirect");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
}
static void entry_vkCmdDrawIndexedIndirect(
@@ -1216,6 +1236,7 @@
{
AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
}
static void entry_vkCmdDispatch(
@@ -1226,6 +1247,7 @@
{
AEMU_SCOPED_TRACE("vkCmdDispatch");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
}
static void entry_vkCmdDispatchIndirect(
@@ -1235,6 +1257,7 @@
{
AEMU_SCOPED_TRACE("vkCmdDispatchIndirect");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDispatchIndirect(commandBuffer, buffer, offset);
}
static void entry_vkCmdCopyBuffer(
@@ -1246,6 +1269,7 @@
{
AEMU_SCOPED_TRACE("vkCmdCopyBuffer");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
}
static void entry_vkCmdCopyImage(
@@ -1259,6 +1283,7 @@
{
AEMU_SCOPED_TRACE("vkCmdCopyImage");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
static void entry_vkCmdBlitImage(
@@ -1273,6 +1298,7 @@
{
AEMU_SCOPED_TRACE("vkCmdBlitImage");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
}
static void entry_vkCmdCopyBufferToImage(
@@ -1285,6 +1311,7 @@
{
AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
}
static void entry_vkCmdCopyImageToBuffer(
@@ -1297,6 +1324,7 @@
{
AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
}
static void entry_vkCmdUpdateBuffer(
@@ -1308,6 +1336,7 @@
{
AEMU_SCOPED_TRACE("vkCmdUpdateBuffer");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
}
static void entry_vkCmdFillBuffer(
@@ -1319,6 +1348,7 @@
{
AEMU_SCOPED_TRACE("vkCmdFillBuffer");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
}
static void entry_vkCmdClearColorImage(
@@ -1331,6 +1361,7 @@
{
AEMU_SCOPED_TRACE("vkCmdClearColorImage");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
}
static void entry_vkCmdClearDepthStencilImage(
@@ -1343,6 +1374,7 @@
{
AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
}
static void entry_vkCmdClearAttachments(
@@ -1354,6 +1386,7 @@
{
AEMU_SCOPED_TRACE("vkCmdClearAttachments");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
}
static void entry_vkCmdResolveImage(
@@ -1367,6 +1400,7 @@
{
AEMU_SCOPED_TRACE("vkCmdResolveImage");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
static void entry_vkCmdSetEvent(
@@ -1376,6 +1410,7 @@
{
AEMU_SCOPED_TRACE("vkCmdSetEvent");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetEvent(commandBuffer, event, stageMask);
}
static void entry_vkCmdResetEvent(
@@ -1385,6 +1420,7 @@
{
AEMU_SCOPED_TRACE("vkCmdResetEvent");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdResetEvent(commandBuffer, event, stageMask);
}
static void entry_vkCmdWaitEvents(
@@ -1402,6 +1438,7 @@
{
AEMU_SCOPED_TRACE("vkCmdWaitEvents");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}
static void entry_vkCmdPipelineBarrier(
@@ -1418,6 +1455,7 @@
{
AEMU_SCOPED_TRACE("vkCmdPipelineBarrier");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}
static void entry_vkCmdBeginQuery(
@@ -1428,6 +1466,7 @@
{
AEMU_SCOPED_TRACE("vkCmdBeginQuery");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdBeginQuery(commandBuffer, queryPool, query, flags);
}
static void entry_vkCmdEndQuery(
@@ -1437,6 +1476,7 @@
{
AEMU_SCOPED_TRACE("vkCmdEndQuery");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdEndQuery(commandBuffer, queryPool, query);
}
static void entry_vkCmdResetQueryPool(
@@ -1447,6 +1487,7 @@
{
AEMU_SCOPED_TRACE("vkCmdResetQueryPool");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
}
static void entry_vkCmdWriteTimestamp(
@@ -1457,6 +1498,7 @@
{
AEMU_SCOPED_TRACE("vkCmdWriteTimestamp");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
}
static void entry_vkCmdCopyQueryPoolResults(
@@ -1471,6 +1513,7 @@
{
AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
}
static void entry_vkCmdPushConstants(
@@ -1483,6 +1526,7 @@
{
AEMU_SCOPED_TRACE("vkCmdPushConstants");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
}
static void entry_vkCmdBeginRenderPass(
@@ -1492,6 +1536,7 @@
{
AEMU_SCOPED_TRACE("vkCmdBeginRenderPass");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
}
static void entry_vkCmdNextSubpass(
@@ -1500,6 +1545,7 @@
{
AEMU_SCOPED_TRACE("vkCmdNextSubpass");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdNextSubpass(commandBuffer, contents);
}
static void entry_vkCmdEndRenderPass(
@@ -1507,6 +1553,7 @@
{
AEMU_SCOPED_TRACE("vkCmdEndRenderPass");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdEndRenderPass(commandBuffer);
}
static void entry_vkCmdExecuteCommands(
@@ -1516,6 +1563,7 @@
{
AEMU_SCOPED_TRACE("vkCmdExecuteCommands");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
}
#endif
@@ -1570,6 +1618,7 @@
{
AEMU_SCOPED_TRACE("vkCmdSetDeviceMask");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetDeviceMask(commandBuffer, deviceMask);
}
static void entry_vkCmdDispatchBase(
@@ -1583,6 +1632,7 @@
{
AEMU_SCOPED_TRACE("vkCmdDispatchBase");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
}
static VkResult entry_vkEnumeratePhysicalDeviceGroups(
@@ -1728,7 +1778,8 @@
{
AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion");
auto vkEnc = HostConnection::get()->vkEncoder();
- vkEnc->vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
+ auto resources = ResourceTracker::get();
+ resources->on_vkDestroySamplerYcbcrConversion(vkEnc, device, ycbcrConversion, pAllocator);
}
static VkResult entry_vkCreateDescriptorUpdateTemplate(
VkDevice device,
@@ -2288,6 +2339,7 @@
{
AEMU_SCOPED_TRACE("vkCmdSetDeviceMaskKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetDeviceMaskKHR(commandBuffer, deviceMask);
}
static void entry_vkCmdDispatchBaseKHR(
@@ -2301,6 +2353,7 @@
{
AEMU_SCOPED_TRACE("vkCmdDispatchBaseKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
}
#endif
@@ -2467,6 +2520,7 @@
{
AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
}
static void entry_vkCmdPushDescriptorSetWithTemplateKHR(
@@ -2478,6 +2532,7 @@
{
AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetWithTemplateKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
}
#endif
@@ -2538,6 +2593,7 @@
{
AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
}
static void entry_vkCmdNextSubpass2KHR(
@@ -2547,6 +2603,7 @@
{
AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
}
static void entry_vkCmdEndRenderPass2KHR(
@@ -2555,6 +2612,7 @@
{
AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo);
}
#endif
@@ -2766,7 +2824,8 @@
{
AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
- vkEnc->vkDestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator);
+ auto resources = ResourceTracker::get();
+ resources->on_vkDestroySamplerYcbcrConversionKHR(vkEnc, device, ycbcrConversion, pAllocator);
}
#endif
#ifdef VK_KHR_bind_memory2
@@ -2818,6 +2877,7 @@
{
AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}
static void entry_vkCmdDrawIndexedIndirectCountKHR(
@@ -2831,6 +2891,7 @@
{
AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountKHR");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}
#endif
@@ -2952,6 +3013,7 @@
{
AEMU_SCOPED_TRACE("vkCmdDebugMarkerBeginEXT");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
}
static void entry_vkCmdDebugMarkerEndEXT(
@@ -2959,6 +3021,7 @@
{
AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDebugMarkerEndEXT(commandBuffer);
}
static void entry_vkCmdDebugMarkerInsertEXT(
@@ -2967,6 +3030,7 @@
{
AEMU_SCOPED_TRACE("vkCmdDebugMarkerInsertEXT");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
}
#endif
@@ -2986,6 +3050,7 @@
{
AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountAMD");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}
static void entry_vkCmdDrawIndexedIndirectCountAMD(
@@ -2999,6 +3064,7 @@
{
AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountAMD");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}
#endif
@@ -3093,6 +3159,7 @@
{
AEMU_SCOPED_TRACE("vkCmdBeginConditionalRenderingEXT");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin);
}
static void entry_vkCmdEndConditionalRenderingEXT(
@@ -3100,6 +3167,7 @@
{
AEMU_SCOPED_TRACE("vkCmdEndConditionalRenderingEXT");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdEndConditionalRenderingEXT(commandBuffer);
}
#endif
@@ -3110,6 +3178,7 @@
{
AEMU_SCOPED_TRACE("vkCmdProcessCommandsNVX");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo);
}
static void entry_vkCmdReserveSpaceForCommandsNVX(
@@ -3118,6 +3187,7 @@
{
AEMU_SCOPED_TRACE("vkCmdReserveSpaceForCommandsNVX");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo);
}
static VkResult entry_vkCreateIndirectCommandsLayoutNVX(
@@ -3207,6 +3277,7 @@
{
AEMU_SCOPED_TRACE("vkCmdSetViewportWScalingNV");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings);
}
#endif
@@ -3354,6 +3425,7 @@
{
AEMU_SCOPED_TRACE("vkCmdSetDiscardRectangleEXT");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
}
#endif
@@ -3455,6 +3527,7 @@
{
AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
}
static void entry_vkCmdEndDebugUtilsLabelEXT(
@@ -3462,6 +3535,7 @@
{
AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdEndDebugUtilsLabelEXT(commandBuffer);
}
static void entry_vkCmdInsertDebugUtilsLabelEXT(
@@ -3470,6 +3544,7 @@
{
AEMU_SCOPED_TRACE("vkCmdInsertDebugUtilsLabelEXT");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
}
static VkResult entry_vkCreateDebugUtilsMessengerEXT(
@@ -3547,6 +3622,7 @@
{
AEMU_SCOPED_TRACE("vkCmdSetSampleLocationsEXT");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo);
}
static void entry_vkGetPhysicalDeviceMultisamplePropertiesEXT(
@@ -3646,6 +3722,7 @@
{
AEMU_SCOPED_TRACE("vkCmdWriteBufferMarkerAMD");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
}
#endif
@@ -3662,6 +3739,7 @@
{
AEMU_SCOPED_TRACE("vkCmdSetCheckpointNV");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker);
}
static void entry_vkGetQueueCheckpointDataNV(
@@ -3738,6 +3816,7 @@
{
AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkBeginCommandBufferAsyncGOOGLE(commandBuffer, pBeginInfo);
}
static void entry_vkEndCommandBufferAsyncGOOGLE(
@@ -3745,6 +3824,7 @@
{
AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkEndCommandBufferAsyncGOOGLE(commandBuffer);
}
static void entry_vkResetCommandBufferAsyncGOOGLE(
@@ -3753,8 +3833,47 @@
{
AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE");
auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
vkEnc->vkResetCommandBufferAsyncGOOGLE(commandBuffer, flags);
}
+static void entry_vkCommandBufferHostSyncGOOGLE(
+ VkCommandBuffer commandBuffer,
+ uint32_t needHostSync,
+ uint32_t sequenceNumber)
+{
+ AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE");
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
+ vkEnc->vkCommandBufferHostSyncGOOGLE(commandBuffer, needHostSync, sequenceNumber);
+}
+#endif
+#ifdef VK_GOOGLE_create_resources_with_requirements
+static VkResult entry_vkCreateImageWithRequirementsGOOGLE(
+ VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage,
+ VkMemoryRequirements* pMemoryRequirements)
+{
+ AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE");
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
+ vkCreateImageWithRequirementsGOOGLE_VkResult_return = vkEnc->vkCreateImageWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pImage, pMemoryRequirements);
+ return vkCreateImageWithRequirementsGOOGLE_VkResult_return;
+}
+static VkResult entry_vkCreateBufferWithRequirementsGOOGLE(
+ VkDevice device,
+ const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer,
+ VkMemoryRequirements* pMemoryRequirements)
+{
+ AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE");
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
+ vkCreateBufferWithRequirementsGOOGLE_VkResult_return = vkEnc->vkCreateBufferWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pBuffer, pMemoryRequirements);
+ return vkCreateBufferWithRequirementsGOOGLE_VkResult_return;
+}
#endif
void* goldfish_vulkan_get_proc_address(const char* name){
#ifdef VK_VERSION_1_0
@@ -5186,6 +5305,20 @@
{
return nullptr;
}
+ if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE"))
+ {
+ return nullptr;
+ }
+#endif
+#ifdef VK_GOOGLE_create_resources_with_requirements
+ if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE"))
+ {
+ return nullptr;
+ }
+ if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE"))
+ {
+ return nullptr;
+ }
#endif
return nullptr;
}
@@ -6780,6 +6913,23 @@
bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_async_command_buffers");
return hasExt ? (void*)entry_vkResetCommandBufferAsyncGOOGLE : nullptr;
}
+ if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE"))
+ {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_async_command_buffers");
+ return hasExt ? (void*)entry_vkCommandBufferHostSyncGOOGLE : nullptr;
+ }
+#endif
+#ifdef VK_GOOGLE_create_resources_with_requirements
+ if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE"))
+ {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_create_resources_with_requirements");
+ return hasExt ? (void*)entry_vkCreateImageWithRequirementsGOOGLE : nullptr;
+ }
+ if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE"))
+ {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_create_resources_with_requirements");
+ return hasExt ? (void*)entry_vkCreateBufferWithRequirementsGOOGLE : nullptr;
+ }
#endif
return nullptr;
}
@@ -8374,6 +8524,23 @@
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_async_command_buffers");
return hasExt ? (void*)entry_vkResetCommandBufferAsyncGOOGLE : nullptr;
}
+ if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE"))
+ {
+ bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_async_command_buffers");
+ return hasExt ? (void*)entry_vkCommandBufferHostSyncGOOGLE : nullptr;
+ }
+#endif
+#ifdef VK_GOOGLE_create_resources_with_requirements
+ if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE"))
+ {
+ bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_create_resources_with_requirements");
+ return hasExt ? (void*)entry_vkCreateImageWithRequirementsGOOGLE : nullptr;
+ }
+ if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE"))
+ {
+ bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_create_resources_with_requirements");
+ return hasExt ? (void*)entry_vkCreateBufferWithRequirementsGOOGLE : nullptr;
+ }
#endif
return nullptr;
}
diff --git a/system/vulkan/func_table.h b/system/vulkan/func_table.h
index 4d0e977..05658cf 100644
--- a/system/vulkan/func_table.h
+++ b/system/vulkan/func_table.h
@@ -284,6 +284,8 @@
#endif
#ifdef VK_GOOGLE_async_command_buffers
#endif
+#ifdef VK_GOOGLE_create_resources_with_requirements
+#endif
void* goldfish_vulkan_get_proc_address(const char* name);
void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char* name);
void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name);
diff --git a/system/vulkan/goldfish_vulkan.cpp b/system/vulkan/goldfish_vulkan.cpp
index c694ff8..dd73ca6 100644
--- a/system/vulkan/goldfish_vulkan.cpp
+++ b/system/vulkan/goldfish_vulkan.cpp
@@ -27,19 +27,10 @@
#include "func_table.h"
-#include <array>
-#include <bitset>
-#include <mutex>
-
// Used when there is no Vulkan support on the host.
// Copied from frameworks/native/vulkan/libvulkan/stubhal.cpp
namespace vkstubhal {
-const size_t kMaxInstances = 32;
-static std::mutex g_instance_mutex;
-static std::bitset<kMaxInstances> g_instance_used(false);
-static std::array<hwvulkan_dispatch_t, kMaxInstances> g_instances;
-
[[noreturn]] VKAPI_ATTR void NoOp() {
LOG_ALWAYS_FATAL("invalid stub function called");
}
@@ -65,28 +56,19 @@
const VkAllocationCallbacks* /*allocator*/,
VkInstance* instance) {
AEMU_SCOPED_TRACE("vkstubhal::CreateInstance");
- std::lock_guard<std::mutex> lock(g_instance_mutex);
- for (size_t i = 0; i < kMaxInstances; i++) {
- if (!g_instance_used[i]) {
- g_instance_used[i] = true;
- g_instances[i].magic = HWVULKAN_DISPATCH_MAGIC;
- *instance = reinterpret_cast<VkInstance>(&g_instances[i]);
- return VK_SUCCESS;
- }
- }
- ALOGE("no more instances available (max=%zu)", kMaxInstances);
- return VK_ERROR_INITIALIZATION_FAILED;
+ auto dispatch = new hwvulkan_dispatch_t;
+ dispatch->magic = HWVULKAN_DISPATCH_MAGIC;
+ *instance = reinterpret_cast<VkInstance>(dispatch);
+ return VK_SUCCESS;
}
void DestroyInstance(VkInstance instance,
const VkAllocationCallbacks* /*allocator*/) {
AEMU_SCOPED_TRACE("vkstubhal::DestroyInstance");
- std::lock_guard<std::mutex> lock(g_instance_mutex);
- ssize_t idx =
- reinterpret_cast<hwvulkan_dispatch_t*>(instance) - &g_instances[0];
- ALOG_ASSERT(idx >= 0 && static_cast<size_t>(idx) < g_instance_used.size(),
+ auto dispatch = reinterpret_cast<hwvulkan_dispatch_t*>(instance);
+ ALOG_ASSERT(dispatch->magic == HWVULKAN_DISPATCH_MAGIC,
"DestroyInstance: invalid instance handle");
- g_instance_used[static_cast<size_t>(idx)] = false;
+ delete dispatch;
}
VkResult EnumeratePhysicalDevices(VkInstance /*instance*/,
@@ -137,6 +119,33 @@
AEMU_SCOPED_TRACE("vkstubhal::DebugReportMessageEXT");
}
+VkResult
+CreateDebugUtilsMessengerEXT(VkInstance /*instance*/,
+ const VkDebugUtilsMessengerCreateInfoEXT* /*pCreateInfo*/,
+ const VkAllocationCallbacks* /*pAllocator*/,
+ VkDebugUtilsMessengerEXT* /*pMessenger*/)
+{
+ AEMU_SCOPED_TRACE("vkstubhal::CreateDebugUtilsMessengerEXT");
+ return VK_SUCCESS;
+}
+
+void
+DestroyDebugUtilsMessengerEXT(VkInstance /*instance*/,
+ VkDebugUtilsMessengerEXT /*messenger*/,
+ const VkAllocationCallbacks* /*pAllocator*/)
+{
+ AEMU_SCOPED_TRACE("vkstubhal::DestroyDebugUtilsMessengerkEXT");
+}
+
+void
+SubmitDebugUtilsMessageEXT(VkInstance /*instance*/,
+ VkDebugUtilsMessageSeverityFlagBitsEXT /*messageSeverity*/,
+ VkDebugUtilsMessageTypeFlagsEXT /*messageTypes*/,
+ const VkDebugUtilsMessengerCallbackDataEXT* /*pCallbackData*/)
+{
+ AEMU_SCOPED_TRACE("vkstubhal::SubmitDebugUtilsMessageEXT");
+}
+
#ifdef VK_USE_PLATFORM_FUCHSIA
VkResult
GetMemoryZirconHandleFUCHSIA(VkDevice /*device*/,
@@ -231,6 +240,12 @@
return reinterpret_cast<PFN_vkVoidFunction>(DestroyDebugReportCallbackEXT);
if (strcmp(name, "vkDebugReportMessageEXT") == 0)
return reinterpret_cast<PFN_vkVoidFunction>(DebugReportMessageEXT);
+ if (strcmp(name, "vkCreateDebugUtilsMessengerEXT") == 0)
+ return reinterpret_cast<PFN_vkVoidFunction>(CreateDebugUtilsMessengerEXT);
+ if (strcmp(name, "vkDestroyDebugUtilsMessengerEXT") == 0)
+ return reinterpret_cast<PFN_vkVoidFunction>(DestroyDebugUtilsMessengerEXT);
+ if (strcmp(name, "vkSubmitDebugUtilsMessageEXT") == 0)
+ return reinterpret_cast<PFN_vkVoidFunction>(SubmitDebugUtilsMessageEXT);
#ifdef VK_USE_PLATFORM_FUCHSIA
if (strcmp(name, "vkGetMemoryZirconHandleFUCHSIA") == 0)
return reinterpret_cast<PFN_vkVoidFunction>(GetMemoryZirconHandleFUCHSIA);
@@ -300,13 +315,13 @@
ALOGE("vulkan: Failed to get renderControl encoder context\n"); \
return ret; \
} \
+ goldfish_vk::ResourceTracker::get()->setupFeatures(rcEnc->featureInfo_const()); \
+ auto hostSupportsVulkan = goldfish_vk::ResourceTracker::get()->hostSupportsVulkan(); \
goldfish_vk::VkEncoder *vkEnc = hostCon->vkEncoder(); \
if (!vkEnc) { \
ALOGE("vulkan: Failed to get Vulkan encoder\n"); \
return ret; \
} \
- goldfish_vk::ResourceTracker::get()->setupFeatures(rcEnc->featureInfo_const()); \
- auto hostSupportsVulkan = goldfish_vk::ResourceTracker::get()->hostSupportsVulkan(); \
VKAPI_ATTR
VkResult EnumerateInstanceExtensionProperties(
diff --git a/system/vulkan_enc/ResourceTracker.cpp b/system/vulkan_enc/ResourceTracker.cpp
index f88abde..2663c65 100644
--- a/system/vulkan_enc/ResourceTracker.cpp
+++ b/system/vulkan_enc/ResourceTracker.cpp
@@ -235,7 +235,6 @@
std::vector<HostMemBlocks> hostMemBlocks { VK_MAX_MEMORY_TYPES };
uint32_t apiVersion;
std::set<std::string> enabledExtensions;
- VkFence fence = VK_NULL_HANDLE;
};
struct VkDeviceMemory_Info {
@@ -252,6 +251,11 @@
zx_handle_t vmoHandle = ZX_HANDLE_INVALID;
};
+ struct VkCommandBuffer_Info {
+ VkEncoder** lastUsedEncoderPtr = nullptr;
+ uint32_t sequenceNumber = 0;
+ };
+
// custom guest-side structs for images/buffers because of AHardwareBuffer :((
struct VkImage_Info {
VkDevice device;
@@ -261,6 +265,8 @@
VkDeviceMemory currentBacking = VK_NULL_HANDLE;
VkDeviceSize currentBackingOffset = 0;
VkDeviceSize currentBackingSize = 0;
+ bool baseRequirementsKnown = false;
+ VkMemoryRequirements baseRequirements;
};
struct VkBuffer_Info {
@@ -271,6 +277,8 @@
VkDeviceMemory currentBacking = VK_NULL_HANDLE;
VkDeviceSize currentBackingOffset = 0;
VkDeviceSize currentBackingSize = 0;
+ bool baseRequirementsKnown = false;
+ VkMemoryRequirements baseRequirements;
};
struct VkSemaphore_Info {
@@ -327,6 +335,24 @@
lock.unlock();
}
+ void unregister_VkCommandBuffer(VkCommandBuffer commandBuffer) {
+ AutoLock lock(mLock);
+
+ auto it = info_VkCommandBuffer.find(commandBuffer);
+ if (it == info_VkCommandBuffer.end()) return;
+ auto& info = it->second;
+ auto lastUsedEncoder =
+ info.lastUsedEncoderPtr ?
+ *(info.lastUsedEncoderPtr) : nullptr;
+
+ if (lastUsedEncoder) {
+ lastUsedEncoder->unregisterCleanupCallback(commandBuffer);
+ delete info.lastUsedEncoderPtr;
+ }
+
+ info_VkCommandBuffer.erase(commandBuffer);
+ }
+
void unregister_VkDeviceMemory(VkDeviceMemory mem) {
AutoLock lock(mLock);
@@ -564,6 +590,10 @@
}
}
#endif
+
+ if (mFeatureInfo->hasVulkanNullOptionalStrings) {
+ mStreamFeatureBits |= VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT;
+ }
}
bool hostSupportsVulkan() const {
@@ -576,11 +606,20 @@
return mHostVisibleMemoryVirtInfo.virtualizationSupported;
}
+ uint32_t getStreamFeatures() const {
+ return mStreamFeatureBits;
+ }
+
bool supportsDeferredCommands() const {
if (!mFeatureInfo) return false;
return mFeatureInfo->hasDeferredVulkanCommands;
}
+ bool supportsCreateResourcesWithRequirements() const {
+ if (!mFeatureInfo) return false;
+ return mFeatureInfo->hasVulkanCreateResourcesWithRequirements;
+ }
+
int getHostInstanceExtensionIndex(const std::string& extName) const {
int i = 0;
for (const auto& prop : mHostInstanceExtensions) {
@@ -879,9 +918,12 @@
bool posixExtMemAvailable =
getHostDeviceExtensionIndex(
"VK_KHR_external_memory_fd") != -1;
+ bool extMoltenVkAvailable =
+ getHostDeviceExtensionIndex(
+ "VK_MVK_moltenvk") != -1;
bool hostHasExternalMemorySupport =
- win32ExtMemAvailable || posixExtMemAvailable;
+ win32ExtMemAvailable || posixExtMemAvailable || extMoltenVkAvailable;
if (hostHasExternalMemorySupport) {
#ifdef VK_USE_PLATFORM_ANDROID_KHR
@@ -1069,10 +1111,6 @@
destroyHostMemAlloc(enc, device, &block);
}
}
-
- if (info.fence != VK_NULL_HANDLE) {
- enc->vkDestroyFence(device, info.fence, nullptr);
- }
}
VkResult on_vkGetAndroidHardwareBufferPropertiesANDROID(
@@ -1298,7 +1336,7 @@
fuchsia::sysmem::vulkanUsageTransferSrc |
fuchsia::sysmem::vulkanUsageTransferDst |
fuchsia::sysmem::vulkanUsageSampled;
- constraints.min_buffer_count_for_camping = 1;
+ constraints.min_buffer_count = 1;
constraints.has_buffer_memory_constraints = true;
fuchsia::sysmem::BufferMemoryConstraints& buffer_constraints =
constraints.buffer_memory_constraints;
@@ -2031,12 +2069,10 @@
dedicatedReqs->requiresDedicatedAllocation = VK_TRUE;
}
- void transformImageMemoryRequirementsForGuest(
+ void transformImageMemoryRequirementsForGuestLocked(
VkImage image,
VkMemoryRequirements* reqs) {
- AutoLock lock(mLock);
-
auto it = info_VkImage.find(image);
if (it == info_VkImage.end()) return;
@@ -2051,12 +2087,10 @@
transformExternalResourceMemoryRequirementsForGuest(reqs);
}
- void transformBufferMemoryRequirementsForGuest(
+ void transformBufferMemoryRequirementsForGuestLocked(
VkBuffer buffer,
VkMemoryRequirements* reqs) {
- AutoLock lock(mLock);
-
auto it = info_VkBuffer.find(buffer);
if (it == info_VkBuffer.end()) return;
@@ -2207,22 +2241,16 @@
}
}
}
-
- // Allow external memory for all color attachments on fuchsia.
- // Note: This causes external to be set to true below. The result
- // is that a dedicated memory allocation is required for the image,
- // which allows the memory to be exported.
- if (localCreateInfo.usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) {
- if (!extImgCiPtr) {
- localExtImgCi.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
- localExtImgCi.pNext = nullptr;
- localExtImgCi.handleTypes = ~0; // handle type just needs to be non-zero
- extImgCiPtr = &localExtImgCi; // no vk_append_struct required
- }
- }
#endif
- VkResult res = enc->vkCreateImage(device, &localCreateInfo, pAllocator, pImage);
+ VkResult res;
+ VkMemoryRequirements memReqs;
+
+ if (supportsCreateResourcesWithRequirements()) {
+ res = enc->vkCreateImageWithRequirementsGOOGLE(device, &localCreateInfo, pAllocator, pImage, &memReqs);
+ } else {
+ res = enc->vkCreateImage(device, &localCreateInfo, pAllocator, pImage);
+ }
if (res != VK_SUCCESS) return res;
@@ -2237,10 +2265,19 @@
info.createInfo = *pCreateInfo;
info.createInfo.pNext = nullptr;
- if (!extImgCiPtr) return res;
+ if (supportsCreateResourcesWithRequirements()) {
+ info.baseRequirementsKnown = true;
+ }
- info.external = true;
- info.externalCreateInfo = *extImgCiPtr;
+ if (extImgCiPtr) {
+ info.external = true;
+ info.externalCreateInfo = *extImgCiPtr;
+ }
+
+ if (info.baseRequirementsKnown) {
+ transformImageMemoryRequirementsForGuestLocked(*pImage, &memReqs);
+ info.baseRequirements = memReqs;
+ }
return res;
}
@@ -2258,7 +2295,15 @@
const VkExternalFormatANDROID* extFormatAndroidPtr =
vk_find_struct<VkExternalFormatANDROID>(pCreateInfo);
if (extFormatAndroidPtr) {
- if (extFormatAndroidPtr->externalFormat) {
+ if (extFormatAndroidPtr->externalFormat == AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM) {
+ // We don't support external formats on host and it causes RGB565
+ // to fail in CtsGraphicsTestCases android.graphics.cts.BasicVulkanGpuTest
+ // when passed as an external format.
+ // We may consider doing this for all external formats.
+ // See b/134771579.
+ *pYcbcrConversion = VK_YCBCR_CONVERSION_DO_NOTHING;
+ return VK_SUCCESS;
+ } else if (extFormatAndroidPtr->externalFormat) {
localCreateInfo.format =
vk_format_from_android(extFormatAndroidPtr->externalFormat);
}
@@ -2266,8 +2311,25 @@
#endif
VkEncoder* enc = (VkEncoder*)context;
- return enc->vkCreateSamplerYcbcrConversion(
+ VkResult res = enc->vkCreateSamplerYcbcrConversion(
device, &localCreateInfo, pAllocator, pYcbcrConversion);
+
+ if (*pYcbcrConversion == VK_YCBCR_CONVERSION_DO_NOTHING) {
+ ALOGE("FATAL: vkCreateSamplerYcbcrConversion returned a reserved value (VK_YCBCR_CONVERSION_DO_NOTHING)");
+ abort();
+ }
+ return res;
+ }
+
+ void on_vkDestroySamplerYcbcrConversion(
+ void* context,
+ VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator) {
+ VkEncoder* enc = (VkEncoder*)context;
+ if (ycbcrConversion != VK_YCBCR_CONVERSION_DO_NOTHING) {
+ enc->vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
+ }
}
VkResult on_vkCreateSamplerYcbcrConversionKHR(
@@ -2283,7 +2345,15 @@
const VkExternalFormatANDROID* extFormatAndroidPtr =
vk_find_struct<VkExternalFormatANDROID>(pCreateInfo);
if (extFormatAndroidPtr) {
- if (extFormatAndroidPtr->externalFormat) {
+ if (extFormatAndroidPtr->externalFormat == AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM) {
+ // We don't support external formats on host and it causes RGB565
+ // to fail in CtsGraphicsTestCases android.graphics.cts.BasicVulkanGpuTest
+ // when passed as an external format.
+ // We may consider doing this for all external formats.
+ // See b/134771579.
+ *pYcbcrConversion = VK_YCBCR_CONVERSION_DO_NOTHING;
+ return VK_SUCCESS;
+ } else if (extFormatAndroidPtr->externalFormat) {
localCreateInfo.format =
vk_format_from_android(extFormatAndroidPtr->externalFormat);
}
@@ -2291,8 +2361,51 @@
#endif
VkEncoder* enc = (VkEncoder*)context;
- return enc->vkCreateSamplerYcbcrConversionKHR(
+ VkResult res = enc->vkCreateSamplerYcbcrConversionKHR(
device, &localCreateInfo, pAllocator, pYcbcrConversion);
+
+ if (*pYcbcrConversion == VK_YCBCR_CONVERSION_DO_NOTHING) {
+ ALOGE("FATAL: vkCreateSamplerYcbcrConversionKHR returned a reserved value (VK_YCBCR_CONVERSION_DO_NOTHING)");
+ abort();
+ }
+ return res;
+ }
+
+ void on_vkDestroySamplerYcbcrConversionKHR(
+ void* context,
+ VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator) {
+ VkEncoder* enc = (VkEncoder*)context;
+ if (ycbcrConversion != VK_YCBCR_CONVERSION_DO_NOTHING) {
+ enc->vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
+ }
+ }
+
+ VkResult on_vkCreateSampler(
+ void* context, VkResult,
+ VkDevice device,
+ const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSampler* pSampler) {
+
+ VkSamplerCreateInfo localCreateInfo = vk_make_orphan_copy(*pCreateInfo);
+ vk_struct_chain_iterator structChainIter = vk_make_chain_iterator(&localCreateInfo);
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ VkSamplerYcbcrConversionInfo localVkSamplerYcbcrConversionInfo;
+ const VkSamplerYcbcrConversionInfo* samplerYcbcrConversionInfo =
+ vk_find_struct<VkSamplerYcbcrConversionInfo>(pCreateInfo);
+ if (samplerYcbcrConversionInfo) {
+ if (samplerYcbcrConversionInfo->conversion != VK_YCBCR_CONVERSION_DO_NOTHING) {
+ localVkSamplerYcbcrConversionInfo = vk_make_orphan_copy(*samplerYcbcrConversionInfo);
+ vk_append_struct(&structChainIter, &localVkSamplerYcbcrConversionInfo);
+ }
+ }
+#endif
+
+ VkEncoder* enc = (VkEncoder*)context;
+ return enc->vkCreateSampler(device, &localCreateInfo, pAllocator, pSampler);
}
void on_vkDestroyImage(
@@ -2305,11 +2418,32 @@
void on_vkGetImageMemoryRequirements(
void *context, VkDevice device, VkImage image,
VkMemoryRequirements *pMemoryRequirements) {
+
+ AutoLock lock(mLock);
+
+ auto it = info_VkImage.find(image);
+ if (it == info_VkImage.end()) return;
+
+ auto& info = it->second;
+
+ if (info.baseRequirementsKnown) {
+ *pMemoryRequirements = info.baseRequirements;
+ return;
+ }
+
+ lock.unlock();
+
VkEncoder* enc = (VkEncoder*)context;
+
enc->vkGetImageMemoryRequirements(
device, image, pMemoryRequirements);
- transformImageMemoryRequirementsForGuest(
+
+ lock.lock();
+
+ transformImageMemoryRequirementsForGuestLocked(
image, pMemoryRequirements);
+ info.baseRequirementsKnown = true;
+ info.baseRequirements = *pMemoryRequirements;
}
void on_vkGetImageMemoryRequirements2(
@@ -2361,7 +2495,14 @@
VkBuffer *pBuffer) {
VkEncoder* enc = (VkEncoder*)context;
- VkResult res = enc->vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
+ VkResult res;
+ VkMemoryRequirements memReqs;
+
+ if (supportsCreateResourcesWithRequirements()) {
+ res = enc->vkCreateBufferWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pBuffer, &memReqs);
+ } else {
+ res = enc->vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
+ }
if (res != VK_SUCCESS) return res;
@@ -2375,13 +2516,22 @@
info.createInfo = *pCreateInfo;
info.createInfo.pNext = nullptr;
+ if (supportsCreateResourcesWithRequirements()) {
+ info.baseRequirementsKnown = true;
+ }
+
const VkExternalMemoryBufferCreateInfo* extBufCi =
vk_find_struct<VkExternalMemoryBufferCreateInfo>(pCreateInfo);
- if (!extBufCi) return res;
+ if (extBufCi) {
+ info.external = true;
+ info.externalCreateInfo = *extBufCi;
+ }
- info.external = true;
- info.externalCreateInfo = *extBufCi;
+ if (info.baseRequirementsKnown) {
+ transformBufferMemoryRequirementsForGuestLocked(*pBuffer, &memReqs);
+ info.baseRequirements = memReqs;
+ }
return res;
}
@@ -2395,11 +2545,31 @@
void on_vkGetBufferMemoryRequirements(
void* context, VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements) {
+
+ AutoLock lock(mLock);
+
+ auto it = info_VkBuffer.find(buffer);
+ if (it == info_VkBuffer.end()) return;
+
+ auto& info = it->second;
+
+ if (info.baseRequirementsKnown) {
+ *pMemoryRequirements = info.baseRequirements;
+ return;
+ }
+
+ lock.unlock();
+
VkEncoder* enc = (VkEncoder*)context;
enc->vkGetBufferMemoryRequirements(
device, buffer, pMemoryRequirements);
- transformBufferMemoryRequirementsForGuest(
+
+ lock.lock();
+
+ transformBufferMemoryRequirementsForGuestLocked(
buffer, pMemoryRequirements);
+ info.baseRequirementsKnown = true;
+ info.baseRequirements = *pMemoryRequirements;
}
void on_vkGetBufferMemoryRequirements2(
@@ -2632,8 +2802,6 @@
std::vector<VkSemaphore> pre_signal_semaphores;
std::vector<zx_handle_t> post_wait_events;
std::vector<int> post_wait_sync_fds;
- VkDevice device = VK_NULL_HANDLE;
- VkFence* pFence = nullptr;
VkEncoder* enc = (VkEncoder*)context;
@@ -2670,15 +2838,11 @@
#ifdef VK_USE_PLATFORM_FUCHSIA
if (semInfo.eventHandle) {
post_wait_events.push_back(semInfo.eventHandle);
- device = semInfo.device;
- pFence = &info_VkDevice[device].fence;
}
#endif
#ifdef VK_USE_PLATFORM_ANDROID_KHR
if (semInfo.syncFd >= 0) {
post_wait_sync_fds.push_back(semInfo.syncFd);
- device = semInfo.device;
- pFence = &info_VkDevice[device].fence;
}
#endif
}
@@ -2701,20 +2865,9 @@
if (input_result != VK_SUCCESS) return input_result;
- if (post_wait_events.empty())
- return VK_SUCCESS;
-
- if (*pFence == VK_NULL_HANDLE) {
- VkFenceCreateInfo fence_create_info = {
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, 0, 0,
- };
- enc->vkCreateFence(device, &fence_create_info, nullptr, pFence);
+ if (!post_wait_events.empty() || !post_wait_sync_fds.empty()) {
+ enc->vkQueueWaitIdle(queue);
}
- enc->vkQueueSubmit(queue, 0, nullptr, *pFence);
- static constexpr uint64_t MAX_WAIT_NS =
- 5ULL * 1000ULL * 1000ULL * 1000ULL;
- enc->vkWaitForFences(device, 1, pFence, VK_TRUE, MAX_WAIT_NS);
- enc->vkResetFences(device, 1, pFence);
#ifdef VK_USE_PLATFORM_FUCHSIA
for (auto& event : post_wait_events) {
@@ -3082,6 +3235,48 @@
physicalDevice, pImageFormatInfo, pImageFormatProperties);
}
+ uint32_t syncEncodersForCommandBuffer(VkCommandBuffer commandBuffer, VkEncoder* currentEncoder) {
+ AutoLock lock(mLock);
+
+ auto it = info_VkCommandBuffer.find(commandBuffer);
+ if (it == info_VkCommandBuffer.end()) return 0;
+
+ auto& info = it->second;
+
+ if (!info.lastUsedEncoderPtr) {
+ info.lastUsedEncoderPtr = new VkEncoder*;
+ *(info.lastUsedEncoderPtr) = currentEncoder;
+ }
+
+ auto lastUsedEncoderPtr = info.lastUsedEncoderPtr;
+
+ auto lastEncoder = *(lastUsedEncoderPtr);
+
+ // We always make lastUsedEncoderPtr track
+ // the current encoder, even if the last encoder
+ // is null.
+ *(lastUsedEncoderPtr) = currentEncoder;
+
+ if (!lastEncoder) return 0;
+ if (lastEncoder == currentEncoder) return 0;
+
+ info.sequenceNumber++;
+ lastEncoder->vkCommandBufferHostSyncGOOGLE(commandBuffer, false, info.sequenceNumber);
+ lastEncoder->flush();
+ info.sequenceNumber++;
+ currentEncoder->vkCommandBufferHostSyncGOOGLE(commandBuffer, true, info.sequenceNumber);
+
+ lastEncoder->unregisterCleanupCallback(commandBuffer);
+
+ currentEncoder->registerCleanupCallback(commandBuffer, [currentEncoder, lastUsedEncoderPtr]() {
+ if (*(lastUsedEncoderPtr) == currentEncoder) {
+ *(lastUsedEncoderPtr) = nullptr;
+ }
+ });
+
+ return 1;
+ }
+
VkResult on_vkBeginCommandBuffer(
void* context, VkResult input_result,
VkCommandBuffer commandBuffer,
@@ -3095,6 +3290,7 @@
}
enc->vkBeginCommandBufferAsyncGOOGLE(commandBuffer, pBeginInfo);
+
return VK_SUCCESS;
}
@@ -3110,6 +3306,7 @@
}
enc->vkEndCommandBufferAsyncGOOGLE(commandBuffer);
+
return VK_SUCCESS;
}
@@ -3204,6 +3401,7 @@
mutable Lock mLock;
HostVisibleMemoryVirtualizationInfo mHostVisibleMemoryVirtInfo;
std::unique_ptr<EmulatorFeatureInfo> mFeatureInfo;
+ uint32_t mStreamFeatureBits = 0;
std::unique_ptr<GoldfishAddressSpaceBlockProvider> mGoldfishAddressSpaceBlockProvider;
std::vector<VkExtensionProperties> mHostInstanceExtensions;
@@ -3284,6 +3482,10 @@
return mImpl->usingDirectMapping();
}
+uint32_t ResourceTracker::getStreamFeatures() const {
+ return mImpl->getStreamFeatures();
+}
+
uint32_t ResourceTracker::getApiVersionFromInstance(VkInstance instance) const {
return mImpl->getApiVersionFromInstance(instance);
}
@@ -3690,6 +3892,15 @@
context, input_result, device, pCreateInfo, pAllocator, pYcbcrConversion);
}
+void ResourceTracker::on_vkDestroySamplerYcbcrConversion(
+ void* context,
+ VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator) {
+ mImpl->on_vkDestroySamplerYcbcrConversion(
+ context, device, ycbcrConversion, pAllocator);
+}
+
VkResult ResourceTracker::on_vkCreateSamplerYcbcrConversionKHR(
void* context, VkResult input_result,
VkDevice device,
@@ -3700,6 +3911,25 @@
context, input_result, device, pCreateInfo, pAllocator, pYcbcrConversion);
}
+void ResourceTracker::on_vkDestroySamplerYcbcrConversionKHR(
+ void* context,
+ VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator) {
+ mImpl->on_vkDestroySamplerYcbcrConversionKHR(
+ context, device, ycbcrConversion, pAllocator);
+}
+
+VkResult ResourceTracker::on_vkCreateSampler(
+ void* context, VkResult input_result,
+ VkDevice device,
+ const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSampler* pSampler) {
+ return mImpl->on_vkCreateSampler(
+ context, input_result, device, pCreateInfo, pAllocator, pSampler);
+}
+
VkResult ResourceTracker::on_vkMapMemoryIntoAddressSpaceGOOGLE_pre(
void* context,
VkResult input_result,
@@ -3773,6 +4003,10 @@
pImageFormatProperties);
}
+uint32_t ResourceTracker::syncEncodersForCommandBuffer(VkCommandBuffer commandBuffer, VkEncoder* current) {
+ return mImpl->syncEncodersForCommandBuffer(commandBuffer, current);
+}
+
VkResult ResourceTracker::on_vkBeginCommandBuffer(
void* context, VkResult input_result,
VkCommandBuffer commandBuffer,
diff --git a/system/vulkan_enc/ResourceTracker.h b/system/vulkan_enc/ResourceTracker.h
index 6429d6f..f8e3270 100644
--- a/system/vulkan_enc/ResourceTracker.h
+++ b/system/vulkan_enc/ResourceTracker.h
@@ -28,6 +28,8 @@
namespace goldfish_vk {
+class VkEncoder;
+
class ResourceTracker {
public:
ResourceTracker();
@@ -269,12 +271,29 @@
const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSamplerYcbcrConversion* pYcbcrConversion);
+ void on_vkDestroySamplerYcbcrConversion(
+ void* context,
+ VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator);
VkResult on_vkCreateSamplerYcbcrConversionKHR(
void* context, VkResult input_result,
VkDevice device,
const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSamplerYcbcrConversion* pYcbcrConversion);
+ void on_vkDestroySamplerYcbcrConversionKHR(
+ void* context,
+ VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator);
+
+ VkResult on_vkCreateSampler(
+ void* context, VkResult input_result,
+ VkDevice device,
+ const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSampler* pSampler);
VkResult on_vkMapMemoryIntoAddressSpaceGOOGLE_pre(
void* context,
@@ -322,6 +341,8 @@
const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
VkImageFormatProperties2* pImageFormatProperties);
+ uint32_t syncEncodersForCommandBuffer(VkCommandBuffer commandBuffer, VkEncoder* current);
+
VkResult on_vkBeginCommandBuffer(
void* context, VkResult input_result,
VkCommandBuffer commandBuffer,
@@ -349,6 +370,7 @@
void setupFeatures(const EmulatorFeatureInfo* features);
bool hostSupportsVulkan() const;
bool usingDirectMapping() const;
+ uint32_t getStreamFeatures() const;
uint32_t getApiVersionFromInstance(VkInstance instance) const;
uint32_t getApiVersionFromDevice(VkDevice device) const;
bool hasInstanceExtension(VkInstance instance, const std::string& name) const;
diff --git a/system/vulkan_enc/VkEncoder.cpp b/system/vulkan_enc/VkEncoder.cpp
index 42487ea..6f43f7a 100644
--- a/system/vulkan_enc/VkEncoder.cpp
+++ b/system/vulkan_enc/VkEncoder.cpp
@@ -33,6 +33,7 @@
#include "android/base/AlignedBuf.h"
#include "android/base/Pool.h"
+#include "android/base/synchronization/AndroidLock.h"
#include <cutils/properties.h>
@@ -42,6 +43,9 @@
#include "goldfish_vk_private_defs.h"
#include "goldfish_vk_transform_guest.h"
+#include <unordered_map>
+
+
namespace goldfish_vk {
@@ -51,6 +55,8 @@
using android::aligned_buf_alloc;
using android::aligned_buf_free;
+using android::base::guest::AutoLock;
+using android::base::guest::Lock;
using android::base::Pool;
class VkEncoder::Impl {
@@ -62,6 +68,14 @@
m_logEncodes = atoi(encodeProp) > 0;
}
}
+
+ ~Impl() {
+ for (auto it : mCleanupCallbacks) {
+ fprintf(stderr, "%s: run cleanup callback for %p\n", __func__, it.first);
+ it.second();
+ }
+ }
+
VulkanCountingStream* countingStream() { return &m_countingStream; }
VulkanStreamGuest* stream() { return &m_stream; }
Pool* pool() { return &m_pool; }
@@ -72,6 +86,27 @@
if (!m_logEncodes) return;
ALOGD("encoder log: %s", text);
}
+
+ void flush() {
+ AutoLock encoderLock(lock);
+ m_stream.flush();
+ }
+
+ // Assume the lock for the current encoder is held.
+ void registerCleanupCallback(void* handle, VkEncoder::CleanupCallback cb) {
+ if (mCleanupCallbacks.end() == mCleanupCallbacks.find(handle)) {
+ mCleanupCallbacks[handle] = cb;
+ } else {
+ return;
+ }
+ }
+
+ void unregisterCleanupCallback(void* handle) {
+ mCleanupCallbacks.erase(handle);
+ }
+
+ Lock lock;
+
private:
VulkanCountingStream m_countingStream;
VulkanStreamGuest m_stream;
@@ -79,11 +114,25 @@
Validation m_validation;
bool m_logEncodes;
+
+ std::unordered_map<void*, VkEncoder::CleanupCallback> mCleanupCallbacks;
};
VkEncoder::VkEncoder(IOStream *stream) :
mImpl(new VkEncoder::Impl(stream)) { }
+void VkEncoder::flush() {
+ mImpl->flush();
+}
+
+void VkEncoder::registerCleanupCallback(void* handle, VkEncoder::CleanupCallback cb) {
+ mImpl->registerCleanupCallback(handle, cb);
+}
+
+void VkEncoder::unregisterCleanupCallback(void* handle) {
+ mImpl->unregisterCleanupCallback(handle);
+}
+
#define VALIDATE_RET(retType, success, validate) \
retType goldfish_vk_validateResult = validate; \
if (goldfish_vk_validateResult != success) return goldfish_vk_validateResult; \
@@ -98,6 +147,7 @@
const VkAllocationCallbacks* pAllocator,
VkInstance* pInstance)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateInstance encode");
mImpl->log("start vkCreateInstance");
auto stream = mImpl->stream();
@@ -172,7 +222,9 @@
countingStream->clearPool();
stream->clearPool();
pool->freeAll();
+ encoderLock.unlock();
mImpl->resources()->on_vkCreateInstance(this, vkCreateInstance_VkResult_return, pCreateInfo, pAllocator, pInstance);
+ encoderLock.lock();
mImpl->log("finish vkCreateInstance");;
return vkCreateInstance_VkResult_return;
}
@@ -181,6 +233,7 @@
VkInstance instance,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyInstance encode");
mImpl->log("start vkDestroyInstance");
auto stream = mImpl->stream();
@@ -241,6 +294,7 @@
uint32_t* pPhysicalDeviceCount,
VkPhysicalDevice* pPhysicalDevices)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkEnumeratePhysicalDevices encode");
mImpl->log("start vkEnumeratePhysicalDevices");
auto stream = mImpl->stream();
@@ -351,6 +405,7 @@
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures* pFeatures)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures encode");
mImpl->log("start vkGetPhysicalDeviceFeatures");
auto stream = mImpl->stream();
@@ -391,6 +446,7 @@
VkFormat format,
VkFormatProperties* pFormatProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties encode");
mImpl->log("start vkGetPhysicalDeviceFormatProperties");
auto stream = mImpl->stream();
@@ -439,6 +495,7 @@
VkImageCreateFlags flags,
VkImageFormatProperties* pImageFormatProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties encode");
mImpl->log("start vkGetPhysicalDeviceImageFormatProperties");
auto stream = mImpl->stream();
@@ -504,6 +561,7 @@
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties* pProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties encode");
mImpl->log("start vkGetPhysicalDeviceProperties");
auto stream = mImpl->stream();
@@ -544,6 +602,7 @@
uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties* pQueueFamilyProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties encode");
mImpl->log("start vkGetPhysicalDeviceQueueFamilyProperties");
auto stream = mImpl->stream();
@@ -642,6 +701,7 @@
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties* pMemoryProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties encode");
mImpl->log("start vkGetPhysicalDeviceMemoryProperties");
auto stream = mImpl->stream();
@@ -674,7 +734,9 @@
transform_fromhost_VkPhysicalDeviceMemoryProperties(mImpl->resources(), (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
}
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties returnUnmarshal");
+ encoderLock.unlock();
mImpl->resources()->on_vkGetPhysicalDeviceMemoryProperties(this, physicalDevice, pMemoryProperties);
+ encoderLock.lock();
mImpl->log("finish vkGetPhysicalDeviceMemoryProperties");;
}
@@ -682,6 +744,7 @@
VkInstance instance,
const char* pName)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetInstanceProcAddr encode");
mImpl->log("start vkGetInstanceProcAddr");
auto stream = mImpl->stream();
@@ -728,6 +791,7 @@
VkDevice device,
const char* pName)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetDeviceProcAddr encode");
mImpl->log("start vkGetDeviceProcAddr");
auto stream = mImpl->stream();
@@ -776,6 +840,7 @@
const VkAllocationCallbacks* pAllocator,
VkDevice* pDevice)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateDevice encode");
mImpl->log("start vkCreateDevice");
auto stream = mImpl->stream();
@@ -858,7 +923,9 @@
countingStream->clearPool();
stream->clearPool();
pool->freeAll();
+ encoderLock.unlock();
mImpl->resources()->on_vkCreateDevice(this, vkCreateDevice_VkResult_return, physicalDevice, pCreateInfo, pAllocator, pDevice);
+ encoderLock.lock();
mImpl->log("finish vkCreateDevice");;
return vkCreateDevice_VkResult_return;
}
@@ -867,9 +934,12 @@
VkDevice device,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyDevice encode");
mImpl->log("start vkDestroyDevice");
+ encoderLock.unlock();
mImpl->resources()->on_vkDestroyDevice_pre(this, device, pAllocator);
+ encoderLock.lock();
auto stream = mImpl->stream();
auto countingStream = mImpl->countingStream();
auto resources = mImpl->resources();
@@ -929,6 +999,7 @@
uint32_t* pPropertyCount,
VkExtensionProperties* pProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkEnumerateInstanceExtensionProperties encode");
mImpl->log("start vkEnumerateInstanceExtensionProperties");
auto stream = mImpl->stream();
@@ -944,17 +1015,30 @@
}
countingStream->rewind();
{
- countingStream->putString(local_pLayerName);
+ if (countingStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
+ {
+ // WARNING PTR CHECK
+ uint64_t cgen_var_53 = (uint64_t)(uintptr_t)local_pLayerName;
+ countingStream->putBe64(cgen_var_53);
+ if (local_pLayerName)
+ {
+ countingStream->putString(local_pLayerName);
+ }
+ }
+ else
+ {
+ countingStream->putString(local_pLayerName);
+ }
// WARNING PTR CHECK
- uint64_t cgen_var_53 = (uint64_t)(uintptr_t)pPropertyCount;
- countingStream->putBe64(cgen_var_53);
+ uint64_t cgen_var_54 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_54);
if (pPropertyCount)
{
countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_54 = (uint64_t)(uintptr_t)pProperties;
- countingStream->putBe64(cgen_var_54);
+ uint64_t cgen_var_55 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_55);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -968,17 +1052,30 @@
uint32_t opcode_vkEnumerateInstanceExtensionProperties = OP_vkEnumerateInstanceExtensionProperties;
stream->write(&opcode_vkEnumerateInstanceExtensionProperties, sizeof(uint32_t));
stream->write(&packetSize_vkEnumerateInstanceExtensionProperties, sizeof(uint32_t));
- stream->putString(local_pLayerName);
+ if (stream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
+ {
+ // WARNING PTR CHECK
+ uint64_t cgen_var_56 = (uint64_t)(uintptr_t)local_pLayerName;
+ stream->putBe64(cgen_var_56);
+ if (local_pLayerName)
+ {
+ stream->putString(local_pLayerName);
+ }
+ }
+ else
+ {
+ stream->putString(local_pLayerName);
+ }
// WARNING PTR CHECK
- uint64_t cgen_var_55 = (uint64_t)(uintptr_t)pPropertyCount;
- stream->putBe64(cgen_var_55);
+ uint64_t cgen_var_57 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_57);
if (pPropertyCount)
{
stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_56 = (uint64_t)(uintptr_t)pProperties;
- stream->putBe64(cgen_var_56);
+ uint64_t cgen_var_58 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_58);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -1035,6 +1132,7 @@
uint32_t* pPropertyCount,
VkExtensionProperties* pProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkEnumerateDeviceExtensionProperties encode");
mImpl->log("start vkEnumerateDeviceExtensionProperties");
auto stream = mImpl->stream();
@@ -1052,20 +1150,33 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_59;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_59, 1);
- countingStream->write((uint64_t*)&cgen_var_59, 1 * 8);
- countingStream->putString(local_pLayerName);
+ uint64_t cgen_var_61;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_61, 1);
+ countingStream->write((uint64_t*)&cgen_var_61, 1 * 8);
+ if (countingStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
+ {
+ // WARNING PTR CHECK
+ uint64_t cgen_var_62 = (uint64_t)(uintptr_t)local_pLayerName;
+ countingStream->putBe64(cgen_var_62);
+ if (local_pLayerName)
+ {
+ countingStream->putString(local_pLayerName);
+ }
+ }
+ else
+ {
+ countingStream->putString(local_pLayerName);
+ }
// WARNING PTR CHECK
- uint64_t cgen_var_60 = (uint64_t)(uintptr_t)pPropertyCount;
- countingStream->putBe64(cgen_var_60);
+ uint64_t cgen_var_63 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_63);
if (pPropertyCount)
{
countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_61 = (uint64_t)(uintptr_t)pProperties;
- countingStream->putBe64(cgen_var_61);
+ uint64_t cgen_var_64 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_64);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -1079,20 +1190,33 @@
uint32_t opcode_vkEnumerateDeviceExtensionProperties = OP_vkEnumerateDeviceExtensionProperties;
stream->write(&opcode_vkEnumerateDeviceExtensionProperties, sizeof(uint32_t));
stream->write(&packetSize_vkEnumerateDeviceExtensionProperties, sizeof(uint32_t));
- uint64_t cgen_var_62;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_62, 1);
- stream->write((uint64_t*)&cgen_var_62, 1 * 8);
- stream->putString(local_pLayerName);
+ uint64_t cgen_var_65;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_65, 1);
+ stream->write((uint64_t*)&cgen_var_65, 1 * 8);
+ if (stream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
+ {
+ // WARNING PTR CHECK
+ uint64_t cgen_var_66 = (uint64_t)(uintptr_t)local_pLayerName;
+ stream->putBe64(cgen_var_66);
+ if (local_pLayerName)
+ {
+ stream->putString(local_pLayerName);
+ }
+ }
+ else
+ {
+ stream->putString(local_pLayerName);
+ }
// WARNING PTR CHECK
- uint64_t cgen_var_63 = (uint64_t)(uintptr_t)pPropertyCount;
- stream->putBe64(cgen_var_63);
+ uint64_t cgen_var_67 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_67);
if (pPropertyCount)
{
stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_64 = (uint64_t)(uintptr_t)pProperties;
- stream->putBe64(cgen_var_64);
+ uint64_t cgen_var_68 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_68);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -1147,6 +1271,7 @@
uint32_t* pPropertyCount,
VkLayerProperties* pProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties encode");
mImpl->log("start vkEnumerateInstanceLayerProperties");
auto stream = mImpl->stream();
@@ -1157,15 +1282,15 @@
countingStream->rewind();
{
// WARNING PTR CHECK
- uint64_t cgen_var_67 = (uint64_t)(uintptr_t)pPropertyCount;
- countingStream->putBe64(cgen_var_67);
+ uint64_t cgen_var_71 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_71);
if (pPropertyCount)
{
countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_68 = (uint64_t)(uintptr_t)pProperties;
- countingStream->putBe64(cgen_var_68);
+ uint64_t cgen_var_72 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_72);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -1180,15 +1305,15 @@
stream->write(&opcode_vkEnumerateInstanceLayerProperties, sizeof(uint32_t));
stream->write(&packetSize_vkEnumerateInstanceLayerProperties, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_69 = (uint64_t)(uintptr_t)pPropertyCount;
- stream->putBe64(cgen_var_69);
+ uint64_t cgen_var_73 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_73);
if (pPropertyCount)
{
stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_70 = (uint64_t)(uintptr_t)pProperties;
- stream->putBe64(cgen_var_70);
+ uint64_t cgen_var_74 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_74);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -1244,6 +1369,7 @@
uint32_t* pPropertyCount,
VkLayerProperties* pProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties encode");
mImpl->log("start vkEnumerateDeviceLayerProperties");
auto stream = mImpl->stream();
@@ -1255,19 +1381,19 @@
local_physicalDevice = physicalDevice;
countingStream->rewind();
{
- uint64_t cgen_var_73;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_73, 1);
- countingStream->write((uint64_t*)&cgen_var_73, 1 * 8);
+ uint64_t cgen_var_77;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_77, 1);
+ countingStream->write((uint64_t*)&cgen_var_77, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_74 = (uint64_t)(uintptr_t)pPropertyCount;
- countingStream->putBe64(cgen_var_74);
+ uint64_t cgen_var_78 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_78);
if (pPropertyCount)
{
countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_75 = (uint64_t)(uintptr_t)pProperties;
- countingStream->putBe64(cgen_var_75);
+ uint64_t cgen_var_79 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_79);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -1281,19 +1407,19 @@
uint32_t opcode_vkEnumerateDeviceLayerProperties = OP_vkEnumerateDeviceLayerProperties;
stream->write(&opcode_vkEnumerateDeviceLayerProperties, sizeof(uint32_t));
stream->write(&packetSize_vkEnumerateDeviceLayerProperties, sizeof(uint32_t));
- uint64_t cgen_var_76;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_76, 1);
- stream->write((uint64_t*)&cgen_var_76, 1 * 8);
+ uint64_t cgen_var_80;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_80, 1);
+ stream->write((uint64_t*)&cgen_var_80, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_77 = (uint64_t)(uintptr_t)pPropertyCount;
- stream->putBe64(cgen_var_77);
+ uint64_t cgen_var_81 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_81);
if (pPropertyCount)
{
stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_78 = (uint64_t)(uintptr_t)pProperties;
- stream->putBe64(cgen_var_78);
+ uint64_t cgen_var_82 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_82);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -1350,6 +1476,7 @@
uint32_t queueIndex,
VkQueue* pQueue)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetDeviceQueue encode");
mImpl->log("start vkGetDeviceQueue");
auto stream = mImpl->stream();
@@ -1365,35 +1492,35 @@
local_queueIndex = queueIndex;
countingStream->rewind();
{
- uint64_t cgen_var_81;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_81, 1);
- countingStream->write((uint64_t*)&cgen_var_81, 1 * 8);
+ uint64_t cgen_var_85;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_85, 1);
+ countingStream->write((uint64_t*)&cgen_var_85, 1 * 8);
countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_queueIndex, sizeof(uint32_t));
- uint64_t cgen_var_82;
- countingStream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_82, 1);
- countingStream->write((uint64_t*)&cgen_var_82, 8);
+ uint64_t cgen_var_86;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_86, 1);
+ countingStream->write((uint64_t*)&cgen_var_86, 8);
}
uint32_t packetSize_vkGetDeviceQueue = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkGetDeviceQueue = OP_vkGetDeviceQueue;
stream->write(&opcode_vkGetDeviceQueue, sizeof(uint32_t));
stream->write(&packetSize_vkGetDeviceQueue, sizeof(uint32_t));
- uint64_t cgen_var_83;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_83, 1);
- stream->write((uint64_t*)&cgen_var_83, 1 * 8);
+ uint64_t cgen_var_87;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_87, 1);
+ stream->write((uint64_t*)&cgen_var_87, 1 * 8);
stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
stream->write((uint32_t*)&local_queueIndex, sizeof(uint32_t));
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_84;
- stream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_84, 1);
- stream->write((uint64_t*)&cgen_var_84, 8);
+ uint64_t cgen_var_88;
+ stream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_88, 1);
+ stream->write((uint64_t*)&cgen_var_88, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkGetDeviceQueue readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_85;
- stream->read((uint64_t*)&cgen_var_85, 8);
- stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_85, (VkQueue*)pQueue, 1);
+ uint64_t cgen_var_89;
+ stream->read((uint64_t*)&cgen_var_89, 8);
+ stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_89, (VkQueue*)pQueue, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkGetDeviceQueue returnUnmarshal");
mImpl->log("finish vkGetDeviceQueue");;
@@ -1405,6 +1532,7 @@
const VkSubmitInfo* pSubmits,
VkFence fence)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkQueueSubmit encode");
mImpl->log("start vkQueueSubmit");
auto stream = mImpl->stream();
@@ -1437,34 +1565,34 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_86;
- countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_86, 1);
- countingStream->write((uint64_t*)&cgen_var_86, 1 * 8);
+ uint64_t cgen_var_90;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_90, 1);
+ countingStream->write((uint64_t*)&cgen_var_90, 1 * 8);
countingStream->write((uint32_t*)&local_submitCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
{
marshal_VkSubmitInfo(countingStream, (VkSubmitInfo*)(local_pSubmits + i));
}
- uint64_t cgen_var_87;
- countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_87, 1);
- countingStream->write((uint64_t*)&cgen_var_87, 1 * 8);
+ uint64_t cgen_var_91;
+ countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_91, 1);
+ countingStream->write((uint64_t*)&cgen_var_91, 1 * 8);
}
uint32_t packetSize_vkQueueSubmit = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkQueueSubmit = OP_vkQueueSubmit;
stream->write(&opcode_vkQueueSubmit, sizeof(uint32_t));
stream->write(&packetSize_vkQueueSubmit, sizeof(uint32_t));
- uint64_t cgen_var_88;
- stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_88, 1);
- stream->write((uint64_t*)&cgen_var_88, 1 * 8);
+ uint64_t cgen_var_92;
+ stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_92, 1);
+ stream->write((uint64_t*)&cgen_var_92, 1 * 8);
stream->write((uint32_t*)&local_submitCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
{
marshal_VkSubmitInfo(stream, (VkSubmitInfo*)(local_pSubmits + i));
}
- uint64_t cgen_var_89;
- stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_89, 1);
- stream->write((uint64_t*)&cgen_var_89, 1 * 8);
+ uint64_t cgen_var_93;
+ stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_93, 1);
+ stream->write((uint64_t*)&cgen_var_93, 1 * 8);
AEMU_SCOPED_TRACE("vkQueueSubmit readParams");
AEMU_SCOPED_TRACE("vkQueueSubmit returnUnmarshal");
VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
@@ -1479,6 +1607,7 @@
VkResult VkEncoder::vkQueueWaitIdle(
VkQueue queue)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkQueueWaitIdle encode");
mImpl->log("start vkQueueWaitIdle");
auto stream = mImpl->stream();
@@ -1490,18 +1619,18 @@
local_queue = queue;
countingStream->rewind();
{
- uint64_t cgen_var_90;
- countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_90, 1);
- countingStream->write((uint64_t*)&cgen_var_90, 1 * 8);
+ uint64_t cgen_var_94;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_94, 1);
+ countingStream->write((uint64_t*)&cgen_var_94, 1 * 8);
}
uint32_t packetSize_vkQueueWaitIdle = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkQueueWaitIdle = OP_vkQueueWaitIdle;
stream->write(&opcode_vkQueueWaitIdle, sizeof(uint32_t));
stream->write(&packetSize_vkQueueWaitIdle, sizeof(uint32_t));
- uint64_t cgen_var_91;
- stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_91, 1);
- stream->write((uint64_t*)&cgen_var_91, 1 * 8);
+ uint64_t cgen_var_95;
+ stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_95, 1);
+ stream->write((uint64_t*)&cgen_var_95, 1 * 8);
AEMU_SCOPED_TRACE("vkQueueWaitIdle readParams");
AEMU_SCOPED_TRACE("vkQueueWaitIdle returnUnmarshal");
VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
@@ -1516,6 +1645,7 @@
VkResult VkEncoder::vkDeviceWaitIdle(
VkDevice device)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDeviceWaitIdle encode");
mImpl->log("start vkDeviceWaitIdle");
auto stream = mImpl->stream();
@@ -1527,18 +1657,18 @@
local_device = device;
countingStream->rewind();
{
- uint64_t cgen_var_92;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_92, 1);
- countingStream->write((uint64_t*)&cgen_var_92, 1 * 8);
+ uint64_t cgen_var_96;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_96, 1);
+ countingStream->write((uint64_t*)&cgen_var_96, 1 * 8);
}
uint32_t packetSize_vkDeviceWaitIdle = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkDeviceWaitIdle = OP_vkDeviceWaitIdle;
stream->write(&opcode_vkDeviceWaitIdle, sizeof(uint32_t));
stream->write(&packetSize_vkDeviceWaitIdle, sizeof(uint32_t));
- uint64_t cgen_var_93;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_93, 1);
- stream->write((uint64_t*)&cgen_var_93, 1 * 8);
+ uint64_t cgen_var_97;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_97, 1);
+ stream->write((uint64_t*)&cgen_var_97, 1 * 8);
AEMU_SCOPED_TRACE("vkDeviceWaitIdle readParams");
AEMU_SCOPED_TRACE("vkDeviceWaitIdle returnUnmarshal");
VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
@@ -1556,6 +1686,7 @@
const VkAllocationCallbacks* pAllocator,
VkDeviceMemory* pMemory)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkAllocateMemory encode");
mImpl->log("start vkAllocateMemory");
auto stream = mImpl->stream();
@@ -1590,47 +1721,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_94;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_94, 1);
- countingStream->write((uint64_t*)&cgen_var_94, 1 * 8);
+ uint64_t cgen_var_98;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_98, 1);
+ countingStream->write((uint64_t*)&cgen_var_98, 1 * 8);
marshal_VkMemoryAllocateInfo(countingStream, (VkMemoryAllocateInfo*)(local_pAllocateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_95 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_95);
+ uint64_t cgen_var_99 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_99);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_96;
- countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(pMemory, &cgen_var_96, 1);
- countingStream->write((uint64_t*)&cgen_var_96, 8);
+ uint64_t cgen_var_100;
+ countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(pMemory, &cgen_var_100, 1);
+ countingStream->write((uint64_t*)&cgen_var_100, 8);
}
uint32_t packetSize_vkAllocateMemory = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkAllocateMemory = OP_vkAllocateMemory;
stream->write(&opcode_vkAllocateMemory, sizeof(uint32_t));
stream->write(&packetSize_vkAllocateMemory, sizeof(uint32_t));
- uint64_t cgen_var_97;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_97, 1);
- stream->write((uint64_t*)&cgen_var_97, 1 * 8);
+ uint64_t cgen_var_101;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_101, 1);
+ stream->write((uint64_t*)&cgen_var_101, 1 * 8);
marshal_VkMemoryAllocateInfo(stream, (VkMemoryAllocateInfo*)(local_pAllocateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_98 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_98);
+ uint64_t cgen_var_102 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_102);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_99;
- stream->handleMapping()->mapHandles_VkDeviceMemory_u64(pMemory, &cgen_var_99, 1);
- stream->write((uint64_t*)&cgen_var_99, 8);
+ uint64_t cgen_var_103;
+ stream->handleMapping()->mapHandles_VkDeviceMemory_u64(pMemory, &cgen_var_103, 1);
+ stream->write((uint64_t*)&cgen_var_103, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkAllocateMemory readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_100;
- stream->read((uint64_t*)&cgen_var_100, 8);
- stream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_100, (VkDeviceMemory*)pMemory, 1);
+ uint64_t cgen_var_104;
+ stream->read((uint64_t*)&cgen_var_104, 8);
+ stream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_104, (VkDeviceMemory*)pMemory, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkAllocateMemory returnUnmarshal");
VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
@@ -1647,6 +1778,7 @@
VkDeviceMemory memory,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkFreeMemory encode");
mImpl->log("start vkFreeMemory");
auto stream = mImpl->stream();
@@ -1669,15 +1801,15 @@
mImpl->resources()->deviceMemoryTransform_tohost((VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
countingStream->rewind();
{
- uint64_t cgen_var_101;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_101, 1);
- countingStream->write((uint64_t*)&cgen_var_101, 1 * 8);
- uint64_t cgen_var_102;
- countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_102, 1);
- countingStream->write((uint64_t*)&cgen_var_102, 1 * 8);
+ uint64_t cgen_var_105;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_105, 1);
+ countingStream->write((uint64_t*)&cgen_var_105, 1 * 8);
+ uint64_t cgen_var_106;
+ countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_106, 1);
+ countingStream->write((uint64_t*)&cgen_var_106, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_103 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_103);
+ uint64_t cgen_var_107 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_107);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -1688,15 +1820,15 @@
uint32_t opcode_vkFreeMemory = OP_vkFreeMemory;
stream->write(&opcode_vkFreeMemory, sizeof(uint32_t));
stream->write(&packetSize_vkFreeMemory, sizeof(uint32_t));
- uint64_t cgen_var_104;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_104, 1);
- stream->write((uint64_t*)&cgen_var_104, 1 * 8);
- uint64_t cgen_var_105;
- stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_105, 1);
- stream->write((uint64_t*)&cgen_var_105, 1 * 8);
+ uint64_t cgen_var_108;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_108, 1);
+ stream->write((uint64_t*)&cgen_var_108, 1 * 8);
+ uint64_t cgen_var_109;
+ stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_109, 1);
+ stream->write((uint64_t*)&cgen_var_109, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_106 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_106);
+ uint64_t cgen_var_110 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_110);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -1735,6 +1867,7 @@
uint32_t memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges encode");
mImpl->log("start vkFlushMappedMemoryRanges");
VALIDATE_RET(VkResult, VK_SUCCESS, mImpl->validation()->on_vkFlushMappedMemoryRanges(this, VK_SUCCESS, device, memoryRangeCount, pMemoryRanges));
@@ -1766,9 +1899,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_107;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_107, 1);
- countingStream->write((uint64_t*)&cgen_var_107, 1 * 8);
+ uint64_t cgen_var_111;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_111, 1);
+ countingStream->write((uint64_t*)&cgen_var_111, 1 * 8);
countingStream->write((uint32_t*)&local_memoryRangeCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
{
@@ -1799,9 +1932,9 @@
uint32_t opcode_vkFlushMappedMemoryRanges = OP_vkFlushMappedMemoryRanges;
stream->write(&opcode_vkFlushMappedMemoryRanges, sizeof(uint32_t));
stream->write(&packetSize_vkFlushMappedMemoryRanges, sizeof(uint32_t));
- uint64_t cgen_var_108;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_108, 1);
- stream->write((uint64_t*)&cgen_var_108, 1 * 8);
+ uint64_t cgen_var_112;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_112, 1);
+ stream->write((uint64_t*)&cgen_var_112, 1 * 8);
stream->write((uint32_t*)&local_memoryRangeCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
{
@@ -1842,6 +1975,7 @@
uint32_t memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges encode");
mImpl->log("start vkInvalidateMappedMemoryRanges");
VALIDATE_RET(VkResult, VK_SUCCESS, mImpl->validation()->on_vkInvalidateMappedMemoryRanges(this, VK_SUCCESS, device, memoryRangeCount, pMemoryRanges));
@@ -1873,9 +2007,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_109;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_109, 1);
- countingStream->write((uint64_t*)&cgen_var_109, 1 * 8);
+ uint64_t cgen_var_113;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_113, 1);
+ countingStream->write((uint64_t*)&cgen_var_113, 1 * 8);
countingStream->write((uint32_t*)&local_memoryRangeCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
{
@@ -1887,9 +2021,9 @@
uint32_t opcode_vkInvalidateMappedMemoryRanges = OP_vkInvalidateMappedMemoryRanges;
stream->write(&opcode_vkInvalidateMappedMemoryRanges, sizeof(uint32_t));
stream->write(&packetSize_vkInvalidateMappedMemoryRanges, sizeof(uint32_t));
- uint64_t cgen_var_110;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_110, 1);
- stream->write((uint64_t*)&cgen_var_110, 1 * 8);
+ uint64_t cgen_var_114;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_114, 1);
+ stream->write((uint64_t*)&cgen_var_114, 1 * 8);
stream->write((uint32_t*)&local_memoryRangeCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
{
@@ -1930,6 +2064,7 @@
VkDeviceMemory memory,
VkDeviceSize* pCommittedMemoryInBytes)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment encode");
mImpl->log("start vkGetDeviceMemoryCommitment");
auto stream = mImpl->stream();
@@ -1944,12 +2079,12 @@
mImpl->resources()->deviceMemoryTransform_tohost((VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
countingStream->rewind();
{
- uint64_t cgen_var_111;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_111, 1);
- countingStream->write((uint64_t*)&cgen_var_111, 1 * 8);
- uint64_t cgen_var_112;
- countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_112, 1);
- countingStream->write((uint64_t*)&cgen_var_112, 1 * 8);
+ uint64_t cgen_var_115;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_115, 1);
+ countingStream->write((uint64_t*)&cgen_var_115, 1 * 8);
+ uint64_t cgen_var_116;
+ countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_116, 1);
+ countingStream->write((uint64_t*)&cgen_var_116, 1 * 8);
countingStream->write((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
}
uint32_t packetSize_vkGetDeviceMemoryCommitment = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -1957,12 +2092,12 @@
uint32_t opcode_vkGetDeviceMemoryCommitment = OP_vkGetDeviceMemoryCommitment;
stream->write(&opcode_vkGetDeviceMemoryCommitment, sizeof(uint32_t));
stream->write(&packetSize_vkGetDeviceMemoryCommitment, sizeof(uint32_t));
- uint64_t cgen_var_113;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_113, 1);
- stream->write((uint64_t*)&cgen_var_113, 1 * 8);
- uint64_t cgen_var_114;
- stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_114, 1);
- stream->write((uint64_t*)&cgen_var_114, 1 * 8);
+ uint64_t cgen_var_117;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_117, 1);
+ stream->write((uint64_t*)&cgen_var_117, 1 * 8);
+ uint64_t cgen_var_118;
+ stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_118, 1);
+ stream->write((uint64_t*)&cgen_var_118, 1 * 8);
stream->write((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment readParams");
stream->read((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
@@ -1976,6 +2111,7 @@
VkDeviceMemory memory,
VkDeviceSize memoryOffset)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkBindBufferMemory encode");
mImpl->log("start vkBindBufferMemory");
auto stream = mImpl->stream();
@@ -1994,15 +2130,15 @@
mImpl->resources()->deviceMemoryTransform_tohost((VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)&local_memoryOffset, 1, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
countingStream->rewind();
{
- uint64_t cgen_var_115;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_115, 1);
- countingStream->write((uint64_t*)&cgen_var_115, 1 * 8);
- uint64_t cgen_var_116;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_116, 1);
- countingStream->write((uint64_t*)&cgen_var_116, 1 * 8);
- uint64_t cgen_var_117;
- countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_117, 1);
- countingStream->write((uint64_t*)&cgen_var_117, 1 * 8);
+ uint64_t cgen_var_119;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_119, 1);
+ countingStream->write((uint64_t*)&cgen_var_119, 1 * 8);
+ uint64_t cgen_var_120;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_120, 1);
+ countingStream->write((uint64_t*)&cgen_var_120, 1 * 8);
+ uint64_t cgen_var_121;
+ countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_121, 1);
+ countingStream->write((uint64_t*)&cgen_var_121, 1 * 8);
countingStream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
}
uint32_t packetSize_vkBindBufferMemory = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -2010,15 +2146,15 @@
uint32_t opcode_vkBindBufferMemory = OP_vkBindBufferMemory;
stream->write(&opcode_vkBindBufferMemory, sizeof(uint32_t));
stream->write(&packetSize_vkBindBufferMemory, sizeof(uint32_t));
- uint64_t cgen_var_118;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_118, 1);
- stream->write((uint64_t*)&cgen_var_118, 1 * 8);
- uint64_t cgen_var_119;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_119, 1);
- stream->write((uint64_t*)&cgen_var_119, 1 * 8);
- uint64_t cgen_var_120;
- stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_120, 1);
- stream->write((uint64_t*)&cgen_var_120, 1 * 8);
+ uint64_t cgen_var_122;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_122, 1);
+ stream->write((uint64_t*)&cgen_var_122, 1 * 8);
+ uint64_t cgen_var_123;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_123, 1);
+ stream->write((uint64_t*)&cgen_var_123, 1 * 8);
+ uint64_t cgen_var_124;
+ stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_124, 1);
+ stream->write((uint64_t*)&cgen_var_124, 1 * 8);
stream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
AEMU_SCOPED_TRACE("vkBindBufferMemory readParams");
AEMU_SCOPED_TRACE("vkBindBufferMemory returnUnmarshal");
@@ -2037,6 +2173,7 @@
VkDeviceMemory memory,
VkDeviceSize memoryOffset)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkBindImageMemory encode");
mImpl->log("start vkBindImageMemory");
auto stream = mImpl->stream();
@@ -2055,15 +2192,15 @@
mImpl->resources()->deviceMemoryTransform_tohost((VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)&local_memoryOffset, 1, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
countingStream->rewind();
{
- uint64_t cgen_var_121;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_121, 1);
- countingStream->write((uint64_t*)&cgen_var_121, 1 * 8);
- uint64_t cgen_var_122;
- countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_122, 1);
- countingStream->write((uint64_t*)&cgen_var_122, 1 * 8);
- uint64_t cgen_var_123;
- countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_123, 1);
- countingStream->write((uint64_t*)&cgen_var_123, 1 * 8);
+ uint64_t cgen_var_125;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_125, 1);
+ countingStream->write((uint64_t*)&cgen_var_125, 1 * 8);
+ uint64_t cgen_var_126;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_126, 1);
+ countingStream->write((uint64_t*)&cgen_var_126, 1 * 8);
+ uint64_t cgen_var_127;
+ countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_127, 1);
+ countingStream->write((uint64_t*)&cgen_var_127, 1 * 8);
countingStream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
}
uint32_t packetSize_vkBindImageMemory = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -2071,15 +2208,15 @@
uint32_t opcode_vkBindImageMemory = OP_vkBindImageMemory;
stream->write(&opcode_vkBindImageMemory, sizeof(uint32_t));
stream->write(&packetSize_vkBindImageMemory, sizeof(uint32_t));
- uint64_t cgen_var_124;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_124, 1);
- stream->write((uint64_t*)&cgen_var_124, 1 * 8);
- uint64_t cgen_var_125;
- stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_125, 1);
- stream->write((uint64_t*)&cgen_var_125, 1 * 8);
- uint64_t cgen_var_126;
- stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_126, 1);
- stream->write((uint64_t*)&cgen_var_126, 1 * 8);
+ uint64_t cgen_var_128;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_128, 1);
+ stream->write((uint64_t*)&cgen_var_128, 1 * 8);
+ uint64_t cgen_var_129;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_129, 1);
+ stream->write((uint64_t*)&cgen_var_129, 1 * 8);
+ uint64_t cgen_var_130;
+ stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_130, 1);
+ stream->write((uint64_t*)&cgen_var_130, 1 * 8);
stream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize));
AEMU_SCOPED_TRACE("vkBindImageMemory readParams");
AEMU_SCOPED_TRACE("vkBindImageMemory returnUnmarshal");
@@ -2097,6 +2234,7 @@
VkBuffer buffer,
VkMemoryRequirements* pMemoryRequirements)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements encode");
mImpl->log("start vkGetBufferMemoryRequirements");
auto stream = mImpl->stream();
@@ -2110,12 +2248,12 @@
local_buffer = buffer;
countingStream->rewind();
{
- uint64_t cgen_var_127;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_127, 1);
- countingStream->write((uint64_t*)&cgen_var_127, 1 * 8);
- uint64_t cgen_var_128;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_128, 1);
- countingStream->write((uint64_t*)&cgen_var_128, 1 * 8);
+ uint64_t cgen_var_131;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_131, 1);
+ countingStream->write((uint64_t*)&cgen_var_131, 1 * 8);
+ uint64_t cgen_var_132;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_132, 1);
+ countingStream->write((uint64_t*)&cgen_var_132, 1 * 8);
marshal_VkMemoryRequirements(countingStream, (VkMemoryRequirements*)(pMemoryRequirements));
}
uint32_t packetSize_vkGetBufferMemoryRequirements = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -2123,12 +2261,12 @@
uint32_t opcode_vkGetBufferMemoryRequirements = OP_vkGetBufferMemoryRequirements;
stream->write(&opcode_vkGetBufferMemoryRequirements, sizeof(uint32_t));
stream->write(&packetSize_vkGetBufferMemoryRequirements, sizeof(uint32_t));
- uint64_t cgen_var_129;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_129, 1);
- stream->write((uint64_t*)&cgen_var_129, 1 * 8);
- uint64_t cgen_var_130;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_130, 1);
- stream->write((uint64_t*)&cgen_var_130, 1 * 8);
+ uint64_t cgen_var_133;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_133, 1);
+ stream->write((uint64_t*)&cgen_var_133, 1 * 8);
+ uint64_t cgen_var_134;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_134, 1);
+ stream->write((uint64_t*)&cgen_var_134, 1 * 8);
marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements readParams");
unmarshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
@@ -2145,6 +2283,7 @@
VkImage image,
VkMemoryRequirements* pMemoryRequirements)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements encode");
mImpl->log("start vkGetImageMemoryRequirements");
auto stream = mImpl->stream();
@@ -2158,71 +2297,72 @@
local_image = image;
countingStream->rewind();
{
- uint64_t cgen_var_131;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_131, 1);
- countingStream->write((uint64_t*)&cgen_var_131, 1 * 8);
- uint64_t cgen_var_132;
- countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_132, 1);
- countingStream->write((uint64_t*)&cgen_var_132, 1 * 8);
- marshal_VkMemoryRequirements(countingStream, (VkMemoryRequirements*)(pMemoryRequirements));
- }
- uint32_t packetSize_vkGetImageMemoryRequirements = 4 + 4 + (uint32_t)countingStream->bytesWritten();
- countingStream->rewind();
- uint32_t opcode_vkGetImageMemoryRequirements = OP_vkGetImageMemoryRequirements;
- stream->write(&opcode_vkGetImageMemoryRequirements, sizeof(uint32_t));
- stream->write(&packetSize_vkGetImageMemoryRequirements, sizeof(uint32_t));
- uint64_t cgen_var_133;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_133, 1);
- stream->write((uint64_t*)&cgen_var_133, 1 * 8);
- uint64_t cgen_var_134;
- stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_134, 1);
- stream->write((uint64_t*)&cgen_var_134, 1 * 8);
- marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
- AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements readParams");
- unmarshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
- if (pMemoryRequirements)
- {
- transform_fromhost_VkMemoryRequirements(mImpl->resources(), (VkMemoryRequirements*)(pMemoryRequirements));
- }
- AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements returnUnmarshal");
- mImpl->log("finish vkGetImageMemoryRequirements");;
-}
-
-void VkEncoder::vkGetImageSparseMemoryRequirements(
- VkDevice device,
- VkImage image,
- uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
-{
- AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements encode");
- mImpl->log("start vkGetImageSparseMemoryRequirements");
- auto stream = mImpl->stream();
- auto countingStream = mImpl->countingStream();
- auto resources = mImpl->resources();
- auto pool = mImpl->pool();
- stream->setHandleMapping(resources->unwrapMapping());
- VkDevice local_device;
- VkImage local_image;
- local_device = device;
- local_image = image;
- countingStream->rewind();
- {
uint64_t cgen_var_135;
countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_135, 1);
countingStream->write((uint64_t*)&cgen_var_135, 1 * 8);
uint64_t cgen_var_136;
countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_136, 1);
countingStream->write((uint64_t*)&cgen_var_136, 1 * 8);
+ marshal_VkMemoryRequirements(countingStream, (VkMemoryRequirements*)(pMemoryRequirements));
+ }
+ uint32_t packetSize_vkGetImageMemoryRequirements = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkGetImageMemoryRequirements = OP_vkGetImageMemoryRequirements;
+ stream->write(&opcode_vkGetImageMemoryRequirements, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetImageMemoryRequirements, sizeof(uint32_t));
+ uint64_t cgen_var_137;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_137, 1);
+ stream->write((uint64_t*)&cgen_var_137, 1 * 8);
+ uint64_t cgen_var_138;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_138, 1);
+ stream->write((uint64_t*)&cgen_var_138, 1 * 8);
+ marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
+ AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements readParams");
+ unmarshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
+ if (pMemoryRequirements)
+ {
+ transform_fromhost_VkMemoryRequirements(mImpl->resources(), (VkMemoryRequirements*)(pMemoryRequirements));
+ }
+ AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements returnUnmarshal");
+ mImpl->log("finish vkGetImageMemoryRequirements");;
+}
+
+void VkEncoder::vkGetImageSparseMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+{
+ AutoLock encoderLock(mImpl->lock);
+ AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements encode");
+ mImpl->log("start vkGetImageSparseMemoryRequirements");
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImage local_image;
+ local_device = device;
+ local_image = image;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_139;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_139, 1);
+ countingStream->write((uint64_t*)&cgen_var_139, 1 * 8);
+ uint64_t cgen_var_140;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_140, 1);
+ countingStream->write((uint64_t*)&cgen_var_140, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_137 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
- countingStream->putBe64(cgen_var_137);
+ uint64_t cgen_var_141 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+ countingStream->putBe64(cgen_var_141);
if (pSparseMemoryRequirementCount)
{
countingStream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_138 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
- countingStream->putBe64(cgen_var_138);
+ uint64_t cgen_var_142 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+ countingStream->putBe64(cgen_var_142);
if (pSparseMemoryRequirements)
{
for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
@@ -2236,22 +2376,22 @@
uint32_t opcode_vkGetImageSparseMemoryRequirements = OP_vkGetImageSparseMemoryRequirements;
stream->write(&opcode_vkGetImageSparseMemoryRequirements, sizeof(uint32_t));
stream->write(&packetSize_vkGetImageSparseMemoryRequirements, sizeof(uint32_t));
- uint64_t cgen_var_139;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_139, 1);
- stream->write((uint64_t*)&cgen_var_139, 1 * 8);
- uint64_t cgen_var_140;
- stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_140, 1);
- stream->write((uint64_t*)&cgen_var_140, 1 * 8);
+ uint64_t cgen_var_143;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_143, 1);
+ stream->write((uint64_t*)&cgen_var_143, 1 * 8);
+ uint64_t cgen_var_144;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_144, 1);
+ stream->write((uint64_t*)&cgen_var_144, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_141 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
- stream->putBe64(cgen_var_141);
+ uint64_t cgen_var_145 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+ stream->putBe64(cgen_var_145);
if (pSparseMemoryRequirementCount)
{
stream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_142 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
- stream->putBe64(cgen_var_142);
+ uint64_t cgen_var_146 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+ stream->putBe64(cgen_var_146);
if (pSparseMemoryRequirements)
{
for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
@@ -2306,6 +2446,7 @@
uint32_t* pPropertyCount,
VkSparseImageFormatProperties* pProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties encode");
mImpl->log("start vkGetPhysicalDeviceSparseImageFormatProperties");
auto stream = mImpl->stream();
@@ -2327,24 +2468,24 @@
local_tiling = tiling;
countingStream->rewind();
{
- uint64_t cgen_var_145;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_145, 1);
- countingStream->write((uint64_t*)&cgen_var_145, 1 * 8);
+ uint64_t cgen_var_149;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_149, 1);
+ countingStream->write((uint64_t*)&cgen_var_149, 1 * 8);
countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
countingStream->write((VkImageType*)&local_type, sizeof(VkImageType));
countingStream->write((VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
countingStream->write((VkImageUsageFlags*)&local_usage, sizeof(VkImageUsageFlags));
countingStream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
// WARNING PTR CHECK
- uint64_t cgen_var_146 = (uint64_t)(uintptr_t)pPropertyCount;
- countingStream->putBe64(cgen_var_146);
+ uint64_t cgen_var_150 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_150);
if (pPropertyCount)
{
countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_147 = (uint64_t)(uintptr_t)pProperties;
- countingStream->putBe64(cgen_var_147);
+ uint64_t cgen_var_151 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_151);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -2358,24 +2499,24 @@
uint32_t opcode_vkGetPhysicalDeviceSparseImageFormatProperties = OP_vkGetPhysicalDeviceSparseImageFormatProperties;
stream->write(&opcode_vkGetPhysicalDeviceSparseImageFormatProperties, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceSparseImageFormatProperties, sizeof(uint32_t));
- uint64_t cgen_var_148;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_148, 1);
- stream->write((uint64_t*)&cgen_var_148, 1 * 8);
+ uint64_t cgen_var_152;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_152, 1);
+ stream->write((uint64_t*)&cgen_var_152, 1 * 8);
stream->write((VkFormat*)&local_format, sizeof(VkFormat));
stream->write((VkImageType*)&local_type, sizeof(VkImageType));
stream->write((VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
stream->write((VkImageUsageFlags*)&local_usage, sizeof(VkImageUsageFlags));
stream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
// WARNING PTR CHECK
- uint64_t cgen_var_149 = (uint64_t)(uintptr_t)pPropertyCount;
- stream->putBe64(cgen_var_149);
+ uint64_t cgen_var_153 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_153);
if (pPropertyCount)
{
stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_150 = (uint64_t)(uintptr_t)pProperties;
- stream->putBe64(cgen_var_150);
+ uint64_t cgen_var_154 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_154);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -2426,6 +2567,7 @@
const VkBindSparseInfo* pBindInfo,
VkFence fence)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkQueueBindSparse encode");
mImpl->log("start vkQueueBindSparse");
auto stream = mImpl->stream();
@@ -2458,34 +2600,34 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_153;
- countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_153, 1);
- countingStream->write((uint64_t*)&cgen_var_153, 1 * 8);
+ uint64_t cgen_var_157;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_157, 1);
+ countingStream->write((uint64_t*)&cgen_var_157, 1 * 8);
countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
marshal_VkBindSparseInfo(countingStream, (VkBindSparseInfo*)(local_pBindInfo + i));
}
- uint64_t cgen_var_154;
- countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_154, 1);
- countingStream->write((uint64_t*)&cgen_var_154, 1 * 8);
+ uint64_t cgen_var_158;
+ countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_158, 1);
+ countingStream->write((uint64_t*)&cgen_var_158, 1 * 8);
}
uint32_t packetSize_vkQueueBindSparse = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkQueueBindSparse = OP_vkQueueBindSparse;
stream->write(&opcode_vkQueueBindSparse, sizeof(uint32_t));
stream->write(&packetSize_vkQueueBindSparse, sizeof(uint32_t));
- uint64_t cgen_var_155;
- stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_155, 1);
- stream->write((uint64_t*)&cgen_var_155, 1 * 8);
+ uint64_t cgen_var_159;
+ stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_159, 1);
+ stream->write((uint64_t*)&cgen_var_159, 1 * 8);
stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
marshal_VkBindSparseInfo(stream, (VkBindSparseInfo*)(local_pBindInfo + i));
}
- uint64_t cgen_var_156;
- stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_156, 1);
- stream->write((uint64_t*)&cgen_var_156, 1 * 8);
+ uint64_t cgen_var_160;
+ stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_160, 1);
+ stream->write((uint64_t*)&cgen_var_160, 1 * 8);
AEMU_SCOPED_TRACE("vkQueueBindSparse readParams");
AEMU_SCOPED_TRACE("vkQueueBindSparse returnUnmarshal");
VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
@@ -2503,6 +2645,7 @@
const VkAllocationCallbacks* pAllocator,
VkFence* pFence)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateFence encode");
mImpl->log("start vkCreateFence");
auto stream = mImpl->stream();
@@ -2537,47 +2680,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_157;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_157, 1);
- countingStream->write((uint64_t*)&cgen_var_157, 1 * 8);
+ uint64_t cgen_var_161;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_161, 1);
+ countingStream->write((uint64_t*)&cgen_var_161, 1 * 8);
marshal_VkFenceCreateInfo(countingStream, (VkFenceCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_158 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_158);
+ uint64_t cgen_var_162 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_162);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_159;
- countingStream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_159, 1);
- countingStream->write((uint64_t*)&cgen_var_159, 8);
+ uint64_t cgen_var_163;
+ countingStream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_163, 1);
+ countingStream->write((uint64_t*)&cgen_var_163, 8);
}
uint32_t packetSize_vkCreateFence = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateFence = OP_vkCreateFence;
stream->write(&opcode_vkCreateFence, sizeof(uint32_t));
stream->write(&packetSize_vkCreateFence, sizeof(uint32_t));
- uint64_t cgen_var_160;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_160, 1);
- stream->write((uint64_t*)&cgen_var_160, 1 * 8);
+ uint64_t cgen_var_164;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_164, 1);
+ stream->write((uint64_t*)&cgen_var_164, 1 * 8);
marshal_VkFenceCreateInfo(stream, (VkFenceCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_161 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_161);
+ uint64_t cgen_var_165 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_165);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_162;
- stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_162, 1);
- stream->write((uint64_t*)&cgen_var_162, 8);
+ uint64_t cgen_var_166;
+ stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_166, 1);
+ stream->write((uint64_t*)&cgen_var_166, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateFence readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_163;
- stream->read((uint64_t*)&cgen_var_163, 8);
- stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_163, (VkFence*)pFence, 1);
+ uint64_t cgen_var_167;
+ stream->read((uint64_t*)&cgen_var_167, 8);
+ stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_167, (VkFence*)pFence, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateFence returnUnmarshal");
VkResult vkCreateFence_VkResult_return = (VkResult)0;
@@ -2594,6 +2737,7 @@
VkFence fence,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyFence encode");
mImpl->log("start vkDestroyFence");
auto stream = mImpl->stream();
@@ -2619,15 +2763,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_164;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_164, 1);
- countingStream->write((uint64_t*)&cgen_var_164, 1 * 8);
- uint64_t cgen_var_165;
- countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_165, 1);
- countingStream->write((uint64_t*)&cgen_var_165, 1 * 8);
+ uint64_t cgen_var_168;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_168, 1);
+ countingStream->write((uint64_t*)&cgen_var_168, 1 * 8);
+ uint64_t cgen_var_169;
+ countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_169, 1);
+ countingStream->write((uint64_t*)&cgen_var_169, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_166 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_166);
+ uint64_t cgen_var_170 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_170);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -2638,15 +2782,15 @@
uint32_t opcode_vkDestroyFence = OP_vkDestroyFence;
stream->write(&opcode_vkDestroyFence, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyFence, sizeof(uint32_t));
- uint64_t cgen_var_167;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_167, 1);
- stream->write((uint64_t*)&cgen_var_167, 1 * 8);
- uint64_t cgen_var_168;
- stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_168, 1);
- stream->write((uint64_t*)&cgen_var_168, 1 * 8);
+ uint64_t cgen_var_171;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_171, 1);
+ stream->write((uint64_t*)&cgen_var_171, 1 * 8);
+ uint64_t cgen_var_172;
+ stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_172, 1);
+ stream->write((uint64_t*)&cgen_var_172, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_169 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_169);
+ uint64_t cgen_var_173 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_173);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -2662,6 +2806,7 @@
uint32_t fenceCount,
const VkFence* pFences)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkResetFences encode");
mImpl->log("start vkResetFences");
auto stream = mImpl->stream();
@@ -2681,16 +2826,16 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_170;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_170, 1);
- countingStream->write((uint64_t*)&cgen_var_170, 1 * 8);
+ uint64_t cgen_var_174;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_174, 1);
+ countingStream->write((uint64_t*)&cgen_var_174, 1 * 8);
countingStream->write((uint32_t*)&local_fenceCount, sizeof(uint32_t));
if (((fenceCount)))
{
- uint64_t* cgen_var_171;
- countingStream->alloc((void**)&cgen_var_171, ((fenceCount)) * 8);
- countingStream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_171, ((fenceCount)));
- countingStream->write((uint64_t*)cgen_var_171, ((fenceCount)) * 8);
+ uint64_t* cgen_var_175;
+ countingStream->alloc((void**)&cgen_var_175, ((fenceCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_175, ((fenceCount)));
+ countingStream->write((uint64_t*)cgen_var_175, ((fenceCount)) * 8);
}
}
uint32_t packetSize_vkResetFences = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -2698,16 +2843,16 @@
uint32_t opcode_vkResetFences = OP_vkResetFences;
stream->write(&opcode_vkResetFences, sizeof(uint32_t));
stream->write(&packetSize_vkResetFences, sizeof(uint32_t));
- uint64_t cgen_var_172;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_172, 1);
- stream->write((uint64_t*)&cgen_var_172, 1 * 8);
+ uint64_t cgen_var_176;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_176, 1);
+ stream->write((uint64_t*)&cgen_var_176, 1 * 8);
stream->write((uint32_t*)&local_fenceCount, sizeof(uint32_t));
if (((fenceCount)))
{
- uint64_t* cgen_var_173;
- stream->alloc((void**)&cgen_var_173, ((fenceCount)) * 8);
- stream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_173, ((fenceCount)));
- stream->write((uint64_t*)cgen_var_173, ((fenceCount)) * 8);
+ uint64_t* cgen_var_177;
+ stream->alloc((void**)&cgen_var_177, ((fenceCount)) * 8);
+ stream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_177, ((fenceCount)));
+ stream->write((uint64_t*)cgen_var_177, ((fenceCount)) * 8);
}
AEMU_SCOPED_TRACE("vkResetFences readParams");
AEMU_SCOPED_TRACE("vkResetFences returnUnmarshal");
@@ -2724,6 +2869,7 @@
VkDevice device,
VkFence fence)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetFenceStatus encode");
mImpl->log("start vkGetFenceStatus");
auto stream = mImpl->stream();
@@ -2737,24 +2883,24 @@
local_fence = fence;
countingStream->rewind();
{
- uint64_t cgen_var_174;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_174, 1);
- countingStream->write((uint64_t*)&cgen_var_174, 1 * 8);
- uint64_t cgen_var_175;
- countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_175, 1);
- countingStream->write((uint64_t*)&cgen_var_175, 1 * 8);
+ uint64_t cgen_var_178;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_178, 1);
+ countingStream->write((uint64_t*)&cgen_var_178, 1 * 8);
+ uint64_t cgen_var_179;
+ countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_179, 1);
+ countingStream->write((uint64_t*)&cgen_var_179, 1 * 8);
}
uint32_t packetSize_vkGetFenceStatus = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkGetFenceStatus = OP_vkGetFenceStatus;
stream->write(&opcode_vkGetFenceStatus, sizeof(uint32_t));
stream->write(&packetSize_vkGetFenceStatus, sizeof(uint32_t));
- uint64_t cgen_var_176;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_176, 1);
- stream->write((uint64_t*)&cgen_var_176, 1 * 8);
- uint64_t cgen_var_177;
- stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_177, 1);
- stream->write((uint64_t*)&cgen_var_177, 1 * 8);
+ uint64_t cgen_var_180;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_180, 1);
+ stream->write((uint64_t*)&cgen_var_180, 1 * 8);
+ uint64_t cgen_var_181;
+ stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_181, 1);
+ stream->write((uint64_t*)&cgen_var_181, 1 * 8);
AEMU_SCOPED_TRACE("vkGetFenceStatus readParams");
AEMU_SCOPED_TRACE("vkGetFenceStatus returnUnmarshal");
VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
@@ -2773,6 +2919,7 @@
VkBool32 waitAll,
uint64_t timeout)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkWaitForFences encode");
mImpl->log("start vkWaitForFences");
auto stream = mImpl->stream();
@@ -2796,16 +2943,16 @@
local_timeout = timeout;
countingStream->rewind();
{
- uint64_t cgen_var_178;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_178, 1);
- countingStream->write((uint64_t*)&cgen_var_178, 1 * 8);
+ uint64_t cgen_var_182;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_182, 1);
+ countingStream->write((uint64_t*)&cgen_var_182, 1 * 8);
countingStream->write((uint32_t*)&local_fenceCount, sizeof(uint32_t));
if (((fenceCount)))
{
- uint64_t* cgen_var_179;
- countingStream->alloc((void**)&cgen_var_179, ((fenceCount)) * 8);
- countingStream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_179, ((fenceCount)));
- countingStream->write((uint64_t*)cgen_var_179, ((fenceCount)) * 8);
+ uint64_t* cgen_var_183;
+ countingStream->alloc((void**)&cgen_var_183, ((fenceCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_183, ((fenceCount)));
+ countingStream->write((uint64_t*)cgen_var_183, ((fenceCount)) * 8);
}
countingStream->write((VkBool32*)&local_waitAll, sizeof(VkBool32));
countingStream->write((uint64_t*)&local_timeout, sizeof(uint64_t));
@@ -2815,16 +2962,16 @@
uint32_t opcode_vkWaitForFences = OP_vkWaitForFences;
stream->write(&opcode_vkWaitForFences, sizeof(uint32_t));
stream->write(&packetSize_vkWaitForFences, sizeof(uint32_t));
- uint64_t cgen_var_180;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_180, 1);
- stream->write((uint64_t*)&cgen_var_180, 1 * 8);
+ uint64_t cgen_var_184;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_184, 1);
+ stream->write((uint64_t*)&cgen_var_184, 1 * 8);
stream->write((uint32_t*)&local_fenceCount, sizeof(uint32_t));
if (((fenceCount)))
{
- uint64_t* cgen_var_181;
- stream->alloc((void**)&cgen_var_181, ((fenceCount)) * 8);
- stream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_181, ((fenceCount)));
- stream->write((uint64_t*)cgen_var_181, ((fenceCount)) * 8);
+ uint64_t* cgen_var_185;
+ stream->alloc((void**)&cgen_var_185, ((fenceCount)) * 8);
+ stream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_185, ((fenceCount)));
+ stream->write((uint64_t*)cgen_var_185, ((fenceCount)) * 8);
}
stream->write((VkBool32*)&local_waitAll, sizeof(VkBool32));
stream->write((uint64_t*)&local_timeout, sizeof(uint64_t));
@@ -2845,6 +2992,7 @@
const VkAllocationCallbacks* pAllocator,
VkSemaphore* pSemaphore)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateSemaphore encode");
mImpl->log("start vkCreateSemaphore");
auto stream = mImpl->stream();
@@ -2879,47 +3027,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_182;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_182, 1);
- countingStream->write((uint64_t*)&cgen_var_182, 1 * 8);
+ uint64_t cgen_var_186;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_186, 1);
+ countingStream->write((uint64_t*)&cgen_var_186, 1 * 8);
marshal_VkSemaphoreCreateInfo(countingStream, (VkSemaphoreCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_183 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_183);
+ uint64_t cgen_var_187 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_187);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_184;
- countingStream->handleMapping()->mapHandles_VkSemaphore_u64(pSemaphore, &cgen_var_184, 1);
- countingStream->write((uint64_t*)&cgen_var_184, 8);
+ uint64_t cgen_var_188;
+ countingStream->handleMapping()->mapHandles_VkSemaphore_u64(pSemaphore, &cgen_var_188, 1);
+ countingStream->write((uint64_t*)&cgen_var_188, 8);
}
uint32_t packetSize_vkCreateSemaphore = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateSemaphore = OP_vkCreateSemaphore;
stream->write(&opcode_vkCreateSemaphore, sizeof(uint32_t));
stream->write(&packetSize_vkCreateSemaphore, sizeof(uint32_t));
- uint64_t cgen_var_185;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_185, 1);
- stream->write((uint64_t*)&cgen_var_185, 1 * 8);
+ uint64_t cgen_var_189;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_189, 1);
+ stream->write((uint64_t*)&cgen_var_189, 1 * 8);
marshal_VkSemaphoreCreateInfo(stream, (VkSemaphoreCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_186 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_186);
+ uint64_t cgen_var_190 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_190);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_187;
- stream->handleMapping()->mapHandles_VkSemaphore_u64(pSemaphore, &cgen_var_187, 1);
- stream->write((uint64_t*)&cgen_var_187, 8);
+ uint64_t cgen_var_191;
+ stream->handleMapping()->mapHandles_VkSemaphore_u64(pSemaphore, &cgen_var_191, 1);
+ stream->write((uint64_t*)&cgen_var_191, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateSemaphore readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_188;
- stream->read((uint64_t*)&cgen_var_188, 8);
- stream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_188, (VkSemaphore*)pSemaphore, 1);
+ uint64_t cgen_var_192;
+ stream->read((uint64_t*)&cgen_var_192, 8);
+ stream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_192, (VkSemaphore*)pSemaphore, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateSemaphore returnUnmarshal");
VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
@@ -2936,6 +3084,7 @@
VkSemaphore semaphore,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroySemaphore encode");
mImpl->log("start vkDestroySemaphore");
auto stream = mImpl->stream();
@@ -2961,15 +3110,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_189;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_189, 1);
- countingStream->write((uint64_t*)&cgen_var_189, 1 * 8);
- uint64_t cgen_var_190;
- countingStream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_190, 1);
- countingStream->write((uint64_t*)&cgen_var_190, 1 * 8);
+ uint64_t cgen_var_193;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_193, 1);
+ countingStream->write((uint64_t*)&cgen_var_193, 1 * 8);
+ uint64_t cgen_var_194;
+ countingStream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_194, 1);
+ countingStream->write((uint64_t*)&cgen_var_194, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_191 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_191);
+ uint64_t cgen_var_195 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_195);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -2980,15 +3129,15 @@
uint32_t opcode_vkDestroySemaphore = OP_vkDestroySemaphore;
stream->write(&opcode_vkDestroySemaphore, sizeof(uint32_t));
stream->write(&packetSize_vkDestroySemaphore, sizeof(uint32_t));
- uint64_t cgen_var_192;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_192, 1);
- stream->write((uint64_t*)&cgen_var_192, 1 * 8);
- uint64_t cgen_var_193;
- stream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_193, 1);
- stream->write((uint64_t*)&cgen_var_193, 1 * 8);
+ uint64_t cgen_var_196;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_196, 1);
+ stream->write((uint64_t*)&cgen_var_196, 1 * 8);
+ uint64_t cgen_var_197;
+ stream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_197, 1);
+ stream->write((uint64_t*)&cgen_var_197, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_194 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_194);
+ uint64_t cgen_var_198 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_198);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3005,6 +3154,7 @@
const VkAllocationCallbacks* pAllocator,
VkEvent* pEvent)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateEvent encode");
mImpl->log("start vkCreateEvent");
auto stream = mImpl->stream();
@@ -3039,47 +3189,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_195;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_195, 1);
- countingStream->write((uint64_t*)&cgen_var_195, 1 * 8);
+ uint64_t cgen_var_199;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_199, 1);
+ countingStream->write((uint64_t*)&cgen_var_199, 1 * 8);
marshal_VkEventCreateInfo(countingStream, (VkEventCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_196 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_196);
+ uint64_t cgen_var_200 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_200);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_197;
- countingStream->handleMapping()->mapHandles_VkEvent_u64(pEvent, &cgen_var_197, 1);
- countingStream->write((uint64_t*)&cgen_var_197, 8);
+ uint64_t cgen_var_201;
+ countingStream->handleMapping()->mapHandles_VkEvent_u64(pEvent, &cgen_var_201, 1);
+ countingStream->write((uint64_t*)&cgen_var_201, 8);
}
uint32_t packetSize_vkCreateEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateEvent = OP_vkCreateEvent;
stream->write(&opcode_vkCreateEvent, sizeof(uint32_t));
stream->write(&packetSize_vkCreateEvent, sizeof(uint32_t));
- uint64_t cgen_var_198;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_198, 1);
- stream->write((uint64_t*)&cgen_var_198, 1 * 8);
+ uint64_t cgen_var_202;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_202, 1);
+ stream->write((uint64_t*)&cgen_var_202, 1 * 8);
marshal_VkEventCreateInfo(stream, (VkEventCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_199 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_199);
+ uint64_t cgen_var_203 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_203);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_200;
- stream->handleMapping()->mapHandles_VkEvent_u64(pEvent, &cgen_var_200, 1);
- stream->write((uint64_t*)&cgen_var_200, 8);
+ uint64_t cgen_var_204;
+ stream->handleMapping()->mapHandles_VkEvent_u64(pEvent, &cgen_var_204, 1);
+ stream->write((uint64_t*)&cgen_var_204, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateEvent readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_201;
- stream->read((uint64_t*)&cgen_var_201, 8);
- stream->handleMapping()->mapHandles_u64_VkEvent(&cgen_var_201, (VkEvent*)pEvent, 1);
+ uint64_t cgen_var_205;
+ stream->read((uint64_t*)&cgen_var_205, 8);
+ stream->handleMapping()->mapHandles_u64_VkEvent(&cgen_var_205, (VkEvent*)pEvent, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateEvent returnUnmarshal");
VkResult vkCreateEvent_VkResult_return = (VkResult)0;
@@ -3096,6 +3246,7 @@
VkEvent event,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyEvent encode");
mImpl->log("start vkDestroyEvent");
auto stream = mImpl->stream();
@@ -3121,15 +3272,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_202;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_202, 1);
- countingStream->write((uint64_t*)&cgen_var_202, 1 * 8);
- uint64_t cgen_var_203;
- countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_203, 1);
- countingStream->write((uint64_t*)&cgen_var_203, 1 * 8);
+ uint64_t cgen_var_206;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_206, 1);
+ countingStream->write((uint64_t*)&cgen_var_206, 1 * 8);
+ uint64_t cgen_var_207;
+ countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_207, 1);
+ countingStream->write((uint64_t*)&cgen_var_207, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_204 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_204);
+ uint64_t cgen_var_208 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_208);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3140,15 +3291,15 @@
uint32_t opcode_vkDestroyEvent = OP_vkDestroyEvent;
stream->write(&opcode_vkDestroyEvent, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyEvent, sizeof(uint32_t));
- uint64_t cgen_var_205;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_205, 1);
- stream->write((uint64_t*)&cgen_var_205, 1 * 8);
- uint64_t cgen_var_206;
- stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_206, 1);
- stream->write((uint64_t*)&cgen_var_206, 1 * 8);
+ uint64_t cgen_var_209;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_209, 1);
+ stream->write((uint64_t*)&cgen_var_209, 1 * 8);
+ uint64_t cgen_var_210;
+ stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_210, 1);
+ stream->write((uint64_t*)&cgen_var_210, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_207 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_207);
+ uint64_t cgen_var_211 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_211);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3163,6 +3314,7 @@
VkDevice device,
VkEvent event)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetEventStatus encode");
mImpl->log("start vkGetEventStatus");
auto stream = mImpl->stream();
@@ -3176,52 +3328,6 @@
local_event = event;
countingStream->rewind();
{
- uint64_t cgen_var_208;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_208, 1);
- countingStream->write((uint64_t*)&cgen_var_208, 1 * 8);
- uint64_t cgen_var_209;
- countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_209, 1);
- countingStream->write((uint64_t*)&cgen_var_209, 1 * 8);
- }
- uint32_t packetSize_vkGetEventStatus = 4 + 4 + (uint32_t)countingStream->bytesWritten();
- countingStream->rewind();
- uint32_t opcode_vkGetEventStatus = OP_vkGetEventStatus;
- stream->write(&opcode_vkGetEventStatus, sizeof(uint32_t));
- stream->write(&packetSize_vkGetEventStatus, sizeof(uint32_t));
- uint64_t cgen_var_210;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_210, 1);
- stream->write((uint64_t*)&cgen_var_210, 1 * 8);
- uint64_t cgen_var_211;
- stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_211, 1);
- stream->write((uint64_t*)&cgen_var_211, 1 * 8);
- AEMU_SCOPED_TRACE("vkGetEventStatus readParams");
- AEMU_SCOPED_TRACE("vkGetEventStatus returnUnmarshal");
- VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
- stream->read(&vkGetEventStatus_VkResult_return, sizeof(VkResult));
- countingStream->clearPool();
- stream->clearPool();
- pool->freeAll();
- mImpl->log("finish vkGetEventStatus");;
- return vkGetEventStatus_VkResult_return;
-}
-
-VkResult VkEncoder::vkSetEvent(
- VkDevice device,
- VkEvent event)
-{
- AEMU_SCOPED_TRACE("vkSetEvent encode");
- mImpl->log("start vkSetEvent");
- auto stream = mImpl->stream();
- auto countingStream = mImpl->countingStream();
- auto resources = mImpl->resources();
- auto pool = mImpl->pool();
- stream->setHandleMapping(resources->unwrapMapping());
- VkDevice local_device;
- VkEvent local_event;
- local_device = device;
- local_event = event;
- countingStream->rewind();
- {
uint64_t cgen_var_212;
countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_212, 1);
countingStream->write((uint64_t*)&cgen_var_212, 1 * 8);
@@ -3229,34 +3335,35 @@
countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_213, 1);
countingStream->write((uint64_t*)&cgen_var_213, 1 * 8);
}
- uint32_t packetSize_vkSetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ uint32_t packetSize_vkGetEventStatus = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
- uint32_t opcode_vkSetEvent = OP_vkSetEvent;
- stream->write(&opcode_vkSetEvent, sizeof(uint32_t));
- stream->write(&packetSize_vkSetEvent, sizeof(uint32_t));
+ uint32_t opcode_vkGetEventStatus = OP_vkGetEventStatus;
+ stream->write(&opcode_vkGetEventStatus, sizeof(uint32_t));
+ stream->write(&packetSize_vkGetEventStatus, sizeof(uint32_t));
uint64_t cgen_var_214;
stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_214, 1);
stream->write((uint64_t*)&cgen_var_214, 1 * 8);
uint64_t cgen_var_215;
stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_215, 1);
stream->write((uint64_t*)&cgen_var_215, 1 * 8);
- AEMU_SCOPED_TRACE("vkSetEvent readParams");
- AEMU_SCOPED_TRACE("vkSetEvent returnUnmarshal");
- VkResult vkSetEvent_VkResult_return = (VkResult)0;
- stream->read(&vkSetEvent_VkResult_return, sizeof(VkResult));
+ AEMU_SCOPED_TRACE("vkGetEventStatus readParams");
+ AEMU_SCOPED_TRACE("vkGetEventStatus returnUnmarshal");
+ VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
+ stream->read(&vkGetEventStatus_VkResult_return, sizeof(VkResult));
countingStream->clearPool();
stream->clearPool();
pool->freeAll();
- mImpl->log("finish vkSetEvent");;
- return vkSetEvent_VkResult_return;
+ mImpl->log("finish vkGetEventStatus");;
+ return vkGetEventStatus_VkResult_return;
}
-VkResult VkEncoder::vkResetEvent(
+VkResult VkEncoder::vkSetEvent(
VkDevice device,
VkEvent event)
{
- AEMU_SCOPED_TRACE("vkResetEvent encode");
- mImpl->log("start vkResetEvent");
+ AutoLock encoderLock(mImpl->lock);
+ AEMU_SCOPED_TRACE("vkSetEvent encode");
+ mImpl->log("start vkSetEvent");
auto stream = mImpl->stream();
auto countingStream = mImpl->countingStream();
auto resources = mImpl->resources();
@@ -3275,17 +3382,64 @@
countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_217, 1);
countingStream->write((uint64_t*)&cgen_var_217, 1 * 8);
}
- uint32_t packetSize_vkResetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ uint32_t packetSize_vkSetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
- uint32_t opcode_vkResetEvent = OP_vkResetEvent;
- stream->write(&opcode_vkResetEvent, sizeof(uint32_t));
- stream->write(&packetSize_vkResetEvent, sizeof(uint32_t));
+ uint32_t opcode_vkSetEvent = OP_vkSetEvent;
+ stream->write(&opcode_vkSetEvent, sizeof(uint32_t));
+ stream->write(&packetSize_vkSetEvent, sizeof(uint32_t));
uint64_t cgen_var_218;
stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_218, 1);
stream->write((uint64_t*)&cgen_var_218, 1 * 8);
uint64_t cgen_var_219;
stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_219, 1);
stream->write((uint64_t*)&cgen_var_219, 1 * 8);
+ AEMU_SCOPED_TRACE("vkSetEvent readParams");
+ AEMU_SCOPED_TRACE("vkSetEvent returnUnmarshal");
+ VkResult vkSetEvent_VkResult_return = (VkResult)0;
+ stream->read(&vkSetEvent_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ mImpl->log("finish vkSetEvent");;
+ return vkSetEvent_VkResult_return;
+}
+
+VkResult VkEncoder::vkResetEvent(
+ VkDevice device,
+ VkEvent event)
+{
+ AutoLock encoderLock(mImpl->lock);
+ AEMU_SCOPED_TRACE("vkResetEvent encode");
+ mImpl->log("start vkResetEvent");
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkEvent local_event;
+ local_device = device;
+ local_event = event;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_220;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_220, 1);
+ countingStream->write((uint64_t*)&cgen_var_220, 1 * 8);
+ uint64_t cgen_var_221;
+ countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_221, 1);
+ countingStream->write((uint64_t*)&cgen_var_221, 1 * 8);
+ }
+ uint32_t packetSize_vkResetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkResetEvent = OP_vkResetEvent;
+ stream->write(&opcode_vkResetEvent, sizeof(uint32_t));
+ stream->write(&packetSize_vkResetEvent, sizeof(uint32_t));
+ uint64_t cgen_var_222;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_222, 1);
+ stream->write((uint64_t*)&cgen_var_222, 1 * 8);
+ uint64_t cgen_var_223;
+ stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_223, 1);
+ stream->write((uint64_t*)&cgen_var_223, 1 * 8);
AEMU_SCOPED_TRACE("vkResetEvent readParams");
AEMU_SCOPED_TRACE("vkResetEvent returnUnmarshal");
VkResult vkResetEvent_VkResult_return = (VkResult)0;
@@ -3303,6 +3457,7 @@
const VkAllocationCallbacks* pAllocator,
VkQueryPool* pQueryPool)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateQueryPool encode");
mImpl->log("start vkCreateQueryPool");
auto stream = mImpl->stream();
@@ -3337,47 +3492,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_220;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_220, 1);
- countingStream->write((uint64_t*)&cgen_var_220, 1 * 8);
+ uint64_t cgen_var_224;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_224, 1);
+ countingStream->write((uint64_t*)&cgen_var_224, 1 * 8);
marshal_VkQueryPoolCreateInfo(countingStream, (VkQueryPoolCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_221 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_221);
+ uint64_t cgen_var_225 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_225);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_222;
- countingStream->handleMapping()->mapHandles_VkQueryPool_u64(pQueryPool, &cgen_var_222, 1);
- countingStream->write((uint64_t*)&cgen_var_222, 8);
+ uint64_t cgen_var_226;
+ countingStream->handleMapping()->mapHandles_VkQueryPool_u64(pQueryPool, &cgen_var_226, 1);
+ countingStream->write((uint64_t*)&cgen_var_226, 8);
}
uint32_t packetSize_vkCreateQueryPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateQueryPool = OP_vkCreateQueryPool;
stream->write(&opcode_vkCreateQueryPool, sizeof(uint32_t));
stream->write(&packetSize_vkCreateQueryPool, sizeof(uint32_t));
- uint64_t cgen_var_223;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_223, 1);
- stream->write((uint64_t*)&cgen_var_223, 1 * 8);
+ uint64_t cgen_var_227;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_227, 1);
+ stream->write((uint64_t*)&cgen_var_227, 1 * 8);
marshal_VkQueryPoolCreateInfo(stream, (VkQueryPoolCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_224 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_224);
+ uint64_t cgen_var_228 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_228);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_225;
- stream->handleMapping()->mapHandles_VkQueryPool_u64(pQueryPool, &cgen_var_225, 1);
- stream->write((uint64_t*)&cgen_var_225, 8);
+ uint64_t cgen_var_229;
+ stream->handleMapping()->mapHandles_VkQueryPool_u64(pQueryPool, &cgen_var_229, 1);
+ stream->write((uint64_t*)&cgen_var_229, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateQueryPool readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_226;
- stream->read((uint64_t*)&cgen_var_226, 8);
- stream->handleMapping()->mapHandles_u64_VkQueryPool(&cgen_var_226, (VkQueryPool*)pQueryPool, 1);
+ uint64_t cgen_var_230;
+ stream->read((uint64_t*)&cgen_var_230, 8);
+ stream->handleMapping()->mapHandles_u64_VkQueryPool(&cgen_var_230, (VkQueryPool*)pQueryPool, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateQueryPool returnUnmarshal");
VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
@@ -3394,6 +3549,7 @@
VkQueryPool queryPool,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyQueryPool encode");
mImpl->log("start vkDestroyQueryPool");
auto stream = mImpl->stream();
@@ -3419,15 +3575,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_227;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_227, 1);
- countingStream->write((uint64_t*)&cgen_var_227, 1 * 8);
- uint64_t cgen_var_228;
- countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_228, 1);
- countingStream->write((uint64_t*)&cgen_var_228, 1 * 8);
+ uint64_t cgen_var_231;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_231, 1);
+ countingStream->write((uint64_t*)&cgen_var_231, 1 * 8);
+ uint64_t cgen_var_232;
+ countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_232, 1);
+ countingStream->write((uint64_t*)&cgen_var_232, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_229 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_229);
+ uint64_t cgen_var_233 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_233);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3438,15 +3594,15 @@
uint32_t opcode_vkDestroyQueryPool = OP_vkDestroyQueryPool;
stream->write(&opcode_vkDestroyQueryPool, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyQueryPool, sizeof(uint32_t));
- uint64_t cgen_var_230;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_230, 1);
- stream->write((uint64_t*)&cgen_var_230, 1 * 8);
- uint64_t cgen_var_231;
- stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_231, 1);
- stream->write((uint64_t*)&cgen_var_231, 1 * 8);
+ uint64_t cgen_var_234;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_234, 1);
+ stream->write((uint64_t*)&cgen_var_234, 1 * 8);
+ uint64_t cgen_var_235;
+ stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_235, 1);
+ stream->write((uint64_t*)&cgen_var_235, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_232 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_232);
+ uint64_t cgen_var_236 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_236);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3467,6 +3623,7 @@
VkDeviceSize stride,
VkQueryResultFlags flags)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetQueryPoolResults encode");
mImpl->log("start vkGetQueryPoolResults");
auto stream = mImpl->stream();
@@ -3490,16 +3647,16 @@
local_flags = flags;
countingStream->rewind();
{
- uint64_t cgen_var_233;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_233, 1);
- countingStream->write((uint64_t*)&cgen_var_233, 1 * 8);
- uint64_t cgen_var_234;
- countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_234, 1);
- countingStream->write((uint64_t*)&cgen_var_234, 1 * 8);
+ uint64_t cgen_var_237;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_237, 1);
+ countingStream->write((uint64_t*)&cgen_var_237, 1 * 8);
+ uint64_t cgen_var_238;
+ countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_238, 1);
+ countingStream->write((uint64_t*)&cgen_var_238, 1 * 8);
countingStream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
- uint64_t cgen_var_235 = (uint64_t)local_dataSize;
- countingStream->putBe64(cgen_var_235);
+ uint64_t cgen_var_239 = (uint64_t)local_dataSize;
+ countingStream->putBe64(cgen_var_239);
countingStream->write((void*)pData, ((dataSize)) * sizeof(uint8_t));
countingStream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize));
countingStream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
@@ -3509,16 +3666,16 @@
uint32_t opcode_vkGetQueryPoolResults = OP_vkGetQueryPoolResults;
stream->write(&opcode_vkGetQueryPoolResults, sizeof(uint32_t));
stream->write(&packetSize_vkGetQueryPoolResults, sizeof(uint32_t));
- uint64_t cgen_var_236;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_236, 1);
- stream->write((uint64_t*)&cgen_var_236, 1 * 8);
- uint64_t cgen_var_237;
- stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_237, 1);
- stream->write((uint64_t*)&cgen_var_237, 1 * 8);
+ uint64_t cgen_var_240;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_240, 1);
+ stream->write((uint64_t*)&cgen_var_240, 1 * 8);
+ uint64_t cgen_var_241;
+ stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_241, 1);
+ stream->write((uint64_t*)&cgen_var_241, 1 * 8);
stream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
stream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
- uint64_t cgen_var_238 = (uint64_t)local_dataSize;
- stream->putBe64(cgen_var_238);
+ uint64_t cgen_var_242 = (uint64_t)local_dataSize;
+ stream->putBe64(cgen_var_242);
stream->write((void*)pData, ((dataSize)) * sizeof(uint8_t));
stream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize));
stream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
@@ -3540,6 +3697,7 @@
const VkAllocationCallbacks* pAllocator,
VkBuffer* pBuffer)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateBuffer encode");
mImpl->log("start vkCreateBuffer");
auto stream = mImpl->stream();
@@ -3574,47 +3732,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_239;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_239, 1);
- countingStream->write((uint64_t*)&cgen_var_239, 1 * 8);
+ uint64_t cgen_var_243;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_243, 1);
+ countingStream->write((uint64_t*)&cgen_var_243, 1 * 8);
marshal_VkBufferCreateInfo(countingStream, (VkBufferCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_240 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_240);
+ uint64_t cgen_var_244 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_244);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_241;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(pBuffer, &cgen_var_241, 1);
- countingStream->write((uint64_t*)&cgen_var_241, 8);
+ uint64_t cgen_var_245;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(pBuffer, &cgen_var_245, 1);
+ countingStream->write((uint64_t*)&cgen_var_245, 8);
}
uint32_t packetSize_vkCreateBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateBuffer = OP_vkCreateBuffer;
stream->write(&opcode_vkCreateBuffer, sizeof(uint32_t));
stream->write(&packetSize_vkCreateBuffer, sizeof(uint32_t));
- uint64_t cgen_var_242;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_242, 1);
- stream->write((uint64_t*)&cgen_var_242, 1 * 8);
+ uint64_t cgen_var_246;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_246, 1);
+ stream->write((uint64_t*)&cgen_var_246, 1 * 8);
marshal_VkBufferCreateInfo(stream, (VkBufferCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_243 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_243);
+ uint64_t cgen_var_247 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_247);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_244;
- stream->handleMapping()->mapHandles_VkBuffer_u64(pBuffer, &cgen_var_244, 1);
- stream->write((uint64_t*)&cgen_var_244, 8);
+ uint64_t cgen_var_248;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(pBuffer, &cgen_var_248, 1);
+ stream->write((uint64_t*)&cgen_var_248, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateBuffer readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_245;
- stream->read((uint64_t*)&cgen_var_245, 8);
- stream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_245, (VkBuffer*)pBuffer, 1);
+ uint64_t cgen_var_249;
+ stream->read((uint64_t*)&cgen_var_249, 8);
+ stream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_249, (VkBuffer*)pBuffer, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateBuffer returnUnmarshal");
VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
@@ -3631,6 +3789,7 @@
VkBuffer buffer,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyBuffer encode");
mImpl->log("start vkDestroyBuffer");
auto stream = mImpl->stream();
@@ -3656,15 +3815,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_246;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_246, 1);
- countingStream->write((uint64_t*)&cgen_var_246, 1 * 8);
- uint64_t cgen_var_247;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_247, 1);
- countingStream->write((uint64_t*)&cgen_var_247, 1 * 8);
+ uint64_t cgen_var_250;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_250, 1);
+ countingStream->write((uint64_t*)&cgen_var_250, 1 * 8);
+ uint64_t cgen_var_251;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_251, 1);
+ countingStream->write((uint64_t*)&cgen_var_251, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_248 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_248);
+ uint64_t cgen_var_252 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_252);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3675,15 +3834,15 @@
uint32_t opcode_vkDestroyBuffer = OP_vkDestroyBuffer;
stream->write(&opcode_vkDestroyBuffer, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyBuffer, sizeof(uint32_t));
- uint64_t cgen_var_249;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_249, 1);
- stream->write((uint64_t*)&cgen_var_249, 1 * 8);
- uint64_t cgen_var_250;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_250, 1);
- stream->write((uint64_t*)&cgen_var_250, 1 * 8);
+ uint64_t cgen_var_253;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_253, 1);
+ stream->write((uint64_t*)&cgen_var_253, 1 * 8);
+ uint64_t cgen_var_254;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_254, 1);
+ stream->write((uint64_t*)&cgen_var_254, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_251 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_251);
+ uint64_t cgen_var_255 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_255);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3700,6 +3859,7 @@
const VkAllocationCallbacks* pAllocator,
VkBufferView* pView)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateBufferView encode");
mImpl->log("start vkCreateBufferView");
auto stream = mImpl->stream();
@@ -3734,47 +3894,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_252;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_252, 1);
- countingStream->write((uint64_t*)&cgen_var_252, 1 * 8);
+ uint64_t cgen_var_256;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_256, 1);
+ countingStream->write((uint64_t*)&cgen_var_256, 1 * 8);
marshal_VkBufferViewCreateInfo(countingStream, (VkBufferViewCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_253 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_253);
+ uint64_t cgen_var_257 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_257);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_254;
- countingStream->handleMapping()->mapHandles_VkBufferView_u64(pView, &cgen_var_254, 1);
- countingStream->write((uint64_t*)&cgen_var_254, 8);
+ uint64_t cgen_var_258;
+ countingStream->handleMapping()->mapHandles_VkBufferView_u64(pView, &cgen_var_258, 1);
+ countingStream->write((uint64_t*)&cgen_var_258, 8);
}
uint32_t packetSize_vkCreateBufferView = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateBufferView = OP_vkCreateBufferView;
stream->write(&opcode_vkCreateBufferView, sizeof(uint32_t));
stream->write(&packetSize_vkCreateBufferView, sizeof(uint32_t));
- uint64_t cgen_var_255;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_255, 1);
- stream->write((uint64_t*)&cgen_var_255, 1 * 8);
+ uint64_t cgen_var_259;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_259, 1);
+ stream->write((uint64_t*)&cgen_var_259, 1 * 8);
marshal_VkBufferViewCreateInfo(stream, (VkBufferViewCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_256 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_256);
+ uint64_t cgen_var_260 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_260);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_257;
- stream->handleMapping()->mapHandles_VkBufferView_u64(pView, &cgen_var_257, 1);
- stream->write((uint64_t*)&cgen_var_257, 8);
+ uint64_t cgen_var_261;
+ stream->handleMapping()->mapHandles_VkBufferView_u64(pView, &cgen_var_261, 1);
+ stream->write((uint64_t*)&cgen_var_261, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateBufferView readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_258;
- stream->read((uint64_t*)&cgen_var_258, 8);
- stream->handleMapping()->mapHandles_u64_VkBufferView(&cgen_var_258, (VkBufferView*)pView, 1);
+ uint64_t cgen_var_262;
+ stream->read((uint64_t*)&cgen_var_262, 8);
+ stream->handleMapping()->mapHandles_u64_VkBufferView(&cgen_var_262, (VkBufferView*)pView, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateBufferView returnUnmarshal");
VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
@@ -3791,6 +3951,7 @@
VkBufferView bufferView,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyBufferView encode");
mImpl->log("start vkDestroyBufferView");
auto stream = mImpl->stream();
@@ -3816,15 +3977,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_259;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_259, 1);
- countingStream->write((uint64_t*)&cgen_var_259, 1 * 8);
- uint64_t cgen_var_260;
- countingStream->handleMapping()->mapHandles_VkBufferView_u64(&local_bufferView, &cgen_var_260, 1);
- countingStream->write((uint64_t*)&cgen_var_260, 1 * 8);
+ uint64_t cgen_var_263;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_263, 1);
+ countingStream->write((uint64_t*)&cgen_var_263, 1 * 8);
+ uint64_t cgen_var_264;
+ countingStream->handleMapping()->mapHandles_VkBufferView_u64(&local_bufferView, &cgen_var_264, 1);
+ countingStream->write((uint64_t*)&cgen_var_264, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_261 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_261);
+ uint64_t cgen_var_265 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_265);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3835,15 +3996,15 @@
uint32_t opcode_vkDestroyBufferView = OP_vkDestroyBufferView;
stream->write(&opcode_vkDestroyBufferView, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyBufferView, sizeof(uint32_t));
- uint64_t cgen_var_262;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_262, 1);
- stream->write((uint64_t*)&cgen_var_262, 1 * 8);
- uint64_t cgen_var_263;
- stream->handleMapping()->mapHandles_VkBufferView_u64(&local_bufferView, &cgen_var_263, 1);
- stream->write((uint64_t*)&cgen_var_263, 1 * 8);
+ uint64_t cgen_var_266;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_266, 1);
+ stream->write((uint64_t*)&cgen_var_266, 1 * 8);
+ uint64_t cgen_var_267;
+ stream->handleMapping()->mapHandles_VkBufferView_u64(&local_bufferView, &cgen_var_267, 1);
+ stream->write((uint64_t*)&cgen_var_267, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_264 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_264);
+ uint64_t cgen_var_268 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_268);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3860,6 +4021,7 @@
const VkAllocationCallbacks* pAllocator,
VkImage* pImage)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateImage encode");
mImpl->log("start vkCreateImage");
auto stream = mImpl->stream();
@@ -3895,47 +4057,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_265;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_265, 1);
- countingStream->write((uint64_t*)&cgen_var_265, 1 * 8);
+ uint64_t cgen_var_269;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_269, 1);
+ countingStream->write((uint64_t*)&cgen_var_269, 1 * 8);
marshal_VkImageCreateInfo(countingStream, (VkImageCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_266 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_266);
+ uint64_t cgen_var_270 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_270);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_267;
- countingStream->handleMapping()->mapHandles_VkImage_u64(pImage, &cgen_var_267, 1);
- countingStream->write((uint64_t*)&cgen_var_267, 8);
+ uint64_t cgen_var_271;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(pImage, &cgen_var_271, 1);
+ countingStream->write((uint64_t*)&cgen_var_271, 8);
}
uint32_t packetSize_vkCreateImage = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateImage = OP_vkCreateImage;
stream->write(&opcode_vkCreateImage, sizeof(uint32_t));
stream->write(&packetSize_vkCreateImage, sizeof(uint32_t));
- uint64_t cgen_var_268;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_268, 1);
- stream->write((uint64_t*)&cgen_var_268, 1 * 8);
+ uint64_t cgen_var_272;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_272, 1);
+ stream->write((uint64_t*)&cgen_var_272, 1 * 8);
marshal_VkImageCreateInfo(stream, (VkImageCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_269 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_269);
+ uint64_t cgen_var_273 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_273);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_270;
- stream->handleMapping()->mapHandles_VkImage_u64(pImage, &cgen_var_270, 1);
- stream->write((uint64_t*)&cgen_var_270, 8);
+ uint64_t cgen_var_274;
+ stream->handleMapping()->mapHandles_VkImage_u64(pImage, &cgen_var_274, 1);
+ stream->write((uint64_t*)&cgen_var_274, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateImage readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_271;
- stream->read((uint64_t*)&cgen_var_271, 8);
- stream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_271, (VkImage*)pImage, 1);
+ uint64_t cgen_var_275;
+ stream->read((uint64_t*)&cgen_var_275, 8);
+ stream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_275, (VkImage*)pImage, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateImage returnUnmarshal");
VkResult vkCreateImage_VkResult_return = (VkResult)0;
@@ -3952,6 +4114,7 @@
VkImage image,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyImage encode");
mImpl->log("start vkDestroyImage");
auto stream = mImpl->stream();
@@ -3977,15 +4140,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_272;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_272, 1);
- countingStream->write((uint64_t*)&cgen_var_272, 1 * 8);
- uint64_t cgen_var_273;
- countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_273, 1);
- countingStream->write((uint64_t*)&cgen_var_273, 1 * 8);
+ uint64_t cgen_var_276;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_276, 1);
+ countingStream->write((uint64_t*)&cgen_var_276, 1 * 8);
+ uint64_t cgen_var_277;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_277, 1);
+ countingStream->write((uint64_t*)&cgen_var_277, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_274 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_274);
+ uint64_t cgen_var_278 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_278);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -3996,15 +4159,15 @@
uint32_t opcode_vkDestroyImage = OP_vkDestroyImage;
stream->write(&opcode_vkDestroyImage, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyImage, sizeof(uint32_t));
- uint64_t cgen_var_275;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_275, 1);
- stream->write((uint64_t*)&cgen_var_275, 1 * 8);
- uint64_t cgen_var_276;
- stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_276, 1);
- stream->write((uint64_t*)&cgen_var_276, 1 * 8);
+ uint64_t cgen_var_279;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_279, 1);
+ stream->write((uint64_t*)&cgen_var_279, 1 * 8);
+ uint64_t cgen_var_280;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_280, 1);
+ stream->write((uint64_t*)&cgen_var_280, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_277 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_277);
+ uint64_t cgen_var_281 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_281);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4021,6 +4184,7 @@
const VkImageSubresource* pSubresource,
VkSubresourceLayout* pLayout)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout encode");
mImpl->log("start vkGetImageSubresourceLayout");
auto stream = mImpl->stream();
@@ -4045,12 +4209,12 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_278;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_278, 1);
- countingStream->write((uint64_t*)&cgen_var_278, 1 * 8);
- uint64_t cgen_var_279;
- countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_279, 1);
- countingStream->write((uint64_t*)&cgen_var_279, 1 * 8);
+ uint64_t cgen_var_282;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_282, 1);
+ countingStream->write((uint64_t*)&cgen_var_282, 1 * 8);
+ uint64_t cgen_var_283;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_283, 1);
+ countingStream->write((uint64_t*)&cgen_var_283, 1 * 8);
marshal_VkImageSubresource(countingStream, (VkImageSubresource*)(local_pSubresource));
marshal_VkSubresourceLayout(countingStream, (VkSubresourceLayout*)(pLayout));
}
@@ -4059,12 +4223,12 @@
uint32_t opcode_vkGetImageSubresourceLayout = OP_vkGetImageSubresourceLayout;
stream->write(&opcode_vkGetImageSubresourceLayout, sizeof(uint32_t));
stream->write(&packetSize_vkGetImageSubresourceLayout, sizeof(uint32_t));
- uint64_t cgen_var_280;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_280, 1);
- stream->write((uint64_t*)&cgen_var_280, 1 * 8);
- uint64_t cgen_var_281;
- stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_281, 1);
- stream->write((uint64_t*)&cgen_var_281, 1 * 8);
+ uint64_t cgen_var_284;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_284, 1);
+ stream->write((uint64_t*)&cgen_var_284, 1 * 8);
+ uint64_t cgen_var_285;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_285, 1);
+ stream->write((uint64_t*)&cgen_var_285, 1 * 8);
marshal_VkImageSubresource(stream, (VkImageSubresource*)(local_pSubresource));
marshal_VkSubresourceLayout(stream, (VkSubresourceLayout*)(pLayout));
AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout readParams");
@@ -4083,6 +4247,7 @@
const VkAllocationCallbacks* pAllocator,
VkImageView* pView)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateImageView encode");
mImpl->log("start vkCreateImageView");
auto stream = mImpl->stream();
@@ -4117,47 +4282,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_282;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_282, 1);
- countingStream->write((uint64_t*)&cgen_var_282, 1 * 8);
+ uint64_t cgen_var_286;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_286, 1);
+ countingStream->write((uint64_t*)&cgen_var_286, 1 * 8);
marshal_VkImageViewCreateInfo(countingStream, (VkImageViewCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_283 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_283);
+ uint64_t cgen_var_287 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_287);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_284;
- countingStream->handleMapping()->mapHandles_VkImageView_u64(pView, &cgen_var_284, 1);
- countingStream->write((uint64_t*)&cgen_var_284, 8);
+ uint64_t cgen_var_288;
+ countingStream->handleMapping()->mapHandles_VkImageView_u64(pView, &cgen_var_288, 1);
+ countingStream->write((uint64_t*)&cgen_var_288, 8);
}
uint32_t packetSize_vkCreateImageView = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateImageView = OP_vkCreateImageView;
stream->write(&opcode_vkCreateImageView, sizeof(uint32_t));
stream->write(&packetSize_vkCreateImageView, sizeof(uint32_t));
- uint64_t cgen_var_285;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_285, 1);
- stream->write((uint64_t*)&cgen_var_285, 1 * 8);
+ uint64_t cgen_var_289;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_289, 1);
+ stream->write((uint64_t*)&cgen_var_289, 1 * 8);
marshal_VkImageViewCreateInfo(stream, (VkImageViewCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_286 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_286);
+ uint64_t cgen_var_290 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_290);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_287;
- stream->handleMapping()->mapHandles_VkImageView_u64(pView, &cgen_var_287, 1);
- stream->write((uint64_t*)&cgen_var_287, 8);
+ uint64_t cgen_var_291;
+ stream->handleMapping()->mapHandles_VkImageView_u64(pView, &cgen_var_291, 1);
+ stream->write((uint64_t*)&cgen_var_291, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateImageView readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_288;
- stream->read((uint64_t*)&cgen_var_288, 8);
- stream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_288, (VkImageView*)pView, 1);
+ uint64_t cgen_var_292;
+ stream->read((uint64_t*)&cgen_var_292, 8);
+ stream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_292, (VkImageView*)pView, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateImageView returnUnmarshal");
VkResult vkCreateImageView_VkResult_return = (VkResult)0;
@@ -4174,6 +4339,7 @@
VkImageView imageView,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyImageView encode");
mImpl->log("start vkDestroyImageView");
auto stream = mImpl->stream();
@@ -4199,15 +4365,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_289;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_289, 1);
- countingStream->write((uint64_t*)&cgen_var_289, 1 * 8);
- uint64_t cgen_var_290;
- countingStream->handleMapping()->mapHandles_VkImageView_u64(&local_imageView, &cgen_var_290, 1);
- countingStream->write((uint64_t*)&cgen_var_290, 1 * 8);
+ uint64_t cgen_var_293;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_293, 1);
+ countingStream->write((uint64_t*)&cgen_var_293, 1 * 8);
+ uint64_t cgen_var_294;
+ countingStream->handleMapping()->mapHandles_VkImageView_u64(&local_imageView, &cgen_var_294, 1);
+ countingStream->write((uint64_t*)&cgen_var_294, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_291 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_291);
+ uint64_t cgen_var_295 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_295);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4218,15 +4384,15 @@
uint32_t opcode_vkDestroyImageView = OP_vkDestroyImageView;
stream->write(&opcode_vkDestroyImageView, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyImageView, sizeof(uint32_t));
- uint64_t cgen_var_292;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_292, 1);
- stream->write((uint64_t*)&cgen_var_292, 1 * 8);
- uint64_t cgen_var_293;
- stream->handleMapping()->mapHandles_VkImageView_u64(&local_imageView, &cgen_var_293, 1);
- stream->write((uint64_t*)&cgen_var_293, 1 * 8);
+ uint64_t cgen_var_296;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_296, 1);
+ stream->write((uint64_t*)&cgen_var_296, 1 * 8);
+ uint64_t cgen_var_297;
+ stream->handleMapping()->mapHandles_VkImageView_u64(&local_imageView, &cgen_var_297, 1);
+ stream->write((uint64_t*)&cgen_var_297, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_294 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_294);
+ uint64_t cgen_var_298 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_298);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4243,6 +4409,7 @@
const VkAllocationCallbacks* pAllocator,
VkShaderModule* pShaderModule)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateShaderModule encode");
mImpl->log("start vkCreateShaderModule");
auto stream = mImpl->stream();
@@ -4277,47 +4444,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_295;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_295, 1);
- countingStream->write((uint64_t*)&cgen_var_295, 1 * 8);
+ uint64_t cgen_var_299;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_299, 1);
+ countingStream->write((uint64_t*)&cgen_var_299, 1 * 8);
marshal_VkShaderModuleCreateInfo(countingStream, (VkShaderModuleCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_296 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_296);
+ uint64_t cgen_var_300 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_300);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_297;
- countingStream->handleMapping()->mapHandles_VkShaderModule_u64(pShaderModule, &cgen_var_297, 1);
- countingStream->write((uint64_t*)&cgen_var_297, 8);
+ uint64_t cgen_var_301;
+ countingStream->handleMapping()->mapHandles_VkShaderModule_u64(pShaderModule, &cgen_var_301, 1);
+ countingStream->write((uint64_t*)&cgen_var_301, 8);
}
uint32_t packetSize_vkCreateShaderModule = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateShaderModule = OP_vkCreateShaderModule;
stream->write(&opcode_vkCreateShaderModule, sizeof(uint32_t));
stream->write(&packetSize_vkCreateShaderModule, sizeof(uint32_t));
- uint64_t cgen_var_298;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_298, 1);
- stream->write((uint64_t*)&cgen_var_298, 1 * 8);
+ uint64_t cgen_var_302;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_302, 1);
+ stream->write((uint64_t*)&cgen_var_302, 1 * 8);
marshal_VkShaderModuleCreateInfo(stream, (VkShaderModuleCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_299 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_299);
+ uint64_t cgen_var_303 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_303);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_300;
- stream->handleMapping()->mapHandles_VkShaderModule_u64(pShaderModule, &cgen_var_300, 1);
- stream->write((uint64_t*)&cgen_var_300, 8);
+ uint64_t cgen_var_304;
+ stream->handleMapping()->mapHandles_VkShaderModule_u64(pShaderModule, &cgen_var_304, 1);
+ stream->write((uint64_t*)&cgen_var_304, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateShaderModule readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_301;
- stream->read((uint64_t*)&cgen_var_301, 8);
- stream->handleMapping()->mapHandles_u64_VkShaderModule(&cgen_var_301, (VkShaderModule*)pShaderModule, 1);
+ uint64_t cgen_var_305;
+ stream->read((uint64_t*)&cgen_var_305, 8);
+ stream->handleMapping()->mapHandles_u64_VkShaderModule(&cgen_var_305, (VkShaderModule*)pShaderModule, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateShaderModule returnUnmarshal");
VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
@@ -4334,6 +4501,7 @@
VkShaderModule shaderModule,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyShaderModule encode");
mImpl->log("start vkDestroyShaderModule");
auto stream = mImpl->stream();
@@ -4359,15 +4527,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_302;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_302, 1);
- countingStream->write((uint64_t*)&cgen_var_302, 1 * 8);
- uint64_t cgen_var_303;
- countingStream->handleMapping()->mapHandles_VkShaderModule_u64(&local_shaderModule, &cgen_var_303, 1);
- countingStream->write((uint64_t*)&cgen_var_303, 1 * 8);
+ uint64_t cgen_var_306;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_306, 1);
+ countingStream->write((uint64_t*)&cgen_var_306, 1 * 8);
+ uint64_t cgen_var_307;
+ countingStream->handleMapping()->mapHandles_VkShaderModule_u64(&local_shaderModule, &cgen_var_307, 1);
+ countingStream->write((uint64_t*)&cgen_var_307, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_304 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_304);
+ uint64_t cgen_var_308 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_308);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4378,15 +4546,15 @@
uint32_t opcode_vkDestroyShaderModule = OP_vkDestroyShaderModule;
stream->write(&opcode_vkDestroyShaderModule, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyShaderModule, sizeof(uint32_t));
- uint64_t cgen_var_305;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_305, 1);
- stream->write((uint64_t*)&cgen_var_305, 1 * 8);
- uint64_t cgen_var_306;
- stream->handleMapping()->mapHandles_VkShaderModule_u64(&local_shaderModule, &cgen_var_306, 1);
- stream->write((uint64_t*)&cgen_var_306, 1 * 8);
+ uint64_t cgen_var_309;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_309, 1);
+ stream->write((uint64_t*)&cgen_var_309, 1 * 8);
+ uint64_t cgen_var_310;
+ stream->handleMapping()->mapHandles_VkShaderModule_u64(&local_shaderModule, &cgen_var_310, 1);
+ stream->write((uint64_t*)&cgen_var_310, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_307 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_307);
+ uint64_t cgen_var_311 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_311);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4403,6 +4571,7 @@
const VkAllocationCallbacks* pAllocator,
VkPipelineCache* pPipelineCache)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreatePipelineCache encode");
mImpl->log("start vkCreatePipelineCache");
auto stream = mImpl->stream();
@@ -4437,47 +4606,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_308;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_308, 1);
- countingStream->write((uint64_t*)&cgen_var_308, 1 * 8);
+ uint64_t cgen_var_312;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_312, 1);
+ countingStream->write((uint64_t*)&cgen_var_312, 1 * 8);
marshal_VkPipelineCacheCreateInfo(countingStream, (VkPipelineCacheCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_309 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_309);
+ uint64_t cgen_var_313 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_313);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_310;
- countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(pPipelineCache, &cgen_var_310, 1);
- countingStream->write((uint64_t*)&cgen_var_310, 8);
+ uint64_t cgen_var_314;
+ countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(pPipelineCache, &cgen_var_314, 1);
+ countingStream->write((uint64_t*)&cgen_var_314, 8);
}
uint32_t packetSize_vkCreatePipelineCache = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreatePipelineCache = OP_vkCreatePipelineCache;
stream->write(&opcode_vkCreatePipelineCache, sizeof(uint32_t));
stream->write(&packetSize_vkCreatePipelineCache, sizeof(uint32_t));
- uint64_t cgen_var_311;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_311, 1);
- stream->write((uint64_t*)&cgen_var_311, 1 * 8);
+ uint64_t cgen_var_315;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_315, 1);
+ stream->write((uint64_t*)&cgen_var_315, 1 * 8);
marshal_VkPipelineCacheCreateInfo(stream, (VkPipelineCacheCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_312 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_312);
+ uint64_t cgen_var_316 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_316);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_313;
- stream->handleMapping()->mapHandles_VkPipelineCache_u64(pPipelineCache, &cgen_var_313, 1);
- stream->write((uint64_t*)&cgen_var_313, 8);
+ uint64_t cgen_var_317;
+ stream->handleMapping()->mapHandles_VkPipelineCache_u64(pPipelineCache, &cgen_var_317, 1);
+ stream->write((uint64_t*)&cgen_var_317, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreatePipelineCache readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_314;
- stream->read((uint64_t*)&cgen_var_314, 8);
- stream->handleMapping()->mapHandles_u64_VkPipelineCache(&cgen_var_314, (VkPipelineCache*)pPipelineCache, 1);
+ uint64_t cgen_var_318;
+ stream->read((uint64_t*)&cgen_var_318, 8);
+ stream->handleMapping()->mapHandles_u64_VkPipelineCache(&cgen_var_318, (VkPipelineCache*)pPipelineCache, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreatePipelineCache returnUnmarshal");
VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
@@ -4494,6 +4663,7 @@
VkPipelineCache pipelineCache,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyPipelineCache encode");
mImpl->log("start vkDestroyPipelineCache");
auto stream = mImpl->stream();
@@ -4519,15 +4689,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_315;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_315, 1);
- countingStream->write((uint64_t*)&cgen_var_315, 1 * 8);
- uint64_t cgen_var_316;
- countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_316, 1);
- countingStream->write((uint64_t*)&cgen_var_316, 1 * 8);
+ uint64_t cgen_var_319;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_319, 1);
+ countingStream->write((uint64_t*)&cgen_var_319, 1 * 8);
+ uint64_t cgen_var_320;
+ countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_320, 1);
+ countingStream->write((uint64_t*)&cgen_var_320, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_317 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_317);
+ uint64_t cgen_var_321 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_321);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4538,15 +4708,15 @@
uint32_t opcode_vkDestroyPipelineCache = OP_vkDestroyPipelineCache;
stream->write(&opcode_vkDestroyPipelineCache, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyPipelineCache, sizeof(uint32_t));
- uint64_t cgen_var_318;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_318, 1);
- stream->write((uint64_t*)&cgen_var_318, 1 * 8);
- uint64_t cgen_var_319;
- stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_319, 1);
- stream->write((uint64_t*)&cgen_var_319, 1 * 8);
+ uint64_t cgen_var_322;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_322, 1);
+ stream->write((uint64_t*)&cgen_var_322, 1 * 8);
+ uint64_t cgen_var_323;
+ stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_323, 1);
+ stream->write((uint64_t*)&cgen_var_323, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_320 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_320);
+ uint64_t cgen_var_324 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_324);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4563,6 +4733,7 @@
size_t* pDataSize,
void* pData)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPipelineCacheData encode");
mImpl->log("start vkGetPipelineCacheData");
auto stream = mImpl->stream();
@@ -4576,23 +4747,23 @@
local_pipelineCache = pipelineCache;
countingStream->rewind();
{
- uint64_t cgen_var_321;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_321, 1);
- countingStream->write((uint64_t*)&cgen_var_321, 1 * 8);
- uint64_t cgen_var_322;
- countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_322, 1);
- countingStream->write((uint64_t*)&cgen_var_322, 1 * 8);
+ uint64_t cgen_var_325;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_325, 1);
+ countingStream->write((uint64_t*)&cgen_var_325, 1 * 8);
+ uint64_t cgen_var_326;
+ countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_326, 1);
+ countingStream->write((uint64_t*)&cgen_var_326, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_323 = (uint64_t)(uintptr_t)pDataSize;
- countingStream->putBe64(cgen_var_323);
+ uint64_t cgen_var_327 = (uint64_t)(uintptr_t)pDataSize;
+ countingStream->putBe64(cgen_var_327);
if (pDataSize)
{
- uint64_t cgen_var_324 = (uint64_t)(*pDataSize);
- countingStream->putBe64(cgen_var_324);
+ uint64_t cgen_var_328 = (uint64_t)(*pDataSize);
+ countingStream->putBe64(cgen_var_328);
}
// WARNING PTR CHECK
- uint64_t cgen_var_325 = (uint64_t)(uintptr_t)pData;
- countingStream->putBe64(cgen_var_325);
+ uint64_t cgen_var_329 = (uint64_t)(uintptr_t)pData;
+ countingStream->putBe64(cgen_var_329);
if (pData)
{
countingStream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
@@ -4603,23 +4774,23 @@
uint32_t opcode_vkGetPipelineCacheData = OP_vkGetPipelineCacheData;
stream->write(&opcode_vkGetPipelineCacheData, sizeof(uint32_t));
stream->write(&packetSize_vkGetPipelineCacheData, sizeof(uint32_t));
- uint64_t cgen_var_326;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_326, 1);
- stream->write((uint64_t*)&cgen_var_326, 1 * 8);
- uint64_t cgen_var_327;
- stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_327, 1);
- stream->write((uint64_t*)&cgen_var_327, 1 * 8);
+ uint64_t cgen_var_330;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_330, 1);
+ stream->write((uint64_t*)&cgen_var_330, 1 * 8);
+ uint64_t cgen_var_331;
+ stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_331, 1);
+ stream->write((uint64_t*)&cgen_var_331, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_328 = (uint64_t)(uintptr_t)pDataSize;
- stream->putBe64(cgen_var_328);
+ uint64_t cgen_var_332 = (uint64_t)(uintptr_t)pDataSize;
+ stream->putBe64(cgen_var_332);
if (pDataSize)
{
- uint64_t cgen_var_329 = (uint64_t)(*pDataSize);
- stream->putBe64(cgen_var_329);
+ uint64_t cgen_var_333 = (uint64_t)(*pDataSize);
+ stream->putBe64(cgen_var_333);
}
// WARNING PTR CHECK
- uint64_t cgen_var_330 = (uint64_t)(uintptr_t)pData;
- stream->putBe64(cgen_var_330);
+ uint64_t cgen_var_334 = (uint64_t)(uintptr_t)pData;
+ stream->putBe64(cgen_var_334);
if (pData)
{
stream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
@@ -4663,6 +4834,7 @@
uint32_t srcCacheCount,
const VkPipelineCache* pSrcCaches)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkMergePipelineCaches encode");
mImpl->log("start vkMergePipelineCaches");
auto stream = mImpl->stream();
@@ -4684,19 +4856,19 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_334;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_334, 1);
- countingStream->write((uint64_t*)&cgen_var_334, 1 * 8);
- uint64_t cgen_var_335;
- countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_dstCache, &cgen_var_335, 1);
- countingStream->write((uint64_t*)&cgen_var_335, 1 * 8);
+ uint64_t cgen_var_338;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_338, 1);
+ countingStream->write((uint64_t*)&cgen_var_338, 1 * 8);
+ uint64_t cgen_var_339;
+ countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_dstCache, &cgen_var_339, 1);
+ countingStream->write((uint64_t*)&cgen_var_339, 1 * 8);
countingStream->write((uint32_t*)&local_srcCacheCount, sizeof(uint32_t));
if (((srcCacheCount)))
{
- uint64_t* cgen_var_336;
- countingStream->alloc((void**)&cgen_var_336, ((srcCacheCount)) * 8);
- countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(local_pSrcCaches, cgen_var_336, ((srcCacheCount)));
- countingStream->write((uint64_t*)cgen_var_336, ((srcCacheCount)) * 8);
+ uint64_t* cgen_var_340;
+ countingStream->alloc((void**)&cgen_var_340, ((srcCacheCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(local_pSrcCaches, cgen_var_340, ((srcCacheCount)));
+ countingStream->write((uint64_t*)cgen_var_340, ((srcCacheCount)) * 8);
}
}
uint32_t packetSize_vkMergePipelineCaches = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -4704,19 +4876,19 @@
uint32_t opcode_vkMergePipelineCaches = OP_vkMergePipelineCaches;
stream->write(&opcode_vkMergePipelineCaches, sizeof(uint32_t));
stream->write(&packetSize_vkMergePipelineCaches, sizeof(uint32_t));
- uint64_t cgen_var_337;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_337, 1);
- stream->write((uint64_t*)&cgen_var_337, 1 * 8);
- uint64_t cgen_var_338;
- stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_dstCache, &cgen_var_338, 1);
- stream->write((uint64_t*)&cgen_var_338, 1 * 8);
+ uint64_t cgen_var_341;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_341, 1);
+ stream->write((uint64_t*)&cgen_var_341, 1 * 8);
+ uint64_t cgen_var_342;
+ stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_dstCache, &cgen_var_342, 1);
+ stream->write((uint64_t*)&cgen_var_342, 1 * 8);
stream->write((uint32_t*)&local_srcCacheCount, sizeof(uint32_t));
if (((srcCacheCount)))
{
- uint64_t* cgen_var_339;
- stream->alloc((void**)&cgen_var_339, ((srcCacheCount)) * 8);
- stream->handleMapping()->mapHandles_VkPipelineCache_u64(local_pSrcCaches, cgen_var_339, ((srcCacheCount)));
- stream->write((uint64_t*)cgen_var_339, ((srcCacheCount)) * 8);
+ uint64_t* cgen_var_343;
+ stream->alloc((void**)&cgen_var_343, ((srcCacheCount)) * 8);
+ stream->handleMapping()->mapHandles_VkPipelineCache_u64(local_pSrcCaches, cgen_var_343, ((srcCacheCount)));
+ stream->write((uint64_t*)cgen_var_343, ((srcCacheCount)) * 8);
}
AEMU_SCOPED_TRACE("vkMergePipelineCaches readParams");
AEMU_SCOPED_TRACE("vkMergePipelineCaches returnUnmarshal");
@@ -4737,6 +4909,7 @@
const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines encode");
mImpl->log("start vkCreateGraphicsPipelines");
auto stream = mImpl->stream();
@@ -4781,30 +4954,30 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_340;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_340, 1);
- countingStream->write((uint64_t*)&cgen_var_340, 1 * 8);
- uint64_t cgen_var_341;
- countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_341, 1);
- countingStream->write((uint64_t*)&cgen_var_341, 1 * 8);
+ uint64_t cgen_var_344;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_344, 1);
+ countingStream->write((uint64_t*)&cgen_var_344, 1 * 8);
+ uint64_t cgen_var_345;
+ countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_345, 1);
+ countingStream->write((uint64_t*)&cgen_var_345, 1 * 8);
countingStream->write((uint32_t*)&local_createInfoCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
{
marshal_VkGraphicsPipelineCreateInfo(countingStream, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i));
}
// WARNING PTR CHECK
- uint64_t cgen_var_342 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_342);
+ uint64_t cgen_var_346 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_346);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
if (((createInfoCount)))
{
- uint64_t* cgen_var_343;
- countingStream->alloc((void**)&cgen_var_343, ((createInfoCount)) * 8);
- countingStream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_343, ((createInfoCount)));
- countingStream->write((uint64_t*)cgen_var_343, ((createInfoCount)) * 8);
+ uint64_t* cgen_var_347;
+ countingStream->alloc((void**)&cgen_var_347, ((createInfoCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_347, ((createInfoCount)));
+ countingStream->write((uint64_t*)cgen_var_347, ((createInfoCount)) * 8);
}
}
uint32_t packetSize_vkCreateGraphicsPipelines = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -4812,20 +4985,20 @@
uint32_t opcode_vkCreateGraphicsPipelines = OP_vkCreateGraphicsPipelines;
stream->write(&opcode_vkCreateGraphicsPipelines, sizeof(uint32_t));
stream->write(&packetSize_vkCreateGraphicsPipelines, sizeof(uint32_t));
- uint64_t cgen_var_344;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_344, 1);
- stream->write((uint64_t*)&cgen_var_344, 1 * 8);
- uint64_t cgen_var_345;
- stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_345, 1);
- stream->write((uint64_t*)&cgen_var_345, 1 * 8);
+ uint64_t cgen_var_348;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_348, 1);
+ stream->write((uint64_t*)&cgen_var_348, 1 * 8);
+ uint64_t cgen_var_349;
+ stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_349, 1);
+ stream->write((uint64_t*)&cgen_var_349, 1 * 8);
stream->write((uint32_t*)&local_createInfoCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
{
marshal_VkGraphicsPipelineCreateInfo(stream, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i));
}
// WARNING PTR CHECK
- uint64_t cgen_var_346 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_346);
+ uint64_t cgen_var_350 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_350);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4833,20 +5006,20 @@
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
if (((createInfoCount)))
{
- uint64_t* cgen_var_347;
- stream->alloc((void**)&cgen_var_347, ((createInfoCount)) * 8);
- stream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_347, ((createInfoCount)));
- stream->write((uint64_t*)cgen_var_347, ((createInfoCount)) * 8);
+ uint64_t* cgen_var_351;
+ stream->alloc((void**)&cgen_var_351, ((createInfoCount)) * 8);
+ stream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_351, ((createInfoCount)));
+ stream->write((uint64_t*)cgen_var_351, ((createInfoCount)) * 8);
}
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines readParams");
stream->setHandleMapping(resources->createMapping());
if (((createInfoCount)))
{
- uint64_t* cgen_var_348;
- stream->alloc((void**)&cgen_var_348, ((createInfoCount)) * 8);
- stream->read((uint64_t*)cgen_var_348, ((createInfoCount)) * 8);
- stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_348, (VkPipeline*)pPipelines, ((createInfoCount)));
+ uint64_t* cgen_var_352;
+ stream->alloc((void**)&cgen_var_352, ((createInfoCount)) * 8);
+ stream->read((uint64_t*)cgen_var_352, ((createInfoCount)) * 8);
+ stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_352, (VkPipeline*)pPipelines, ((createInfoCount)));
}
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines returnUnmarshal");
@@ -4867,6 +5040,7 @@
const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateComputePipelines encode");
mImpl->log("start vkCreateComputePipelines");
auto stream = mImpl->stream();
@@ -4911,30 +5085,30 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_349;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_349, 1);
- countingStream->write((uint64_t*)&cgen_var_349, 1 * 8);
- uint64_t cgen_var_350;
- countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_350, 1);
- countingStream->write((uint64_t*)&cgen_var_350, 1 * 8);
+ uint64_t cgen_var_353;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_353, 1);
+ countingStream->write((uint64_t*)&cgen_var_353, 1 * 8);
+ uint64_t cgen_var_354;
+ countingStream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_354, 1);
+ countingStream->write((uint64_t*)&cgen_var_354, 1 * 8);
countingStream->write((uint32_t*)&local_createInfoCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
{
marshal_VkComputePipelineCreateInfo(countingStream, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i));
}
// WARNING PTR CHECK
- uint64_t cgen_var_351 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_351);
+ uint64_t cgen_var_355 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_355);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
if (((createInfoCount)))
{
- uint64_t* cgen_var_352;
- countingStream->alloc((void**)&cgen_var_352, ((createInfoCount)) * 8);
- countingStream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_352, ((createInfoCount)));
- countingStream->write((uint64_t*)cgen_var_352, ((createInfoCount)) * 8);
+ uint64_t* cgen_var_356;
+ countingStream->alloc((void**)&cgen_var_356, ((createInfoCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_356, ((createInfoCount)));
+ countingStream->write((uint64_t*)cgen_var_356, ((createInfoCount)) * 8);
}
}
uint32_t packetSize_vkCreateComputePipelines = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -4942,20 +5116,20 @@
uint32_t opcode_vkCreateComputePipelines = OP_vkCreateComputePipelines;
stream->write(&opcode_vkCreateComputePipelines, sizeof(uint32_t));
stream->write(&packetSize_vkCreateComputePipelines, sizeof(uint32_t));
- uint64_t cgen_var_353;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_353, 1);
- stream->write((uint64_t*)&cgen_var_353, 1 * 8);
- uint64_t cgen_var_354;
- stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_354, 1);
- stream->write((uint64_t*)&cgen_var_354, 1 * 8);
+ uint64_t cgen_var_357;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_357, 1);
+ stream->write((uint64_t*)&cgen_var_357, 1 * 8);
+ uint64_t cgen_var_358;
+ stream->handleMapping()->mapHandles_VkPipelineCache_u64(&local_pipelineCache, &cgen_var_358, 1);
+ stream->write((uint64_t*)&cgen_var_358, 1 * 8);
stream->write((uint32_t*)&local_createInfoCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
{
marshal_VkComputePipelineCreateInfo(stream, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i));
}
// WARNING PTR CHECK
- uint64_t cgen_var_355 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_355);
+ uint64_t cgen_var_359 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_359);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -4963,20 +5137,20 @@
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
if (((createInfoCount)))
{
- uint64_t* cgen_var_356;
- stream->alloc((void**)&cgen_var_356, ((createInfoCount)) * 8);
- stream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_356, ((createInfoCount)));
- stream->write((uint64_t*)cgen_var_356, ((createInfoCount)) * 8);
+ uint64_t* cgen_var_360;
+ stream->alloc((void**)&cgen_var_360, ((createInfoCount)) * 8);
+ stream->handleMapping()->mapHandles_VkPipeline_u64(pPipelines, cgen_var_360, ((createInfoCount)));
+ stream->write((uint64_t*)cgen_var_360, ((createInfoCount)) * 8);
}
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateComputePipelines readParams");
stream->setHandleMapping(resources->createMapping());
if (((createInfoCount)))
{
- uint64_t* cgen_var_357;
- stream->alloc((void**)&cgen_var_357, ((createInfoCount)) * 8);
- stream->read((uint64_t*)cgen_var_357, ((createInfoCount)) * 8);
- stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_357, (VkPipeline*)pPipelines, ((createInfoCount)));
+ uint64_t* cgen_var_361;
+ stream->alloc((void**)&cgen_var_361, ((createInfoCount)) * 8);
+ stream->read((uint64_t*)cgen_var_361, ((createInfoCount)) * 8);
+ stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_361, (VkPipeline*)pPipelines, ((createInfoCount)));
}
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateComputePipelines returnUnmarshal");
@@ -4994,6 +5168,7 @@
VkPipeline pipeline,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyPipeline encode");
mImpl->log("start vkDestroyPipeline");
auto stream = mImpl->stream();
@@ -5019,15 +5194,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_358;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_358, 1);
- countingStream->write((uint64_t*)&cgen_var_358, 1 * 8);
- uint64_t cgen_var_359;
- countingStream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_359, 1);
- countingStream->write((uint64_t*)&cgen_var_359, 1 * 8);
+ uint64_t cgen_var_362;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_362, 1);
+ countingStream->write((uint64_t*)&cgen_var_362, 1 * 8);
+ uint64_t cgen_var_363;
+ countingStream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_363, 1);
+ countingStream->write((uint64_t*)&cgen_var_363, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_360 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_360);
+ uint64_t cgen_var_364 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_364);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5038,15 +5213,15 @@
uint32_t opcode_vkDestroyPipeline = OP_vkDestroyPipeline;
stream->write(&opcode_vkDestroyPipeline, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyPipeline, sizeof(uint32_t));
- uint64_t cgen_var_361;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_361, 1);
- stream->write((uint64_t*)&cgen_var_361, 1 * 8);
- uint64_t cgen_var_362;
- stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_362, 1);
- stream->write((uint64_t*)&cgen_var_362, 1 * 8);
+ uint64_t cgen_var_365;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_365, 1);
+ stream->write((uint64_t*)&cgen_var_365, 1 * 8);
+ uint64_t cgen_var_366;
+ stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_366, 1);
+ stream->write((uint64_t*)&cgen_var_366, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_363 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_363);
+ uint64_t cgen_var_367 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_367);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5063,6 +5238,7 @@
const VkAllocationCallbacks* pAllocator,
VkPipelineLayout* pPipelineLayout)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreatePipelineLayout encode");
mImpl->log("start vkCreatePipelineLayout");
auto stream = mImpl->stream();
@@ -5097,47 +5273,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_364;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_364, 1);
- countingStream->write((uint64_t*)&cgen_var_364, 1 * 8);
+ uint64_t cgen_var_368;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_368, 1);
+ countingStream->write((uint64_t*)&cgen_var_368, 1 * 8);
marshal_VkPipelineLayoutCreateInfo(countingStream, (VkPipelineLayoutCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_365 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_365);
+ uint64_t cgen_var_369 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_369);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_366;
- countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(pPipelineLayout, &cgen_var_366, 1);
- countingStream->write((uint64_t*)&cgen_var_366, 8);
+ uint64_t cgen_var_370;
+ countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(pPipelineLayout, &cgen_var_370, 1);
+ countingStream->write((uint64_t*)&cgen_var_370, 8);
}
uint32_t packetSize_vkCreatePipelineLayout = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreatePipelineLayout = OP_vkCreatePipelineLayout;
stream->write(&opcode_vkCreatePipelineLayout, sizeof(uint32_t));
stream->write(&packetSize_vkCreatePipelineLayout, sizeof(uint32_t));
- uint64_t cgen_var_367;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_367, 1);
- stream->write((uint64_t*)&cgen_var_367, 1 * 8);
+ uint64_t cgen_var_371;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_371, 1);
+ stream->write((uint64_t*)&cgen_var_371, 1 * 8);
marshal_VkPipelineLayoutCreateInfo(stream, (VkPipelineLayoutCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_368 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_368);
+ uint64_t cgen_var_372 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_372);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_369;
- stream->handleMapping()->mapHandles_VkPipelineLayout_u64(pPipelineLayout, &cgen_var_369, 1);
- stream->write((uint64_t*)&cgen_var_369, 8);
+ uint64_t cgen_var_373;
+ stream->handleMapping()->mapHandles_VkPipelineLayout_u64(pPipelineLayout, &cgen_var_373, 1);
+ stream->write((uint64_t*)&cgen_var_373, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreatePipelineLayout readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_370;
- stream->read((uint64_t*)&cgen_var_370, 8);
- stream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_370, (VkPipelineLayout*)pPipelineLayout, 1);
+ uint64_t cgen_var_374;
+ stream->read((uint64_t*)&cgen_var_374, 8);
+ stream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_374, (VkPipelineLayout*)pPipelineLayout, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreatePipelineLayout returnUnmarshal");
VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
@@ -5154,6 +5330,7 @@
VkPipelineLayout pipelineLayout,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyPipelineLayout encode");
mImpl->log("start vkDestroyPipelineLayout");
auto stream = mImpl->stream();
@@ -5179,15 +5356,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_371;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_371, 1);
- countingStream->write((uint64_t*)&cgen_var_371, 1 * 8);
- uint64_t cgen_var_372;
- countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_pipelineLayout, &cgen_var_372, 1);
- countingStream->write((uint64_t*)&cgen_var_372, 1 * 8);
+ uint64_t cgen_var_375;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_375, 1);
+ countingStream->write((uint64_t*)&cgen_var_375, 1 * 8);
+ uint64_t cgen_var_376;
+ countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_pipelineLayout, &cgen_var_376, 1);
+ countingStream->write((uint64_t*)&cgen_var_376, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_373 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_373);
+ uint64_t cgen_var_377 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_377);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5198,15 +5375,15 @@
uint32_t opcode_vkDestroyPipelineLayout = OP_vkDestroyPipelineLayout;
stream->write(&opcode_vkDestroyPipelineLayout, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyPipelineLayout, sizeof(uint32_t));
- uint64_t cgen_var_374;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_374, 1);
- stream->write((uint64_t*)&cgen_var_374, 1 * 8);
- uint64_t cgen_var_375;
- stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_pipelineLayout, &cgen_var_375, 1);
- stream->write((uint64_t*)&cgen_var_375, 1 * 8);
+ uint64_t cgen_var_378;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_378, 1);
+ stream->write((uint64_t*)&cgen_var_378, 1 * 8);
+ uint64_t cgen_var_379;
+ stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_pipelineLayout, &cgen_var_379, 1);
+ stream->write((uint64_t*)&cgen_var_379, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_376 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_376);
+ uint64_t cgen_var_380 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_380);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5223,6 +5400,7 @@
const VkAllocationCallbacks* pAllocator,
VkSampler* pSampler)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateSampler encode");
mImpl->log("start vkCreateSampler");
auto stream = mImpl->stream();
@@ -5257,47 +5435,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_377;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_377, 1);
- countingStream->write((uint64_t*)&cgen_var_377, 1 * 8);
+ uint64_t cgen_var_381;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_381, 1);
+ countingStream->write((uint64_t*)&cgen_var_381, 1 * 8);
marshal_VkSamplerCreateInfo(countingStream, (VkSamplerCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_378 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_378);
+ uint64_t cgen_var_382 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_382);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_379;
- countingStream->handleMapping()->mapHandles_VkSampler_u64(pSampler, &cgen_var_379, 1);
- countingStream->write((uint64_t*)&cgen_var_379, 8);
+ uint64_t cgen_var_383;
+ countingStream->handleMapping()->mapHandles_VkSampler_u64(pSampler, &cgen_var_383, 1);
+ countingStream->write((uint64_t*)&cgen_var_383, 8);
}
uint32_t packetSize_vkCreateSampler = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateSampler = OP_vkCreateSampler;
stream->write(&opcode_vkCreateSampler, sizeof(uint32_t));
stream->write(&packetSize_vkCreateSampler, sizeof(uint32_t));
- uint64_t cgen_var_380;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_380, 1);
- stream->write((uint64_t*)&cgen_var_380, 1 * 8);
+ uint64_t cgen_var_384;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_384, 1);
+ stream->write((uint64_t*)&cgen_var_384, 1 * 8);
marshal_VkSamplerCreateInfo(stream, (VkSamplerCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_381 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_381);
+ uint64_t cgen_var_385 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_385);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_382;
- stream->handleMapping()->mapHandles_VkSampler_u64(pSampler, &cgen_var_382, 1);
- stream->write((uint64_t*)&cgen_var_382, 8);
+ uint64_t cgen_var_386;
+ stream->handleMapping()->mapHandles_VkSampler_u64(pSampler, &cgen_var_386, 1);
+ stream->write((uint64_t*)&cgen_var_386, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateSampler readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_383;
- stream->read((uint64_t*)&cgen_var_383, 8);
- stream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_383, (VkSampler*)pSampler, 1);
+ uint64_t cgen_var_387;
+ stream->read((uint64_t*)&cgen_var_387, 8);
+ stream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_387, (VkSampler*)pSampler, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateSampler returnUnmarshal");
VkResult vkCreateSampler_VkResult_return = (VkResult)0;
@@ -5314,6 +5492,7 @@
VkSampler sampler,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroySampler encode");
mImpl->log("start vkDestroySampler");
auto stream = mImpl->stream();
@@ -5339,15 +5518,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_384;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_384, 1);
- countingStream->write((uint64_t*)&cgen_var_384, 1 * 8);
- uint64_t cgen_var_385;
- countingStream->handleMapping()->mapHandles_VkSampler_u64(&local_sampler, &cgen_var_385, 1);
- countingStream->write((uint64_t*)&cgen_var_385, 1 * 8);
+ uint64_t cgen_var_388;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_388, 1);
+ countingStream->write((uint64_t*)&cgen_var_388, 1 * 8);
+ uint64_t cgen_var_389;
+ countingStream->handleMapping()->mapHandles_VkSampler_u64(&local_sampler, &cgen_var_389, 1);
+ countingStream->write((uint64_t*)&cgen_var_389, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_386 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_386);
+ uint64_t cgen_var_390 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_390);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5358,15 +5537,15 @@
uint32_t opcode_vkDestroySampler = OP_vkDestroySampler;
stream->write(&opcode_vkDestroySampler, sizeof(uint32_t));
stream->write(&packetSize_vkDestroySampler, sizeof(uint32_t));
- uint64_t cgen_var_387;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_387, 1);
- stream->write((uint64_t*)&cgen_var_387, 1 * 8);
- uint64_t cgen_var_388;
- stream->handleMapping()->mapHandles_VkSampler_u64(&local_sampler, &cgen_var_388, 1);
- stream->write((uint64_t*)&cgen_var_388, 1 * 8);
+ uint64_t cgen_var_391;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_391, 1);
+ stream->write((uint64_t*)&cgen_var_391, 1 * 8);
+ uint64_t cgen_var_392;
+ stream->handleMapping()->mapHandles_VkSampler_u64(&local_sampler, &cgen_var_392, 1);
+ stream->write((uint64_t*)&cgen_var_392, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_389 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_389);
+ uint64_t cgen_var_393 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_393);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5383,6 +5562,7 @@
const VkAllocationCallbacks* pAllocator,
VkDescriptorSetLayout* pSetLayout)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout encode");
mImpl->log("start vkCreateDescriptorSetLayout");
auto stream = mImpl->stream();
@@ -5417,47 +5597,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_390;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_390, 1);
- countingStream->write((uint64_t*)&cgen_var_390, 1 * 8);
+ uint64_t cgen_var_394;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_394, 1);
+ countingStream->write((uint64_t*)&cgen_var_394, 1 * 8);
marshal_VkDescriptorSetLayoutCreateInfo(countingStream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_391 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_391);
+ uint64_t cgen_var_395 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_395);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_392;
- countingStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(pSetLayout, &cgen_var_392, 1);
- countingStream->write((uint64_t*)&cgen_var_392, 8);
+ uint64_t cgen_var_396;
+ countingStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(pSetLayout, &cgen_var_396, 1);
+ countingStream->write((uint64_t*)&cgen_var_396, 8);
}
uint32_t packetSize_vkCreateDescriptorSetLayout = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateDescriptorSetLayout = OP_vkCreateDescriptorSetLayout;
stream->write(&opcode_vkCreateDescriptorSetLayout, sizeof(uint32_t));
stream->write(&packetSize_vkCreateDescriptorSetLayout, sizeof(uint32_t));
- uint64_t cgen_var_393;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_393, 1);
- stream->write((uint64_t*)&cgen_var_393, 1 * 8);
+ uint64_t cgen_var_397;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_397, 1);
+ stream->write((uint64_t*)&cgen_var_397, 1 * 8);
marshal_VkDescriptorSetLayoutCreateInfo(stream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_394 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_394);
+ uint64_t cgen_var_398 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_398);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_395;
- stream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(pSetLayout, &cgen_var_395, 1);
- stream->write((uint64_t*)&cgen_var_395, 8);
+ uint64_t cgen_var_399;
+ stream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(pSetLayout, &cgen_var_399, 1);
+ stream->write((uint64_t*)&cgen_var_399, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_396;
- stream->read((uint64_t*)&cgen_var_396, 8);
- stream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(&cgen_var_396, (VkDescriptorSetLayout*)pSetLayout, 1);
+ uint64_t cgen_var_400;
+ stream->read((uint64_t*)&cgen_var_400, 8);
+ stream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(&cgen_var_400, (VkDescriptorSetLayout*)pSetLayout, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout returnUnmarshal");
VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
@@ -5474,6 +5654,7 @@
VkDescriptorSetLayout descriptorSetLayout,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout encode");
mImpl->log("start vkDestroyDescriptorSetLayout");
auto stream = mImpl->stream();
@@ -5499,15 +5680,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_397;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_397, 1);
- countingStream->write((uint64_t*)&cgen_var_397, 1 * 8);
- uint64_t cgen_var_398;
- countingStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&local_descriptorSetLayout, &cgen_var_398, 1);
- countingStream->write((uint64_t*)&cgen_var_398, 1 * 8);
+ uint64_t cgen_var_401;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_401, 1);
+ countingStream->write((uint64_t*)&cgen_var_401, 1 * 8);
+ uint64_t cgen_var_402;
+ countingStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&local_descriptorSetLayout, &cgen_var_402, 1);
+ countingStream->write((uint64_t*)&cgen_var_402, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_399 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_399);
+ uint64_t cgen_var_403 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_403);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5518,15 +5699,15 @@
uint32_t opcode_vkDestroyDescriptorSetLayout = OP_vkDestroyDescriptorSetLayout;
stream->write(&opcode_vkDestroyDescriptorSetLayout, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyDescriptorSetLayout, sizeof(uint32_t));
- uint64_t cgen_var_400;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_400, 1);
- stream->write((uint64_t*)&cgen_var_400, 1 * 8);
- uint64_t cgen_var_401;
- stream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&local_descriptorSetLayout, &cgen_var_401, 1);
- stream->write((uint64_t*)&cgen_var_401, 1 * 8);
+ uint64_t cgen_var_404;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_404, 1);
+ stream->write((uint64_t*)&cgen_var_404, 1 * 8);
+ uint64_t cgen_var_405;
+ stream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&local_descriptorSetLayout, &cgen_var_405, 1);
+ stream->write((uint64_t*)&cgen_var_405, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_402 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_402);
+ uint64_t cgen_var_406 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_406);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5543,6 +5724,7 @@
const VkAllocationCallbacks* pAllocator,
VkDescriptorPool* pDescriptorPool)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateDescriptorPool encode");
mImpl->log("start vkCreateDescriptorPool");
auto stream = mImpl->stream();
@@ -5577,47 +5759,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_403;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_403, 1);
- countingStream->write((uint64_t*)&cgen_var_403, 1 * 8);
+ uint64_t cgen_var_407;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_407, 1);
+ countingStream->write((uint64_t*)&cgen_var_407, 1 * 8);
marshal_VkDescriptorPoolCreateInfo(countingStream, (VkDescriptorPoolCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_404 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_404);
+ uint64_t cgen_var_408 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_408);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_405;
- countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(pDescriptorPool, &cgen_var_405, 1);
- countingStream->write((uint64_t*)&cgen_var_405, 8);
+ uint64_t cgen_var_409;
+ countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(pDescriptorPool, &cgen_var_409, 1);
+ countingStream->write((uint64_t*)&cgen_var_409, 8);
}
uint32_t packetSize_vkCreateDescriptorPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateDescriptorPool = OP_vkCreateDescriptorPool;
stream->write(&opcode_vkCreateDescriptorPool, sizeof(uint32_t));
stream->write(&packetSize_vkCreateDescriptorPool, sizeof(uint32_t));
- uint64_t cgen_var_406;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_406, 1);
- stream->write((uint64_t*)&cgen_var_406, 1 * 8);
+ uint64_t cgen_var_410;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_410, 1);
+ stream->write((uint64_t*)&cgen_var_410, 1 * 8);
marshal_VkDescriptorPoolCreateInfo(stream, (VkDescriptorPoolCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_407 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_407);
+ uint64_t cgen_var_411 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_411);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_408;
- stream->handleMapping()->mapHandles_VkDescriptorPool_u64(pDescriptorPool, &cgen_var_408, 1);
- stream->write((uint64_t*)&cgen_var_408, 8);
+ uint64_t cgen_var_412;
+ stream->handleMapping()->mapHandles_VkDescriptorPool_u64(pDescriptorPool, &cgen_var_412, 1);
+ stream->write((uint64_t*)&cgen_var_412, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateDescriptorPool readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_409;
- stream->read((uint64_t*)&cgen_var_409, 8);
- stream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_409, (VkDescriptorPool*)pDescriptorPool, 1);
+ uint64_t cgen_var_413;
+ stream->read((uint64_t*)&cgen_var_413, 8);
+ stream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_413, (VkDescriptorPool*)pDescriptorPool, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateDescriptorPool returnUnmarshal");
VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
@@ -5634,6 +5816,7 @@
VkDescriptorPool descriptorPool,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyDescriptorPool encode");
mImpl->log("start vkDestroyDescriptorPool");
auto stream = mImpl->stream();
@@ -5659,15 +5842,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_410;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_410, 1);
- countingStream->write((uint64_t*)&cgen_var_410, 1 * 8);
- uint64_t cgen_var_411;
- countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_411, 1);
- countingStream->write((uint64_t*)&cgen_var_411, 1 * 8);
+ uint64_t cgen_var_414;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_414, 1);
+ countingStream->write((uint64_t*)&cgen_var_414, 1 * 8);
+ uint64_t cgen_var_415;
+ countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_415, 1);
+ countingStream->write((uint64_t*)&cgen_var_415, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_412 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_412);
+ uint64_t cgen_var_416 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_416);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5678,15 +5861,15 @@
uint32_t opcode_vkDestroyDescriptorPool = OP_vkDestroyDescriptorPool;
stream->write(&opcode_vkDestroyDescriptorPool, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyDescriptorPool, sizeof(uint32_t));
- uint64_t cgen_var_413;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_413, 1);
- stream->write((uint64_t*)&cgen_var_413, 1 * 8);
- uint64_t cgen_var_414;
- stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_414, 1);
- stream->write((uint64_t*)&cgen_var_414, 1 * 8);
+ uint64_t cgen_var_417;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_417, 1);
+ stream->write((uint64_t*)&cgen_var_417, 1 * 8);
+ uint64_t cgen_var_418;
+ stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_418, 1);
+ stream->write((uint64_t*)&cgen_var_418, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_415 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_415);
+ uint64_t cgen_var_419 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_419);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -5702,6 +5885,7 @@
VkDescriptorPool descriptorPool,
VkDescriptorPoolResetFlags flags)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkResetDescriptorPool encode");
mImpl->log("start vkResetDescriptorPool");
auto stream = mImpl->stream();
@@ -5717,12 +5901,12 @@
local_flags = flags;
countingStream->rewind();
{
- uint64_t cgen_var_416;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_416, 1);
- countingStream->write((uint64_t*)&cgen_var_416, 1 * 8);
- uint64_t cgen_var_417;
- countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_417, 1);
- countingStream->write((uint64_t*)&cgen_var_417, 1 * 8);
+ uint64_t cgen_var_420;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_420, 1);
+ countingStream->write((uint64_t*)&cgen_var_420, 1 * 8);
+ uint64_t cgen_var_421;
+ countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_421, 1);
+ countingStream->write((uint64_t*)&cgen_var_421, 1 * 8);
countingStream->write((VkDescriptorPoolResetFlags*)&local_flags, sizeof(VkDescriptorPoolResetFlags));
}
uint32_t packetSize_vkResetDescriptorPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -5730,12 +5914,12 @@
uint32_t opcode_vkResetDescriptorPool = OP_vkResetDescriptorPool;
stream->write(&opcode_vkResetDescriptorPool, sizeof(uint32_t));
stream->write(&packetSize_vkResetDescriptorPool, sizeof(uint32_t));
- uint64_t cgen_var_418;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_418, 1);
- stream->write((uint64_t*)&cgen_var_418, 1 * 8);
- uint64_t cgen_var_419;
- stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_419, 1);
- stream->write((uint64_t*)&cgen_var_419, 1 * 8);
+ uint64_t cgen_var_422;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_422, 1);
+ stream->write((uint64_t*)&cgen_var_422, 1 * 8);
+ uint64_t cgen_var_423;
+ stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_423, 1);
+ stream->write((uint64_t*)&cgen_var_423, 1 * 8);
stream->write((VkDescriptorPoolResetFlags*)&local_flags, sizeof(VkDescriptorPoolResetFlags));
AEMU_SCOPED_TRACE("vkResetDescriptorPool readParams");
AEMU_SCOPED_TRACE("vkResetDescriptorPool returnUnmarshal");
@@ -5753,6 +5937,7 @@
const VkDescriptorSetAllocateInfo* pAllocateInfo,
VkDescriptorSet* pDescriptorSets)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkAllocateDescriptorSets encode");
mImpl->log("start vkAllocateDescriptorSets");
auto stream = mImpl->stream();
@@ -5775,16 +5960,16 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_420;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_420, 1);
- countingStream->write((uint64_t*)&cgen_var_420, 1 * 8);
+ uint64_t cgen_var_424;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_424, 1);
+ countingStream->write((uint64_t*)&cgen_var_424, 1 * 8);
marshal_VkDescriptorSetAllocateInfo(countingStream, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo));
if (pAllocateInfo->descriptorSetCount)
{
- uint64_t* cgen_var_421;
- countingStream->alloc((void**)&cgen_var_421, pAllocateInfo->descriptorSetCount * 8);
- countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(pDescriptorSets, cgen_var_421, pAllocateInfo->descriptorSetCount);
- countingStream->write((uint64_t*)cgen_var_421, pAllocateInfo->descriptorSetCount * 8);
+ uint64_t* cgen_var_425;
+ countingStream->alloc((void**)&cgen_var_425, pAllocateInfo->descriptorSetCount * 8);
+ countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(pDescriptorSets, cgen_var_425, pAllocateInfo->descriptorSetCount);
+ countingStream->write((uint64_t*)cgen_var_425, pAllocateInfo->descriptorSetCount * 8);
}
}
uint32_t packetSize_vkAllocateDescriptorSets = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -5792,27 +5977,27 @@
uint32_t opcode_vkAllocateDescriptorSets = OP_vkAllocateDescriptorSets;
stream->write(&opcode_vkAllocateDescriptorSets, sizeof(uint32_t));
stream->write(&packetSize_vkAllocateDescriptorSets, sizeof(uint32_t));
- uint64_t cgen_var_422;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_422, 1);
- stream->write((uint64_t*)&cgen_var_422, 1 * 8);
+ uint64_t cgen_var_426;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_426, 1);
+ stream->write((uint64_t*)&cgen_var_426, 1 * 8);
marshal_VkDescriptorSetAllocateInfo(stream, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo));
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
if (pAllocateInfo->descriptorSetCount)
{
- uint64_t* cgen_var_423;
- stream->alloc((void**)&cgen_var_423, pAllocateInfo->descriptorSetCount * 8);
- stream->handleMapping()->mapHandles_VkDescriptorSet_u64(pDescriptorSets, cgen_var_423, pAllocateInfo->descriptorSetCount);
- stream->write((uint64_t*)cgen_var_423, pAllocateInfo->descriptorSetCount * 8);
+ uint64_t* cgen_var_427;
+ stream->alloc((void**)&cgen_var_427, pAllocateInfo->descriptorSetCount * 8);
+ stream->handleMapping()->mapHandles_VkDescriptorSet_u64(pDescriptorSets, cgen_var_427, pAllocateInfo->descriptorSetCount);
+ stream->write((uint64_t*)cgen_var_427, pAllocateInfo->descriptorSetCount * 8);
}
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkAllocateDescriptorSets readParams");
stream->setHandleMapping(resources->createMapping());
if (pAllocateInfo->descriptorSetCount)
{
- uint64_t* cgen_var_424;
- stream->alloc((void**)&cgen_var_424, pAllocateInfo->descriptorSetCount * 8);
- stream->read((uint64_t*)cgen_var_424, pAllocateInfo->descriptorSetCount * 8);
- stream->handleMapping()->mapHandles_u64_VkDescriptorSet(cgen_var_424, (VkDescriptorSet*)pDescriptorSets, pAllocateInfo->descriptorSetCount);
+ uint64_t* cgen_var_428;
+ stream->alloc((void**)&cgen_var_428, pAllocateInfo->descriptorSetCount * 8);
+ stream->read((uint64_t*)cgen_var_428, pAllocateInfo->descriptorSetCount * 8);
+ stream->handleMapping()->mapHandles_u64_VkDescriptorSet(cgen_var_428, (VkDescriptorSet*)pDescriptorSets, pAllocateInfo->descriptorSetCount);
}
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkAllocateDescriptorSets returnUnmarshal");
@@ -5831,6 +6016,7 @@
uint32_t descriptorSetCount,
const VkDescriptorSet* pDescriptorSets)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkFreeDescriptorSets encode");
mImpl->log("start vkFreeDescriptorSets");
auto stream = mImpl->stream();
@@ -5852,24 +6038,24 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_425;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_425, 1);
- countingStream->write((uint64_t*)&cgen_var_425, 1 * 8);
- uint64_t cgen_var_426;
- countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_426, 1);
- countingStream->write((uint64_t*)&cgen_var_426, 1 * 8);
+ uint64_t cgen_var_429;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_429, 1);
+ countingStream->write((uint64_t*)&cgen_var_429, 1 * 8);
+ uint64_t cgen_var_430;
+ countingStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_430, 1);
+ countingStream->write((uint64_t*)&cgen_var_430, 1 * 8);
countingStream->write((uint32_t*)&local_descriptorSetCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_427 = (uint64_t)(uintptr_t)local_pDescriptorSets;
- countingStream->putBe64(cgen_var_427);
+ uint64_t cgen_var_431 = (uint64_t)(uintptr_t)local_pDescriptorSets;
+ countingStream->putBe64(cgen_var_431);
if (local_pDescriptorSets)
{
if (((descriptorSetCount)))
{
- uint64_t* cgen_var_428;
- countingStream->alloc((void**)&cgen_var_428, ((descriptorSetCount)) * 8);
- countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_428, ((descriptorSetCount)));
- countingStream->write((uint64_t*)cgen_var_428, ((descriptorSetCount)) * 8);
+ uint64_t* cgen_var_432;
+ countingStream->alloc((void**)&cgen_var_432, ((descriptorSetCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_432, ((descriptorSetCount)));
+ countingStream->write((uint64_t*)cgen_var_432, ((descriptorSetCount)) * 8);
}
}
}
@@ -5878,24 +6064,24 @@
uint32_t opcode_vkFreeDescriptorSets = OP_vkFreeDescriptorSets;
stream->write(&opcode_vkFreeDescriptorSets, sizeof(uint32_t));
stream->write(&packetSize_vkFreeDescriptorSets, sizeof(uint32_t));
- uint64_t cgen_var_429;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_429, 1);
- stream->write((uint64_t*)&cgen_var_429, 1 * 8);
- uint64_t cgen_var_430;
- stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_430, 1);
- stream->write((uint64_t*)&cgen_var_430, 1 * 8);
+ uint64_t cgen_var_433;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_433, 1);
+ stream->write((uint64_t*)&cgen_var_433, 1 * 8);
+ uint64_t cgen_var_434;
+ stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_434, 1);
+ stream->write((uint64_t*)&cgen_var_434, 1 * 8);
stream->write((uint32_t*)&local_descriptorSetCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_431 = (uint64_t)(uintptr_t)local_pDescriptorSets;
- stream->putBe64(cgen_var_431);
+ uint64_t cgen_var_435 = (uint64_t)(uintptr_t)local_pDescriptorSets;
+ stream->putBe64(cgen_var_435);
if (local_pDescriptorSets)
{
if (((descriptorSetCount)))
{
- uint64_t* cgen_var_432;
- stream->alloc((void**)&cgen_var_432, ((descriptorSetCount)) * 8);
- stream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_432, ((descriptorSetCount)));
- stream->write((uint64_t*)cgen_var_432, ((descriptorSetCount)) * 8);
+ uint64_t* cgen_var_436;
+ stream->alloc((void**)&cgen_var_436, ((descriptorSetCount)) * 8);
+ stream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_436, ((descriptorSetCount)));
+ stream->write((uint64_t*)cgen_var_436, ((descriptorSetCount)) * 8);
}
}
AEMU_SCOPED_TRACE("vkFreeDescriptorSets readParams");
@@ -5920,6 +6106,7 @@
uint32_t descriptorCopyCount,
const VkCopyDescriptorSet* pDescriptorCopies)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkUpdateDescriptorSets encode");
mImpl->log("start vkUpdateDescriptorSets");
auto stream = mImpl->stream();
@@ -5969,9 +6156,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_433;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_433, 1);
- countingStream->write((uint64_t*)&cgen_var_433, 1 * 8);
+ uint64_t cgen_var_437;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_437, 1);
+ countingStream->write((uint64_t*)&cgen_var_437, 1 * 8);
countingStream->write((uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
{
@@ -5988,9 +6175,9 @@
uint32_t opcode_vkUpdateDescriptorSets = OP_vkUpdateDescriptorSets;
stream->write(&opcode_vkUpdateDescriptorSets, sizeof(uint32_t));
stream->write(&packetSize_vkUpdateDescriptorSets, sizeof(uint32_t));
- uint64_t cgen_var_434;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_434, 1);
- stream->write((uint64_t*)&cgen_var_434, 1 * 8);
+ uint64_t cgen_var_438;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_438, 1);
+ stream->write((uint64_t*)&cgen_var_438, 1 * 8);
stream->write((uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
{
@@ -6012,6 +6199,7 @@
const VkAllocationCallbacks* pAllocator,
VkFramebuffer* pFramebuffer)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateFramebuffer encode");
mImpl->log("start vkCreateFramebuffer");
auto stream = mImpl->stream();
@@ -6046,47 +6234,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_435;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_435, 1);
- countingStream->write((uint64_t*)&cgen_var_435, 1 * 8);
+ uint64_t cgen_var_439;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_439, 1);
+ countingStream->write((uint64_t*)&cgen_var_439, 1 * 8);
marshal_VkFramebufferCreateInfo(countingStream, (VkFramebufferCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_436 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_436);
+ uint64_t cgen_var_440 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_440);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_437;
- countingStream->handleMapping()->mapHandles_VkFramebuffer_u64(pFramebuffer, &cgen_var_437, 1);
- countingStream->write((uint64_t*)&cgen_var_437, 8);
+ uint64_t cgen_var_441;
+ countingStream->handleMapping()->mapHandles_VkFramebuffer_u64(pFramebuffer, &cgen_var_441, 1);
+ countingStream->write((uint64_t*)&cgen_var_441, 8);
}
uint32_t packetSize_vkCreateFramebuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateFramebuffer = OP_vkCreateFramebuffer;
stream->write(&opcode_vkCreateFramebuffer, sizeof(uint32_t));
stream->write(&packetSize_vkCreateFramebuffer, sizeof(uint32_t));
- uint64_t cgen_var_438;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_438, 1);
- stream->write((uint64_t*)&cgen_var_438, 1 * 8);
+ uint64_t cgen_var_442;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_442, 1);
+ stream->write((uint64_t*)&cgen_var_442, 1 * 8);
marshal_VkFramebufferCreateInfo(stream, (VkFramebufferCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_439 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_439);
+ uint64_t cgen_var_443 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_443);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_440;
- stream->handleMapping()->mapHandles_VkFramebuffer_u64(pFramebuffer, &cgen_var_440, 1);
- stream->write((uint64_t*)&cgen_var_440, 8);
+ uint64_t cgen_var_444;
+ stream->handleMapping()->mapHandles_VkFramebuffer_u64(pFramebuffer, &cgen_var_444, 1);
+ stream->write((uint64_t*)&cgen_var_444, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateFramebuffer readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_441;
- stream->read((uint64_t*)&cgen_var_441, 8);
- stream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_441, (VkFramebuffer*)pFramebuffer, 1);
+ uint64_t cgen_var_445;
+ stream->read((uint64_t*)&cgen_var_445, 8);
+ stream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_445, (VkFramebuffer*)pFramebuffer, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateFramebuffer returnUnmarshal");
VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
@@ -6103,6 +6291,7 @@
VkFramebuffer framebuffer,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyFramebuffer encode");
mImpl->log("start vkDestroyFramebuffer");
auto stream = mImpl->stream();
@@ -6128,15 +6317,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_442;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_442, 1);
- countingStream->write((uint64_t*)&cgen_var_442, 1 * 8);
- uint64_t cgen_var_443;
- countingStream->handleMapping()->mapHandles_VkFramebuffer_u64(&local_framebuffer, &cgen_var_443, 1);
- countingStream->write((uint64_t*)&cgen_var_443, 1 * 8);
+ uint64_t cgen_var_446;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_446, 1);
+ countingStream->write((uint64_t*)&cgen_var_446, 1 * 8);
+ uint64_t cgen_var_447;
+ countingStream->handleMapping()->mapHandles_VkFramebuffer_u64(&local_framebuffer, &cgen_var_447, 1);
+ countingStream->write((uint64_t*)&cgen_var_447, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_444 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_444);
+ uint64_t cgen_var_448 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_448);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -6147,15 +6336,15 @@
uint32_t opcode_vkDestroyFramebuffer = OP_vkDestroyFramebuffer;
stream->write(&opcode_vkDestroyFramebuffer, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyFramebuffer, sizeof(uint32_t));
- uint64_t cgen_var_445;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_445, 1);
- stream->write((uint64_t*)&cgen_var_445, 1 * 8);
- uint64_t cgen_var_446;
- stream->handleMapping()->mapHandles_VkFramebuffer_u64(&local_framebuffer, &cgen_var_446, 1);
- stream->write((uint64_t*)&cgen_var_446, 1 * 8);
+ uint64_t cgen_var_449;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_449, 1);
+ stream->write((uint64_t*)&cgen_var_449, 1 * 8);
+ uint64_t cgen_var_450;
+ stream->handleMapping()->mapHandles_VkFramebuffer_u64(&local_framebuffer, &cgen_var_450, 1);
+ stream->write((uint64_t*)&cgen_var_450, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_447 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_447);
+ uint64_t cgen_var_451 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_451);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -6172,6 +6361,7 @@
const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateRenderPass encode");
mImpl->log("start vkCreateRenderPass");
auto stream = mImpl->stream();
@@ -6206,47 +6396,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_448;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_448, 1);
- countingStream->write((uint64_t*)&cgen_var_448, 1 * 8);
+ uint64_t cgen_var_452;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_452, 1);
+ countingStream->write((uint64_t*)&cgen_var_452, 1 * 8);
marshal_VkRenderPassCreateInfo(countingStream, (VkRenderPassCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_449 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_449);
+ uint64_t cgen_var_453 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_453);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_450;
- countingStream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_450, 1);
- countingStream->write((uint64_t*)&cgen_var_450, 8);
+ uint64_t cgen_var_454;
+ countingStream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_454, 1);
+ countingStream->write((uint64_t*)&cgen_var_454, 8);
}
uint32_t packetSize_vkCreateRenderPass = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateRenderPass = OP_vkCreateRenderPass;
stream->write(&opcode_vkCreateRenderPass, sizeof(uint32_t));
stream->write(&packetSize_vkCreateRenderPass, sizeof(uint32_t));
- uint64_t cgen_var_451;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_451, 1);
- stream->write((uint64_t*)&cgen_var_451, 1 * 8);
+ uint64_t cgen_var_455;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_455, 1);
+ stream->write((uint64_t*)&cgen_var_455, 1 * 8);
marshal_VkRenderPassCreateInfo(stream, (VkRenderPassCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_452 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_452);
+ uint64_t cgen_var_456 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_456);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_453;
- stream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_453, 1);
- stream->write((uint64_t*)&cgen_var_453, 8);
+ uint64_t cgen_var_457;
+ stream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_457, 1);
+ stream->write((uint64_t*)&cgen_var_457, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateRenderPass readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_454;
- stream->read((uint64_t*)&cgen_var_454, 8);
- stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_454, (VkRenderPass*)pRenderPass, 1);
+ uint64_t cgen_var_458;
+ stream->read((uint64_t*)&cgen_var_458, 8);
+ stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_458, (VkRenderPass*)pRenderPass, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateRenderPass returnUnmarshal");
VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
@@ -6263,6 +6453,7 @@
VkRenderPass renderPass,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyRenderPass encode");
mImpl->log("start vkDestroyRenderPass");
auto stream = mImpl->stream();
@@ -6288,15 +6479,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_455;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_455, 1);
- countingStream->write((uint64_t*)&cgen_var_455, 1 * 8);
- uint64_t cgen_var_456;
- countingStream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_456, 1);
- countingStream->write((uint64_t*)&cgen_var_456, 1 * 8);
+ uint64_t cgen_var_459;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_459, 1);
+ countingStream->write((uint64_t*)&cgen_var_459, 1 * 8);
+ uint64_t cgen_var_460;
+ countingStream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_460, 1);
+ countingStream->write((uint64_t*)&cgen_var_460, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_457 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_457);
+ uint64_t cgen_var_461 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_461);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -6307,15 +6498,15 @@
uint32_t opcode_vkDestroyRenderPass = OP_vkDestroyRenderPass;
stream->write(&opcode_vkDestroyRenderPass, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyRenderPass, sizeof(uint32_t));
- uint64_t cgen_var_458;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_458, 1);
- stream->write((uint64_t*)&cgen_var_458, 1 * 8);
- uint64_t cgen_var_459;
- stream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_459, 1);
- stream->write((uint64_t*)&cgen_var_459, 1 * 8);
+ uint64_t cgen_var_462;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_462, 1);
+ stream->write((uint64_t*)&cgen_var_462, 1 * 8);
+ uint64_t cgen_var_463;
+ stream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_463, 1);
+ stream->write((uint64_t*)&cgen_var_463, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_460 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_460);
+ uint64_t cgen_var_464 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_464);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -6331,6 +6522,7 @@
VkRenderPass renderPass,
VkExtent2D* pGranularity)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity encode");
mImpl->log("start vkGetRenderAreaGranularity");
auto stream = mImpl->stream();
@@ -6344,12 +6536,12 @@
local_renderPass = renderPass;
countingStream->rewind();
{
- uint64_t cgen_var_461;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_461, 1);
- countingStream->write((uint64_t*)&cgen_var_461, 1 * 8);
- uint64_t cgen_var_462;
- countingStream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_462, 1);
- countingStream->write((uint64_t*)&cgen_var_462, 1 * 8);
+ uint64_t cgen_var_465;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_465, 1);
+ countingStream->write((uint64_t*)&cgen_var_465, 1 * 8);
+ uint64_t cgen_var_466;
+ countingStream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_466, 1);
+ countingStream->write((uint64_t*)&cgen_var_466, 1 * 8);
marshal_VkExtent2D(countingStream, (VkExtent2D*)(pGranularity));
}
uint32_t packetSize_vkGetRenderAreaGranularity = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -6357,12 +6549,12 @@
uint32_t opcode_vkGetRenderAreaGranularity = OP_vkGetRenderAreaGranularity;
stream->write(&opcode_vkGetRenderAreaGranularity, sizeof(uint32_t));
stream->write(&packetSize_vkGetRenderAreaGranularity, sizeof(uint32_t));
- uint64_t cgen_var_463;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_463, 1);
- stream->write((uint64_t*)&cgen_var_463, 1 * 8);
- uint64_t cgen_var_464;
- stream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_464, 1);
- stream->write((uint64_t*)&cgen_var_464, 1 * 8);
+ uint64_t cgen_var_467;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_467, 1);
+ stream->write((uint64_t*)&cgen_var_467, 1 * 8);
+ uint64_t cgen_var_468;
+ stream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_468, 1);
+ stream->write((uint64_t*)&cgen_var_468, 1 * 8);
marshal_VkExtent2D(stream, (VkExtent2D*)(pGranularity));
AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity readParams");
unmarshal_VkExtent2D(stream, (VkExtent2D*)(pGranularity));
@@ -6380,6 +6572,7 @@
const VkAllocationCallbacks* pAllocator,
VkCommandPool* pCommandPool)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateCommandPool encode");
mImpl->log("start vkCreateCommandPool");
auto stream = mImpl->stream();
@@ -6414,47 +6607,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_465;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_465, 1);
- countingStream->write((uint64_t*)&cgen_var_465, 1 * 8);
+ uint64_t cgen_var_469;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_469, 1);
+ countingStream->write((uint64_t*)&cgen_var_469, 1 * 8);
marshal_VkCommandPoolCreateInfo(countingStream, (VkCommandPoolCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_466 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_466);
+ uint64_t cgen_var_470 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_470);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_467;
- countingStream->handleMapping()->mapHandles_VkCommandPool_u64(pCommandPool, &cgen_var_467, 1);
- countingStream->write((uint64_t*)&cgen_var_467, 8);
+ uint64_t cgen_var_471;
+ countingStream->handleMapping()->mapHandles_VkCommandPool_u64(pCommandPool, &cgen_var_471, 1);
+ countingStream->write((uint64_t*)&cgen_var_471, 8);
}
uint32_t packetSize_vkCreateCommandPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateCommandPool = OP_vkCreateCommandPool;
stream->write(&opcode_vkCreateCommandPool, sizeof(uint32_t));
stream->write(&packetSize_vkCreateCommandPool, sizeof(uint32_t));
- uint64_t cgen_var_468;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_468, 1);
- stream->write((uint64_t*)&cgen_var_468, 1 * 8);
+ uint64_t cgen_var_472;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_472, 1);
+ stream->write((uint64_t*)&cgen_var_472, 1 * 8);
marshal_VkCommandPoolCreateInfo(stream, (VkCommandPoolCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_469 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_469);
+ uint64_t cgen_var_473 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_473);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_470;
- stream->handleMapping()->mapHandles_VkCommandPool_u64(pCommandPool, &cgen_var_470, 1);
- stream->write((uint64_t*)&cgen_var_470, 8);
+ uint64_t cgen_var_474;
+ stream->handleMapping()->mapHandles_VkCommandPool_u64(pCommandPool, &cgen_var_474, 1);
+ stream->write((uint64_t*)&cgen_var_474, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateCommandPool readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_471;
- stream->read((uint64_t*)&cgen_var_471, 8);
- stream->handleMapping()->mapHandles_u64_VkCommandPool(&cgen_var_471, (VkCommandPool*)pCommandPool, 1);
+ uint64_t cgen_var_475;
+ stream->read((uint64_t*)&cgen_var_475, 8);
+ stream->handleMapping()->mapHandles_u64_VkCommandPool(&cgen_var_475, (VkCommandPool*)pCommandPool, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateCommandPool returnUnmarshal");
VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
@@ -6471,6 +6664,7 @@
VkCommandPool commandPool,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyCommandPool encode");
mImpl->log("start vkDestroyCommandPool");
auto stream = mImpl->stream();
@@ -6496,15 +6690,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_472;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_472, 1);
- countingStream->write((uint64_t*)&cgen_var_472, 1 * 8);
- uint64_t cgen_var_473;
- countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_473, 1);
- countingStream->write((uint64_t*)&cgen_var_473, 1 * 8);
+ uint64_t cgen_var_476;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_476, 1);
+ countingStream->write((uint64_t*)&cgen_var_476, 1 * 8);
+ uint64_t cgen_var_477;
+ countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_477, 1);
+ countingStream->write((uint64_t*)&cgen_var_477, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_474 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_474);
+ uint64_t cgen_var_478 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_478);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -6515,15 +6709,15 @@
uint32_t opcode_vkDestroyCommandPool = OP_vkDestroyCommandPool;
stream->write(&opcode_vkDestroyCommandPool, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyCommandPool, sizeof(uint32_t));
- uint64_t cgen_var_475;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_475, 1);
- stream->write((uint64_t*)&cgen_var_475, 1 * 8);
- uint64_t cgen_var_476;
- stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_476, 1);
- stream->write((uint64_t*)&cgen_var_476, 1 * 8);
+ uint64_t cgen_var_479;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_479, 1);
+ stream->write((uint64_t*)&cgen_var_479, 1 * 8);
+ uint64_t cgen_var_480;
+ stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_480, 1);
+ stream->write((uint64_t*)&cgen_var_480, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_477 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_477);
+ uint64_t cgen_var_481 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_481);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -6539,6 +6733,7 @@
VkCommandPool commandPool,
VkCommandPoolResetFlags flags)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkResetCommandPool encode");
mImpl->log("start vkResetCommandPool");
auto stream = mImpl->stream();
@@ -6554,12 +6749,12 @@
local_flags = flags;
countingStream->rewind();
{
- uint64_t cgen_var_478;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_478, 1);
- countingStream->write((uint64_t*)&cgen_var_478, 1 * 8);
- uint64_t cgen_var_479;
- countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_479, 1);
- countingStream->write((uint64_t*)&cgen_var_479, 1 * 8);
+ uint64_t cgen_var_482;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_482, 1);
+ countingStream->write((uint64_t*)&cgen_var_482, 1 * 8);
+ uint64_t cgen_var_483;
+ countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_483, 1);
+ countingStream->write((uint64_t*)&cgen_var_483, 1 * 8);
countingStream->write((VkCommandPoolResetFlags*)&local_flags, sizeof(VkCommandPoolResetFlags));
}
uint32_t packetSize_vkResetCommandPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -6567,12 +6762,12 @@
uint32_t opcode_vkResetCommandPool = OP_vkResetCommandPool;
stream->write(&opcode_vkResetCommandPool, sizeof(uint32_t));
stream->write(&packetSize_vkResetCommandPool, sizeof(uint32_t));
- uint64_t cgen_var_480;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_480, 1);
- stream->write((uint64_t*)&cgen_var_480, 1 * 8);
- uint64_t cgen_var_481;
- stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_481, 1);
- stream->write((uint64_t*)&cgen_var_481, 1 * 8);
+ uint64_t cgen_var_484;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_484, 1);
+ stream->write((uint64_t*)&cgen_var_484, 1 * 8);
+ uint64_t cgen_var_485;
+ stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_485, 1);
+ stream->write((uint64_t*)&cgen_var_485, 1 * 8);
stream->write((VkCommandPoolResetFlags*)&local_flags, sizeof(VkCommandPoolResetFlags));
AEMU_SCOPED_TRACE("vkResetCommandPool readParams");
AEMU_SCOPED_TRACE("vkResetCommandPool returnUnmarshal");
@@ -6590,6 +6785,7 @@
const VkCommandBufferAllocateInfo* pAllocateInfo,
VkCommandBuffer* pCommandBuffers)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkAllocateCommandBuffers encode");
mImpl->log("start vkAllocateCommandBuffers");
auto stream = mImpl->stream();
@@ -6612,16 +6808,16 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_482;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_482, 1);
- countingStream->write((uint64_t*)&cgen_var_482, 1 * 8);
+ uint64_t cgen_var_486;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_486, 1);
+ countingStream->write((uint64_t*)&cgen_var_486, 1 * 8);
marshal_VkCommandBufferAllocateInfo(countingStream, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo));
if (pAllocateInfo->commandBufferCount)
{
- uint64_t* cgen_var_483;
- countingStream->alloc((void**)&cgen_var_483, pAllocateInfo->commandBufferCount * 8);
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(pCommandBuffers, cgen_var_483, pAllocateInfo->commandBufferCount);
- countingStream->write((uint64_t*)cgen_var_483, pAllocateInfo->commandBufferCount * 8);
+ uint64_t* cgen_var_487;
+ countingStream->alloc((void**)&cgen_var_487, pAllocateInfo->commandBufferCount * 8);
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(pCommandBuffers, cgen_var_487, pAllocateInfo->commandBufferCount);
+ countingStream->write((uint64_t*)cgen_var_487, pAllocateInfo->commandBufferCount * 8);
}
}
uint32_t packetSize_vkAllocateCommandBuffers = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -6629,27 +6825,27 @@
uint32_t opcode_vkAllocateCommandBuffers = OP_vkAllocateCommandBuffers;
stream->write(&opcode_vkAllocateCommandBuffers, sizeof(uint32_t));
stream->write(&packetSize_vkAllocateCommandBuffers, sizeof(uint32_t));
- uint64_t cgen_var_484;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_484, 1);
- stream->write((uint64_t*)&cgen_var_484, 1 * 8);
+ uint64_t cgen_var_488;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_488, 1);
+ stream->write((uint64_t*)&cgen_var_488, 1 * 8);
marshal_VkCommandBufferAllocateInfo(stream, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo));
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
if (pAllocateInfo->commandBufferCount)
{
- uint64_t* cgen_var_485;
- stream->alloc((void**)&cgen_var_485, pAllocateInfo->commandBufferCount * 8);
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(pCommandBuffers, cgen_var_485, pAllocateInfo->commandBufferCount);
- stream->write((uint64_t*)cgen_var_485, pAllocateInfo->commandBufferCount * 8);
+ uint64_t* cgen_var_489;
+ stream->alloc((void**)&cgen_var_489, pAllocateInfo->commandBufferCount * 8);
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(pCommandBuffers, cgen_var_489, pAllocateInfo->commandBufferCount);
+ stream->write((uint64_t*)cgen_var_489, pAllocateInfo->commandBufferCount * 8);
}
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkAllocateCommandBuffers readParams");
stream->setHandleMapping(resources->createMapping());
if (pAllocateInfo->commandBufferCount)
{
- uint64_t* cgen_var_486;
- stream->alloc((void**)&cgen_var_486, pAllocateInfo->commandBufferCount * 8);
- stream->read((uint64_t*)cgen_var_486, pAllocateInfo->commandBufferCount * 8);
- stream->handleMapping()->mapHandles_u64_VkCommandBuffer(cgen_var_486, (VkCommandBuffer*)pCommandBuffers, pAllocateInfo->commandBufferCount);
+ uint64_t* cgen_var_490;
+ stream->alloc((void**)&cgen_var_490, pAllocateInfo->commandBufferCount * 8);
+ stream->read((uint64_t*)cgen_var_490, pAllocateInfo->commandBufferCount * 8);
+ stream->handleMapping()->mapHandles_u64_VkCommandBuffer(cgen_var_490, (VkCommandBuffer*)pCommandBuffers, pAllocateInfo->commandBufferCount);
}
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkAllocateCommandBuffers returnUnmarshal");
@@ -6668,6 +6864,7 @@
uint32_t commandBufferCount,
const VkCommandBuffer* pCommandBuffers)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkFreeCommandBuffers encode");
mImpl->log("start vkFreeCommandBuffers");
auto stream = mImpl->stream();
@@ -6689,24 +6886,24 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_487;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_487, 1);
- countingStream->write((uint64_t*)&cgen_var_487, 1 * 8);
- uint64_t cgen_var_488;
- countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_488, 1);
- countingStream->write((uint64_t*)&cgen_var_488, 1 * 8);
+ uint64_t cgen_var_491;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_491, 1);
+ countingStream->write((uint64_t*)&cgen_var_491, 1 * 8);
+ uint64_t cgen_var_492;
+ countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_492, 1);
+ countingStream->write((uint64_t*)&cgen_var_492, 1 * 8);
countingStream->write((uint32_t*)&local_commandBufferCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_489 = (uint64_t)(uintptr_t)local_pCommandBuffers;
- countingStream->putBe64(cgen_var_489);
+ uint64_t cgen_var_493 = (uint64_t)(uintptr_t)local_pCommandBuffers;
+ countingStream->putBe64(cgen_var_493);
if (local_pCommandBuffers)
{
if (((commandBufferCount)))
{
- uint64_t* cgen_var_490;
- countingStream->alloc((void**)&cgen_var_490, ((commandBufferCount)) * 8);
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_490, ((commandBufferCount)));
- countingStream->write((uint64_t*)cgen_var_490, ((commandBufferCount)) * 8);
+ uint64_t* cgen_var_494;
+ countingStream->alloc((void**)&cgen_var_494, ((commandBufferCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_494, ((commandBufferCount)));
+ countingStream->write((uint64_t*)cgen_var_494, ((commandBufferCount)) * 8);
}
}
}
@@ -6715,24 +6912,24 @@
uint32_t opcode_vkFreeCommandBuffers = OP_vkFreeCommandBuffers;
stream->write(&opcode_vkFreeCommandBuffers, sizeof(uint32_t));
stream->write(&packetSize_vkFreeCommandBuffers, sizeof(uint32_t));
- uint64_t cgen_var_491;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_491, 1);
- stream->write((uint64_t*)&cgen_var_491, 1 * 8);
- uint64_t cgen_var_492;
- stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_492, 1);
- stream->write((uint64_t*)&cgen_var_492, 1 * 8);
+ uint64_t cgen_var_495;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_495, 1);
+ stream->write((uint64_t*)&cgen_var_495, 1 * 8);
+ uint64_t cgen_var_496;
+ stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_496, 1);
+ stream->write((uint64_t*)&cgen_var_496, 1 * 8);
stream->write((uint32_t*)&local_commandBufferCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_493 = (uint64_t)(uintptr_t)local_pCommandBuffers;
- stream->putBe64(cgen_var_493);
+ uint64_t cgen_var_497 = (uint64_t)(uintptr_t)local_pCommandBuffers;
+ stream->putBe64(cgen_var_497);
if (local_pCommandBuffers)
{
if (((commandBufferCount)))
{
- uint64_t* cgen_var_494;
- stream->alloc((void**)&cgen_var_494, ((commandBufferCount)) * 8);
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_494, ((commandBufferCount)));
- stream->write((uint64_t*)cgen_var_494, ((commandBufferCount)) * 8);
+ uint64_t* cgen_var_498;
+ stream->alloc((void**)&cgen_var_498, ((commandBufferCount)) * 8);
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_498, ((commandBufferCount)));
+ stream->write((uint64_t*)cgen_var_498, ((commandBufferCount)) * 8);
}
}
AEMU_SCOPED_TRACE("vkFreeCommandBuffers readParams");
@@ -6748,6 +6945,7 @@
VkCommandBuffer commandBuffer,
const VkCommandBufferBeginInfo* pBeginInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkBeginCommandBuffer encode");
mImpl->log("start vkBeginCommandBuffer");
auto stream = mImpl->stream();
@@ -6770,9 +6968,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_495;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_495, 1);
- countingStream->write((uint64_t*)&cgen_var_495, 1 * 8);
+ uint64_t cgen_var_499;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_499, 1);
+ countingStream->write((uint64_t*)&cgen_var_499, 1 * 8);
marshal_VkCommandBufferBeginInfo(countingStream, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
}
uint32_t packetSize_vkBeginCommandBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -6780,9 +6978,9 @@
uint32_t opcode_vkBeginCommandBuffer = OP_vkBeginCommandBuffer;
stream->write(&opcode_vkBeginCommandBuffer, sizeof(uint32_t));
stream->write(&packetSize_vkBeginCommandBuffer, sizeof(uint32_t));
- uint64_t cgen_var_496;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_496, 1);
- stream->write((uint64_t*)&cgen_var_496, 1 * 8);
+ uint64_t cgen_var_500;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_500, 1);
+ stream->write((uint64_t*)&cgen_var_500, 1 * 8);
marshal_VkCommandBufferBeginInfo(stream, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
AEMU_SCOPED_TRACE("vkBeginCommandBuffer readParams");
AEMU_SCOPED_TRACE("vkBeginCommandBuffer returnUnmarshal");
@@ -6798,6 +6996,7 @@
VkResult VkEncoder::vkEndCommandBuffer(
VkCommandBuffer commandBuffer)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkEndCommandBuffer encode");
mImpl->log("start vkEndCommandBuffer");
auto stream = mImpl->stream();
@@ -6809,18 +7008,18 @@
local_commandBuffer = commandBuffer;
countingStream->rewind();
{
- uint64_t cgen_var_497;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_497, 1);
- countingStream->write((uint64_t*)&cgen_var_497, 1 * 8);
+ uint64_t cgen_var_501;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_501, 1);
+ countingStream->write((uint64_t*)&cgen_var_501, 1 * 8);
}
uint32_t packetSize_vkEndCommandBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkEndCommandBuffer = OP_vkEndCommandBuffer;
stream->write(&opcode_vkEndCommandBuffer, sizeof(uint32_t));
stream->write(&packetSize_vkEndCommandBuffer, sizeof(uint32_t));
- uint64_t cgen_var_498;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_498, 1);
- stream->write((uint64_t*)&cgen_var_498, 1 * 8);
+ uint64_t cgen_var_502;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_502, 1);
+ stream->write((uint64_t*)&cgen_var_502, 1 * 8);
AEMU_SCOPED_TRACE("vkEndCommandBuffer readParams");
AEMU_SCOPED_TRACE("vkEndCommandBuffer returnUnmarshal");
VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
@@ -6836,6 +7035,7 @@
VkCommandBuffer commandBuffer,
VkCommandBufferResetFlags flags)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkResetCommandBuffer encode");
mImpl->log("start vkResetCommandBuffer");
auto stream = mImpl->stream();
@@ -6849,9 +7049,9 @@
local_flags = flags;
countingStream->rewind();
{
- uint64_t cgen_var_499;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_499, 1);
- countingStream->write((uint64_t*)&cgen_var_499, 1 * 8);
+ uint64_t cgen_var_503;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_503, 1);
+ countingStream->write((uint64_t*)&cgen_var_503, 1 * 8);
countingStream->write((VkCommandBufferResetFlags*)&local_flags, sizeof(VkCommandBufferResetFlags));
}
uint32_t packetSize_vkResetCommandBuffer = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -6859,9 +7059,9 @@
uint32_t opcode_vkResetCommandBuffer = OP_vkResetCommandBuffer;
stream->write(&opcode_vkResetCommandBuffer, sizeof(uint32_t));
stream->write(&packetSize_vkResetCommandBuffer, sizeof(uint32_t));
- uint64_t cgen_var_500;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_500, 1);
- stream->write((uint64_t*)&cgen_var_500, 1 * 8);
+ uint64_t cgen_var_504;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_504, 1);
+ stream->write((uint64_t*)&cgen_var_504, 1 * 8);
stream->write((VkCommandBufferResetFlags*)&local_flags, sizeof(VkCommandBufferResetFlags));
AEMU_SCOPED_TRACE("vkResetCommandBuffer readParams");
AEMU_SCOPED_TRACE("vkResetCommandBuffer returnUnmarshal");
@@ -6879,6 +7079,7 @@
VkPipelineBindPoint pipelineBindPoint,
VkPipeline pipeline)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdBindPipeline encode");
mImpl->log("start vkCmdBindPipeline");
auto stream = mImpl->stream();
@@ -6894,26 +7095,26 @@
local_pipeline = pipeline;
countingStream->rewind();
{
- uint64_t cgen_var_501;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_501, 1);
- countingStream->write((uint64_t*)&cgen_var_501, 1 * 8);
+ uint64_t cgen_var_505;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_505, 1);
+ countingStream->write((uint64_t*)&cgen_var_505, 1 * 8);
countingStream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
- uint64_t cgen_var_502;
- countingStream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_502, 1);
- countingStream->write((uint64_t*)&cgen_var_502, 1 * 8);
+ uint64_t cgen_var_506;
+ countingStream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_506, 1);
+ countingStream->write((uint64_t*)&cgen_var_506, 1 * 8);
}
uint32_t packetSize_vkCmdBindPipeline = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCmdBindPipeline = OP_vkCmdBindPipeline;
stream->write(&opcode_vkCmdBindPipeline, sizeof(uint32_t));
stream->write(&packetSize_vkCmdBindPipeline, sizeof(uint32_t));
- uint64_t cgen_var_503;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_503, 1);
- stream->write((uint64_t*)&cgen_var_503, 1 * 8);
+ uint64_t cgen_var_507;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_507, 1);
+ stream->write((uint64_t*)&cgen_var_507, 1 * 8);
stream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
- uint64_t cgen_var_504;
- stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_504, 1);
- stream->write((uint64_t*)&cgen_var_504, 1 * 8);
+ uint64_t cgen_var_508;
+ stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_508, 1);
+ stream->write((uint64_t*)&cgen_var_508, 1 * 8);
AEMU_SCOPED_TRACE("vkCmdBindPipeline readParams");
AEMU_SCOPED_TRACE("vkCmdBindPipeline returnUnmarshal");
mImpl->log("finish vkCmdBindPipeline");;
@@ -6925,6 +7126,7 @@
uint32_t viewportCount,
const VkViewport* pViewports)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdSetViewport encode");
mImpl->log("start vkCmdSetViewport");
auto stream = mImpl->stream();
@@ -6957,9 +7159,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_505;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_505, 1);
- countingStream->write((uint64_t*)&cgen_var_505, 1 * 8);
+ uint64_t cgen_var_509;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_509, 1);
+ countingStream->write((uint64_t*)&cgen_var_509, 1 * 8);
countingStream->write((uint32_t*)&local_firstViewport, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_viewportCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
@@ -6972,9 +7174,9 @@
uint32_t opcode_vkCmdSetViewport = OP_vkCmdSetViewport;
stream->write(&opcode_vkCmdSetViewport, sizeof(uint32_t));
stream->write(&packetSize_vkCmdSetViewport, sizeof(uint32_t));
- uint64_t cgen_var_506;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_506, 1);
- stream->write((uint64_t*)&cgen_var_506, 1 * 8);
+ uint64_t cgen_var_510;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_510, 1);
+ stream->write((uint64_t*)&cgen_var_510, 1 * 8);
stream->write((uint32_t*)&local_firstViewport, sizeof(uint32_t));
stream->write((uint32_t*)&local_viewportCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
@@ -6992,6 +7194,7 @@
uint32_t scissorCount,
const VkRect2D* pScissors)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdSetScissor encode");
mImpl->log("start vkCmdSetScissor");
auto stream = mImpl->stream();
@@ -7024,9 +7227,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_507;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_507, 1);
- countingStream->write((uint64_t*)&cgen_var_507, 1 * 8);
+ uint64_t cgen_var_511;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_511, 1);
+ countingStream->write((uint64_t*)&cgen_var_511, 1 * 8);
countingStream->write((uint32_t*)&local_firstScissor, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_scissorCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
@@ -7039,9 +7242,9 @@
uint32_t opcode_vkCmdSetScissor = OP_vkCmdSetScissor;
stream->write(&opcode_vkCmdSetScissor, sizeof(uint32_t));
stream->write(&packetSize_vkCmdSetScissor, sizeof(uint32_t));
- uint64_t cgen_var_508;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_508, 1);
- stream->write((uint64_t*)&cgen_var_508, 1 * 8);
+ uint64_t cgen_var_512;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_512, 1);
+ stream->write((uint64_t*)&cgen_var_512, 1 * 8);
stream->write((uint32_t*)&local_firstScissor, sizeof(uint32_t));
stream->write((uint32_t*)&local_scissorCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
@@ -7057,6 +7260,7 @@
VkCommandBuffer commandBuffer,
float lineWidth)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdSetLineWidth encode");
mImpl->log("start vkCmdSetLineWidth");
auto stream = mImpl->stream();
@@ -7070,9 +7274,9 @@
local_lineWidth = lineWidth;
countingStream->rewind();
{
- uint64_t cgen_var_509;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_509, 1);
- countingStream->write((uint64_t*)&cgen_var_509, 1 * 8);
+ uint64_t cgen_var_513;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_513, 1);
+ countingStream->write((uint64_t*)&cgen_var_513, 1 * 8);
countingStream->write((float*)&local_lineWidth, sizeof(float));
}
uint32_t packetSize_vkCmdSetLineWidth = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -7080,9 +7284,9 @@
uint32_t opcode_vkCmdSetLineWidth = OP_vkCmdSetLineWidth;
stream->write(&opcode_vkCmdSetLineWidth, sizeof(uint32_t));
stream->write(&packetSize_vkCmdSetLineWidth, sizeof(uint32_t));
- uint64_t cgen_var_510;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_510, 1);
- stream->write((uint64_t*)&cgen_var_510, 1 * 8);
+ uint64_t cgen_var_514;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_514, 1);
+ stream->write((uint64_t*)&cgen_var_514, 1 * 8);
stream->write((float*)&local_lineWidth, sizeof(float));
AEMU_SCOPED_TRACE("vkCmdSetLineWidth readParams");
AEMU_SCOPED_TRACE("vkCmdSetLineWidth returnUnmarshal");
@@ -7095,6 +7299,7 @@
float depthBiasClamp,
float depthBiasSlopeFactor)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdSetDepthBias encode");
mImpl->log("start vkCmdSetDepthBias");
auto stream = mImpl->stream();
@@ -7112,9 +7317,9 @@
local_depthBiasSlopeFactor = depthBiasSlopeFactor;
countingStream->rewind();
{
- uint64_t cgen_var_511;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_511, 1);
- countingStream->write((uint64_t*)&cgen_var_511, 1 * 8);
+ uint64_t cgen_var_515;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_515, 1);
+ countingStream->write((uint64_t*)&cgen_var_515, 1 * 8);
countingStream->write((float*)&local_depthBiasConstantFactor, sizeof(float));
countingStream->write((float*)&local_depthBiasClamp, sizeof(float));
countingStream->write((float*)&local_depthBiasSlopeFactor, sizeof(float));
@@ -7124,9 +7329,9 @@
uint32_t opcode_vkCmdSetDepthBias = OP_vkCmdSetDepthBias;
stream->write(&opcode_vkCmdSetDepthBias, sizeof(uint32_t));
stream->write(&packetSize_vkCmdSetDepthBias, sizeof(uint32_t));
- uint64_t cgen_var_512;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_512, 1);
- stream->write((uint64_t*)&cgen_var_512, 1 * 8);
+ uint64_t cgen_var_516;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_516, 1);
+ stream->write((uint64_t*)&cgen_var_516, 1 * 8);
stream->write((float*)&local_depthBiasConstantFactor, sizeof(float));
stream->write((float*)&local_depthBiasClamp, sizeof(float));
stream->write((float*)&local_depthBiasSlopeFactor, sizeof(float));
@@ -7139,6 +7344,7 @@
VkCommandBuffer commandBuffer,
const float blendConstants[4])
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdSetBlendConstants encode");
mImpl->log("start vkCmdSetBlendConstants");
auto stream = mImpl->stream();
@@ -7152,9 +7358,9 @@
memcpy(&local_blendConstants, &blendConstants, 4 * sizeof(const float));
countingStream->rewind();
{
- uint64_t cgen_var_513;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_513, 1);
- countingStream->write((uint64_t*)&cgen_var_513, 1 * 8);
+ uint64_t cgen_var_517;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_517, 1);
+ countingStream->write((uint64_t*)&cgen_var_517, 1 * 8);
countingStream->write((float*)&local_blendConstants, 4 * sizeof(float));
}
uint32_t packetSize_vkCmdSetBlendConstants = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -7162,9 +7368,9 @@
uint32_t opcode_vkCmdSetBlendConstants = OP_vkCmdSetBlendConstants;
stream->write(&opcode_vkCmdSetBlendConstants, sizeof(uint32_t));
stream->write(&packetSize_vkCmdSetBlendConstants, sizeof(uint32_t));
- uint64_t cgen_var_514;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_514, 1);
- stream->write((uint64_t*)&cgen_var_514, 1 * 8);
+ uint64_t cgen_var_518;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_518, 1);
+ stream->write((uint64_t*)&cgen_var_518, 1 * 8);
stream->write((float*)&local_blendConstants, 4 * sizeof(float));
AEMU_SCOPED_TRACE("vkCmdSetBlendConstants readParams");
AEMU_SCOPED_TRACE("vkCmdSetBlendConstants returnUnmarshal");
@@ -7176,6 +7382,7 @@
float minDepthBounds,
float maxDepthBounds)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdSetDepthBounds encode");
mImpl->log("start vkCmdSetDepthBounds");
auto stream = mImpl->stream();
@@ -7191,9 +7398,9 @@
local_maxDepthBounds = maxDepthBounds;
countingStream->rewind();
{
- uint64_t cgen_var_515;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_515, 1);
- countingStream->write((uint64_t*)&cgen_var_515, 1 * 8);
+ uint64_t cgen_var_519;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_519, 1);
+ countingStream->write((uint64_t*)&cgen_var_519, 1 * 8);
countingStream->write((float*)&local_minDepthBounds, sizeof(float));
countingStream->write((float*)&local_maxDepthBounds, sizeof(float));
}
@@ -7202,9 +7409,9 @@
uint32_t opcode_vkCmdSetDepthBounds = OP_vkCmdSetDepthBounds;
stream->write(&opcode_vkCmdSetDepthBounds, sizeof(uint32_t));
stream->write(&packetSize_vkCmdSetDepthBounds, sizeof(uint32_t));
- uint64_t cgen_var_516;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_516, 1);
- stream->write((uint64_t*)&cgen_var_516, 1 * 8);
+ uint64_t cgen_var_520;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_520, 1);
+ stream->write((uint64_t*)&cgen_var_520, 1 * 8);
stream->write((float*)&local_minDepthBounds, sizeof(float));
stream->write((float*)&local_maxDepthBounds, sizeof(float));
AEMU_SCOPED_TRACE("vkCmdSetDepthBounds readParams");
@@ -7217,6 +7424,7 @@
VkStencilFaceFlags faceMask,
uint32_t compareMask)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask encode");
mImpl->log("start vkCmdSetStencilCompareMask");
auto stream = mImpl->stream();
@@ -7232,9 +7440,9 @@
local_compareMask = compareMask;
countingStream->rewind();
{
- uint64_t cgen_var_517;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_517, 1);
- countingStream->write((uint64_t*)&cgen_var_517, 1 * 8);
+ uint64_t cgen_var_521;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_521, 1);
+ countingStream->write((uint64_t*)&cgen_var_521, 1 * 8);
countingStream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
countingStream->write((uint32_t*)&local_compareMask, sizeof(uint32_t));
}
@@ -7243,9 +7451,9 @@
uint32_t opcode_vkCmdSetStencilCompareMask = OP_vkCmdSetStencilCompareMask;
stream->write(&opcode_vkCmdSetStencilCompareMask, sizeof(uint32_t));
stream->write(&packetSize_vkCmdSetStencilCompareMask, sizeof(uint32_t));
- uint64_t cgen_var_518;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_518, 1);
- stream->write((uint64_t*)&cgen_var_518, 1 * 8);
+ uint64_t cgen_var_522;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_522, 1);
+ stream->write((uint64_t*)&cgen_var_522, 1 * 8);
stream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
stream->write((uint32_t*)&local_compareMask, sizeof(uint32_t));
AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask readParams");
@@ -7258,6 +7466,7 @@
VkStencilFaceFlags faceMask,
uint32_t writeMask)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask encode");
mImpl->log("start vkCmdSetStencilWriteMask");
auto stream = mImpl->stream();
@@ -7273,9 +7482,9 @@
local_writeMask = writeMask;
countingStream->rewind();
{
- uint64_t cgen_var_519;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_519, 1);
- countingStream->write((uint64_t*)&cgen_var_519, 1 * 8);
+ uint64_t cgen_var_523;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_523, 1);
+ countingStream->write((uint64_t*)&cgen_var_523, 1 * 8);
countingStream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
countingStream->write((uint32_t*)&local_writeMask, sizeof(uint32_t));
}
@@ -7284,9 +7493,9 @@
uint32_t opcode_vkCmdSetStencilWriteMask = OP_vkCmdSetStencilWriteMask;
stream->write(&opcode_vkCmdSetStencilWriteMask, sizeof(uint32_t));
stream->write(&packetSize_vkCmdSetStencilWriteMask, sizeof(uint32_t));
- uint64_t cgen_var_520;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_520, 1);
- stream->write((uint64_t*)&cgen_var_520, 1 * 8);
+ uint64_t cgen_var_524;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_524, 1);
+ stream->write((uint64_t*)&cgen_var_524, 1 * 8);
stream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
stream->write((uint32_t*)&local_writeMask, sizeof(uint32_t));
AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask readParams");
@@ -7299,6 +7508,7 @@
VkStencilFaceFlags faceMask,
uint32_t reference)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdSetStencilReference encode");
mImpl->log("start vkCmdSetStencilReference");
auto stream = mImpl->stream();
@@ -7314,9 +7524,9 @@
local_reference = reference;
countingStream->rewind();
{
- uint64_t cgen_var_521;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_521, 1);
- countingStream->write((uint64_t*)&cgen_var_521, 1 * 8);
+ uint64_t cgen_var_525;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_525, 1);
+ countingStream->write((uint64_t*)&cgen_var_525, 1 * 8);
countingStream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
countingStream->write((uint32_t*)&local_reference, sizeof(uint32_t));
}
@@ -7325,9 +7535,9 @@
uint32_t opcode_vkCmdSetStencilReference = OP_vkCmdSetStencilReference;
stream->write(&opcode_vkCmdSetStencilReference, sizeof(uint32_t));
stream->write(&packetSize_vkCmdSetStencilReference, sizeof(uint32_t));
- uint64_t cgen_var_522;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_522, 1);
- stream->write((uint64_t*)&cgen_var_522, 1 * 8);
+ uint64_t cgen_var_526;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_526, 1);
+ stream->write((uint64_t*)&cgen_var_526, 1 * 8);
stream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags));
stream->write((uint32_t*)&local_reference, sizeof(uint32_t));
AEMU_SCOPED_TRACE("vkCmdSetStencilReference readParams");
@@ -7345,6 +7555,7 @@
uint32_t dynamicOffsetCount,
const uint32_t* pDynamicOffsets)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets encode");
mImpl->log("start vkCmdBindDescriptorSets");
auto stream = mImpl->stream();
@@ -7378,21 +7589,21 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_523;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_523, 1);
- countingStream->write((uint64_t*)&cgen_var_523, 1 * 8);
+ uint64_t cgen_var_527;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_527, 1);
+ countingStream->write((uint64_t*)&cgen_var_527, 1 * 8);
countingStream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
- uint64_t cgen_var_524;
- countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_524, 1);
- countingStream->write((uint64_t*)&cgen_var_524, 1 * 8);
+ uint64_t cgen_var_528;
+ countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_528, 1);
+ countingStream->write((uint64_t*)&cgen_var_528, 1 * 8);
countingStream->write((uint32_t*)&local_firstSet, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_descriptorSetCount, sizeof(uint32_t));
if (((descriptorSetCount)))
{
- uint64_t* cgen_var_525;
- countingStream->alloc((void**)&cgen_var_525, ((descriptorSetCount)) * 8);
- countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_525, ((descriptorSetCount)));
- countingStream->write((uint64_t*)cgen_var_525, ((descriptorSetCount)) * 8);
+ uint64_t* cgen_var_529;
+ countingStream->alloc((void**)&cgen_var_529, ((descriptorSetCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_529, ((descriptorSetCount)));
+ countingStream->write((uint64_t*)cgen_var_529, ((descriptorSetCount)) * 8);
}
countingStream->write((uint32_t*)&local_dynamicOffsetCount, sizeof(uint32_t));
countingStream->write((uint32_t*)local_pDynamicOffsets, ((dynamicOffsetCount)) * sizeof(uint32_t));
@@ -7402,21 +7613,21 @@
uint32_t opcode_vkCmdBindDescriptorSets = OP_vkCmdBindDescriptorSets;
stream->write(&opcode_vkCmdBindDescriptorSets, sizeof(uint32_t));
stream->write(&packetSize_vkCmdBindDescriptorSets, sizeof(uint32_t));
- uint64_t cgen_var_526;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_526, 1);
- stream->write((uint64_t*)&cgen_var_526, 1 * 8);
+ uint64_t cgen_var_530;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_530, 1);
+ stream->write((uint64_t*)&cgen_var_530, 1 * 8);
stream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
- uint64_t cgen_var_527;
- stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_527, 1);
- stream->write((uint64_t*)&cgen_var_527, 1 * 8);
+ uint64_t cgen_var_531;
+ stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_531, 1);
+ stream->write((uint64_t*)&cgen_var_531, 1 * 8);
stream->write((uint32_t*)&local_firstSet, sizeof(uint32_t));
stream->write((uint32_t*)&local_descriptorSetCount, sizeof(uint32_t));
if (((descriptorSetCount)))
{
- uint64_t* cgen_var_528;
- stream->alloc((void**)&cgen_var_528, ((descriptorSetCount)) * 8);
- stream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_528, ((descriptorSetCount)));
- stream->write((uint64_t*)cgen_var_528, ((descriptorSetCount)) * 8);
+ uint64_t* cgen_var_532;
+ stream->alloc((void**)&cgen_var_532, ((descriptorSetCount)) * 8);
+ stream->handleMapping()->mapHandles_VkDescriptorSet_u64(local_pDescriptorSets, cgen_var_532, ((descriptorSetCount)));
+ stream->write((uint64_t*)cgen_var_532, ((descriptorSetCount)) * 8);
}
stream->write((uint32_t*)&local_dynamicOffsetCount, sizeof(uint32_t));
stream->write((uint32_t*)local_pDynamicOffsets, ((dynamicOffsetCount)) * sizeof(uint32_t));
@@ -7431,6 +7642,7 @@
VkDeviceSize offset,
VkIndexType indexType)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer encode");
mImpl->log("start vkCmdBindIndexBuffer");
auto stream = mImpl->stream();
@@ -7448,12 +7660,12 @@
local_indexType = indexType;
countingStream->rewind();
{
- uint64_t cgen_var_529;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_529, 1);
- countingStream->write((uint64_t*)&cgen_var_529, 1 * 8);
- uint64_t cgen_var_530;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_530, 1);
- countingStream->write((uint64_t*)&cgen_var_530, 1 * 8);
+ uint64_t cgen_var_533;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_533, 1);
+ countingStream->write((uint64_t*)&cgen_var_533, 1 * 8);
+ uint64_t cgen_var_534;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_534, 1);
+ countingStream->write((uint64_t*)&cgen_var_534, 1 * 8);
countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
countingStream->write((VkIndexType*)&local_indexType, sizeof(VkIndexType));
}
@@ -7462,12 +7674,12 @@
uint32_t opcode_vkCmdBindIndexBuffer = OP_vkCmdBindIndexBuffer;
stream->write(&opcode_vkCmdBindIndexBuffer, sizeof(uint32_t));
stream->write(&packetSize_vkCmdBindIndexBuffer, sizeof(uint32_t));
- uint64_t cgen_var_531;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_531, 1);
- stream->write((uint64_t*)&cgen_var_531, 1 * 8);
- uint64_t cgen_var_532;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_532, 1);
- stream->write((uint64_t*)&cgen_var_532, 1 * 8);
+ uint64_t cgen_var_535;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_535, 1);
+ stream->write((uint64_t*)&cgen_var_535, 1 * 8);
+ uint64_t cgen_var_536;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_536, 1);
+ stream->write((uint64_t*)&cgen_var_536, 1 * 8);
stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
stream->write((VkIndexType*)&local_indexType, sizeof(VkIndexType));
AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer readParams");
@@ -7482,6 +7694,7 @@
const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers encode");
mImpl->log("start vkCmdBindVertexBuffers");
auto stream = mImpl->stream();
@@ -7509,17 +7722,17 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_533;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_533, 1);
- countingStream->write((uint64_t*)&cgen_var_533, 1 * 8);
+ uint64_t cgen_var_537;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_537, 1);
+ countingStream->write((uint64_t*)&cgen_var_537, 1 * 8);
countingStream->write((uint32_t*)&local_firstBinding, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_bindingCount, sizeof(uint32_t));
if (((bindingCount)))
{
- uint64_t* cgen_var_534;
- countingStream->alloc((void**)&cgen_var_534, ((bindingCount)) * 8);
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(local_pBuffers, cgen_var_534, ((bindingCount)));
- countingStream->write((uint64_t*)cgen_var_534, ((bindingCount)) * 8);
+ uint64_t* cgen_var_538;
+ countingStream->alloc((void**)&cgen_var_538, ((bindingCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(local_pBuffers, cgen_var_538, ((bindingCount)));
+ countingStream->write((uint64_t*)cgen_var_538, ((bindingCount)) * 8);
}
countingStream->write((VkDeviceSize*)local_pOffsets, ((bindingCount)) * sizeof(VkDeviceSize));
}
@@ -7528,17 +7741,17 @@
uint32_t opcode_vkCmdBindVertexBuffers = OP_vkCmdBindVertexBuffers;
stream->write(&opcode_vkCmdBindVertexBuffers, sizeof(uint32_t));
stream->write(&packetSize_vkCmdBindVertexBuffers, sizeof(uint32_t));
- uint64_t cgen_var_535;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_535, 1);
- stream->write((uint64_t*)&cgen_var_535, 1 * 8);
+ uint64_t cgen_var_539;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_539, 1);
+ stream->write((uint64_t*)&cgen_var_539, 1 * 8);
stream->write((uint32_t*)&local_firstBinding, sizeof(uint32_t));
stream->write((uint32_t*)&local_bindingCount, sizeof(uint32_t));
if (((bindingCount)))
{
- uint64_t* cgen_var_536;
- stream->alloc((void**)&cgen_var_536, ((bindingCount)) * 8);
- stream->handleMapping()->mapHandles_VkBuffer_u64(local_pBuffers, cgen_var_536, ((bindingCount)));
- stream->write((uint64_t*)cgen_var_536, ((bindingCount)) * 8);
+ uint64_t* cgen_var_540;
+ stream->alloc((void**)&cgen_var_540, ((bindingCount)) * 8);
+ stream->handleMapping()->mapHandles_VkBuffer_u64(local_pBuffers, cgen_var_540, ((bindingCount)));
+ stream->write((uint64_t*)cgen_var_540, ((bindingCount)) * 8);
}
stream->write((VkDeviceSize*)local_pOffsets, ((bindingCount)) * sizeof(VkDeviceSize));
AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers readParams");
@@ -7553,6 +7766,7 @@
uint32_t firstVertex,
uint32_t firstInstance)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdDraw encode");
mImpl->log("start vkCmdDraw");
auto stream = mImpl->stream();
@@ -7572,9 +7786,9 @@
local_firstInstance = firstInstance;
countingStream->rewind();
{
- uint64_t cgen_var_537;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_537, 1);
- countingStream->write((uint64_t*)&cgen_var_537, 1 * 8);
+ uint64_t cgen_var_541;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_541, 1);
+ countingStream->write((uint64_t*)&cgen_var_541, 1 * 8);
countingStream->write((uint32_t*)&local_vertexCount, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_instanceCount, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_firstVertex, sizeof(uint32_t));
@@ -7585,9 +7799,9 @@
uint32_t opcode_vkCmdDraw = OP_vkCmdDraw;
stream->write(&opcode_vkCmdDraw, sizeof(uint32_t));
stream->write(&packetSize_vkCmdDraw, sizeof(uint32_t));
- uint64_t cgen_var_538;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_538, 1);
- stream->write((uint64_t*)&cgen_var_538, 1 * 8);
+ uint64_t cgen_var_542;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_542, 1);
+ stream->write((uint64_t*)&cgen_var_542, 1 * 8);
stream->write((uint32_t*)&local_vertexCount, sizeof(uint32_t));
stream->write((uint32_t*)&local_instanceCount, sizeof(uint32_t));
stream->write((uint32_t*)&local_firstVertex, sizeof(uint32_t));
@@ -7605,6 +7819,7 @@
int32_t vertexOffset,
uint32_t firstInstance)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdDrawIndexed encode");
mImpl->log("start vkCmdDrawIndexed");
auto stream = mImpl->stream();
@@ -7626,9 +7841,9 @@
local_firstInstance = firstInstance;
countingStream->rewind();
{
- uint64_t cgen_var_539;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_539, 1);
- countingStream->write((uint64_t*)&cgen_var_539, 1 * 8);
+ uint64_t cgen_var_543;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_543, 1);
+ countingStream->write((uint64_t*)&cgen_var_543, 1 * 8);
countingStream->write((uint32_t*)&local_indexCount, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_instanceCount, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_firstIndex, sizeof(uint32_t));
@@ -7640,9 +7855,9 @@
uint32_t opcode_vkCmdDrawIndexed = OP_vkCmdDrawIndexed;
stream->write(&opcode_vkCmdDrawIndexed, sizeof(uint32_t));
stream->write(&packetSize_vkCmdDrawIndexed, sizeof(uint32_t));
- uint64_t cgen_var_540;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_540, 1);
- stream->write((uint64_t*)&cgen_var_540, 1 * 8);
+ uint64_t cgen_var_544;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_544, 1);
+ stream->write((uint64_t*)&cgen_var_544, 1 * 8);
stream->write((uint32_t*)&local_indexCount, sizeof(uint32_t));
stream->write((uint32_t*)&local_instanceCount, sizeof(uint32_t));
stream->write((uint32_t*)&local_firstIndex, sizeof(uint32_t));
@@ -7660,6 +7875,7 @@
uint32_t drawCount,
uint32_t stride)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdDrawIndirect encode");
mImpl->log("start vkCmdDrawIndirect");
auto stream = mImpl->stream();
@@ -7679,61 +7895,6 @@
local_stride = stride;
countingStream->rewind();
{
- uint64_t cgen_var_541;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_541, 1);
- countingStream->write((uint64_t*)&cgen_var_541, 1 * 8);
- uint64_t cgen_var_542;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_542, 1);
- countingStream->write((uint64_t*)&cgen_var_542, 1 * 8);
- countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
- countingStream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
- countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
- }
- uint32_t packetSize_vkCmdDrawIndirect = 4 + 4 + (uint32_t)countingStream->bytesWritten();
- countingStream->rewind();
- uint32_t opcode_vkCmdDrawIndirect = OP_vkCmdDrawIndirect;
- stream->write(&opcode_vkCmdDrawIndirect, sizeof(uint32_t));
- stream->write(&packetSize_vkCmdDrawIndirect, sizeof(uint32_t));
- uint64_t cgen_var_543;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_543, 1);
- stream->write((uint64_t*)&cgen_var_543, 1 * 8);
- uint64_t cgen_var_544;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_544, 1);
- stream->write((uint64_t*)&cgen_var_544, 1 * 8);
- stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
- stream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
- stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
- AEMU_SCOPED_TRACE("vkCmdDrawIndirect readParams");
- AEMU_SCOPED_TRACE("vkCmdDrawIndirect returnUnmarshal");
- mImpl->log("finish vkCmdDrawIndirect");;
-}
-
-void VkEncoder::vkCmdDrawIndexedIndirect(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- uint32_t drawCount,
- uint32_t stride)
-{
- AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect encode");
- mImpl->log("start vkCmdDrawIndexedIndirect");
- auto stream = mImpl->stream();
- auto countingStream = mImpl->countingStream();
- auto resources = mImpl->resources();
- auto pool = mImpl->pool();
- stream->setHandleMapping(resources->unwrapMapping());
- VkCommandBuffer local_commandBuffer;
- VkBuffer local_buffer;
- VkDeviceSize local_offset;
- uint32_t local_drawCount;
- uint32_t local_stride;
- local_commandBuffer = commandBuffer;
- local_buffer = buffer;
- local_offset = offset;
- local_drawCount = drawCount;
- local_stride = stride;
- countingStream->rewind();
- {
uint64_t cgen_var_545;
countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_545, 1);
countingStream->write((uint64_t*)&cgen_var_545, 1 * 8);
@@ -7744,11 +7905,11 @@
countingStream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
}
- uint32_t packetSize_vkCmdDrawIndexedIndirect = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ uint32_t packetSize_vkCmdDrawIndirect = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
- uint32_t opcode_vkCmdDrawIndexedIndirect = OP_vkCmdDrawIndexedIndirect;
- stream->write(&opcode_vkCmdDrawIndexedIndirect, sizeof(uint32_t));
- stream->write(&packetSize_vkCmdDrawIndexedIndirect, sizeof(uint32_t));
+ uint32_t opcode_vkCmdDrawIndirect = OP_vkCmdDrawIndirect;
+ stream->write(&opcode_vkCmdDrawIndirect, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDrawIndirect, sizeof(uint32_t));
uint64_t cgen_var_547;
stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_547, 1);
stream->write((uint64_t*)&cgen_var_547, 1 * 8);
@@ -7758,6 +7919,62 @@
stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
stream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+ AEMU_SCOPED_TRACE("vkCmdDrawIndirect readParams");
+ AEMU_SCOPED_TRACE("vkCmdDrawIndirect returnUnmarshal");
+ mImpl->log("finish vkCmdDrawIndirect");;
+}
+
+void VkEncoder::vkCmdDrawIndexedIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride)
+{
+ AutoLock encoderLock(mImpl->lock);
+ AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect encode");
+ mImpl->log("start vkCmdDrawIndexedIndirect");
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkBuffer local_buffer;
+ VkDeviceSize local_offset;
+ uint32_t local_drawCount;
+ uint32_t local_stride;
+ local_commandBuffer = commandBuffer;
+ local_buffer = buffer;
+ local_offset = offset;
+ local_drawCount = drawCount;
+ local_stride = stride;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_549;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_549, 1);
+ countingStream->write((uint64_t*)&cgen_var_549, 1 * 8);
+ uint64_t cgen_var_550;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_550, 1);
+ countingStream->write((uint64_t*)&cgen_var_550, 1 * 8);
+ countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+ countingStream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCmdDrawIndexedIndirect = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdDrawIndexedIndirect = OP_vkCmdDrawIndexedIndirect;
+ stream->write(&opcode_vkCmdDrawIndexedIndirect, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDrawIndexedIndirect, sizeof(uint32_t));
+ uint64_t cgen_var_551;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_551, 1);
+ stream->write((uint64_t*)&cgen_var_551, 1 * 8);
+ uint64_t cgen_var_552;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_552, 1);
+ stream->write((uint64_t*)&cgen_var_552, 1 * 8);
+ stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
+ stream->write((uint32_t*)&local_drawCount, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect readParams");
AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect returnUnmarshal");
mImpl->log("finish vkCmdDrawIndexedIndirect");;
@@ -7769,6 +7986,7 @@
uint32_t groupCountY,
uint32_t groupCountZ)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdDispatch encode");
mImpl->log("start vkCmdDispatch");
auto stream = mImpl->stream();
@@ -7786,9 +8004,9 @@
local_groupCountZ = groupCountZ;
countingStream->rewind();
{
- uint64_t cgen_var_549;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_549, 1);
- countingStream->write((uint64_t*)&cgen_var_549, 1 * 8);
+ uint64_t cgen_var_553;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_553, 1);
+ countingStream->write((uint64_t*)&cgen_var_553, 1 * 8);
countingStream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
@@ -7798,9 +8016,9 @@
uint32_t opcode_vkCmdDispatch = OP_vkCmdDispatch;
stream->write(&opcode_vkCmdDispatch, sizeof(uint32_t));
stream->write(&packetSize_vkCmdDispatch, sizeof(uint32_t));
- uint64_t cgen_var_550;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_550, 1);
- stream->write((uint64_t*)&cgen_var_550, 1 * 8);
+ uint64_t cgen_var_554;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_554, 1);
+ stream->write((uint64_t*)&cgen_var_554, 1 * 8);
stream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t));
stream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t));
stream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t));
@@ -7814,6 +8032,7 @@
VkBuffer buffer,
VkDeviceSize offset)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdDispatchIndirect encode");
mImpl->log("start vkCmdDispatchIndirect");
auto stream = mImpl->stream();
@@ -7829,12 +8048,12 @@
local_offset = offset;
countingStream->rewind();
{
- uint64_t cgen_var_551;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_551, 1);
- countingStream->write((uint64_t*)&cgen_var_551, 1 * 8);
- uint64_t cgen_var_552;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_552, 1);
- countingStream->write((uint64_t*)&cgen_var_552, 1 * 8);
+ uint64_t cgen_var_555;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_555, 1);
+ countingStream->write((uint64_t*)&cgen_var_555, 1 * 8);
+ uint64_t cgen_var_556;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_556, 1);
+ countingStream->write((uint64_t*)&cgen_var_556, 1 * 8);
countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
}
uint32_t packetSize_vkCmdDispatchIndirect = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -7842,12 +8061,12 @@
uint32_t opcode_vkCmdDispatchIndirect = OP_vkCmdDispatchIndirect;
stream->write(&opcode_vkCmdDispatchIndirect, sizeof(uint32_t));
stream->write(&packetSize_vkCmdDispatchIndirect, sizeof(uint32_t));
- uint64_t cgen_var_553;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_553, 1);
- stream->write((uint64_t*)&cgen_var_553, 1 * 8);
- uint64_t cgen_var_554;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_554, 1);
- stream->write((uint64_t*)&cgen_var_554, 1 * 8);
+ uint64_t cgen_var_557;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_557, 1);
+ stream->write((uint64_t*)&cgen_var_557, 1 * 8);
+ uint64_t cgen_var_558;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_558, 1);
+ stream->write((uint64_t*)&cgen_var_558, 1 * 8);
stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
AEMU_SCOPED_TRACE("vkCmdDispatchIndirect readParams");
AEMU_SCOPED_TRACE("vkCmdDispatchIndirect returnUnmarshal");
@@ -7861,6 +8080,7 @@
uint32_t regionCount,
const VkBufferCopy* pRegions)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdCopyBuffer encode");
mImpl->log("start vkCmdCopyBuffer");
auto stream = mImpl->stream();
@@ -7895,15 +8115,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_555;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_555, 1);
- countingStream->write((uint64_t*)&cgen_var_555, 1 * 8);
- uint64_t cgen_var_556;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_556, 1);
- countingStream->write((uint64_t*)&cgen_var_556, 1 * 8);
- uint64_t cgen_var_557;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_557, 1);
- countingStream->write((uint64_t*)&cgen_var_557, 1 * 8);
+ uint64_t cgen_var_559;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_559, 1);
+ countingStream->write((uint64_t*)&cgen_var_559, 1 * 8);
+ uint64_t cgen_var_560;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_560, 1);
+ countingStream->write((uint64_t*)&cgen_var_560, 1 * 8);
+ uint64_t cgen_var_561;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_561, 1);
+ countingStream->write((uint64_t*)&cgen_var_561, 1 * 8);
countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
@@ -7915,15 +8135,15 @@
uint32_t opcode_vkCmdCopyBuffer = OP_vkCmdCopyBuffer;
stream->write(&opcode_vkCmdCopyBuffer, sizeof(uint32_t));
stream->write(&packetSize_vkCmdCopyBuffer, sizeof(uint32_t));
- uint64_t cgen_var_558;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_558, 1);
- stream->write((uint64_t*)&cgen_var_558, 1 * 8);
- uint64_t cgen_var_559;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_559, 1);
- stream->write((uint64_t*)&cgen_var_559, 1 * 8);
- uint64_t cgen_var_560;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_560, 1);
- stream->write((uint64_t*)&cgen_var_560, 1 * 8);
+ uint64_t cgen_var_562;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_562, 1);
+ stream->write((uint64_t*)&cgen_var_562, 1 * 8);
+ uint64_t cgen_var_563;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_563, 1);
+ stream->write((uint64_t*)&cgen_var_563, 1 * 8);
+ uint64_t cgen_var_564;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_564, 1);
+ stream->write((uint64_t*)&cgen_var_564, 1 * 8);
stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
@@ -7943,6 +8163,7 @@
uint32_t regionCount,
const VkImageCopy* pRegions)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdCopyImage encode");
mImpl->log("start vkCmdCopyImage");
auto stream = mImpl->stream();
@@ -7981,16 +8202,16 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_561;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_561, 1);
- countingStream->write((uint64_t*)&cgen_var_561, 1 * 8);
- uint64_t cgen_var_562;
- countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_562, 1);
- countingStream->write((uint64_t*)&cgen_var_562, 1 * 8);
+ uint64_t cgen_var_565;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_565, 1);
+ countingStream->write((uint64_t*)&cgen_var_565, 1 * 8);
+ uint64_t cgen_var_566;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_566, 1);
+ countingStream->write((uint64_t*)&cgen_var_566, 1 * 8);
countingStream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
- uint64_t cgen_var_563;
- countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_563, 1);
- countingStream->write((uint64_t*)&cgen_var_563, 1 * 8);
+ uint64_t cgen_var_567;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_567, 1);
+ countingStream->write((uint64_t*)&cgen_var_567, 1 * 8);
countingStream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
@@ -8003,16 +8224,16 @@
uint32_t opcode_vkCmdCopyImage = OP_vkCmdCopyImage;
stream->write(&opcode_vkCmdCopyImage, sizeof(uint32_t));
stream->write(&packetSize_vkCmdCopyImage, sizeof(uint32_t));
- uint64_t cgen_var_564;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_564, 1);
- stream->write((uint64_t*)&cgen_var_564, 1 * 8);
- uint64_t cgen_var_565;
- stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_565, 1);
- stream->write((uint64_t*)&cgen_var_565, 1 * 8);
+ uint64_t cgen_var_568;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_568, 1);
+ stream->write((uint64_t*)&cgen_var_568, 1 * 8);
+ uint64_t cgen_var_569;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_569, 1);
+ stream->write((uint64_t*)&cgen_var_569, 1 * 8);
stream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
- uint64_t cgen_var_566;
- stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_566, 1);
- stream->write((uint64_t*)&cgen_var_566, 1 * 8);
+ uint64_t cgen_var_570;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_570, 1);
+ stream->write((uint64_t*)&cgen_var_570, 1 * 8);
stream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
@@ -8034,6 +8255,7 @@
const VkImageBlit* pRegions,
VkFilter filter)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdBlitImage encode");
mImpl->log("start vkCmdBlitImage");
auto stream = mImpl->stream();
@@ -8074,16 +8296,16 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_567;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_567, 1);
- countingStream->write((uint64_t*)&cgen_var_567, 1 * 8);
- uint64_t cgen_var_568;
- countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_568, 1);
- countingStream->write((uint64_t*)&cgen_var_568, 1 * 8);
+ uint64_t cgen_var_571;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_571, 1);
+ countingStream->write((uint64_t*)&cgen_var_571, 1 * 8);
+ uint64_t cgen_var_572;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_572, 1);
+ countingStream->write((uint64_t*)&cgen_var_572, 1 * 8);
countingStream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
- uint64_t cgen_var_569;
- countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_569, 1);
- countingStream->write((uint64_t*)&cgen_var_569, 1 * 8);
+ uint64_t cgen_var_573;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_573, 1);
+ countingStream->write((uint64_t*)&cgen_var_573, 1 * 8);
countingStream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
@@ -8097,16 +8319,16 @@
uint32_t opcode_vkCmdBlitImage = OP_vkCmdBlitImage;
stream->write(&opcode_vkCmdBlitImage, sizeof(uint32_t));
stream->write(&packetSize_vkCmdBlitImage, sizeof(uint32_t));
- uint64_t cgen_var_570;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_570, 1);
- stream->write((uint64_t*)&cgen_var_570, 1 * 8);
- uint64_t cgen_var_571;
- stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_571, 1);
- stream->write((uint64_t*)&cgen_var_571, 1 * 8);
+ uint64_t cgen_var_574;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_574, 1);
+ stream->write((uint64_t*)&cgen_var_574, 1 * 8);
+ uint64_t cgen_var_575;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_575, 1);
+ stream->write((uint64_t*)&cgen_var_575, 1 * 8);
stream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
- uint64_t cgen_var_572;
- stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_572, 1);
- stream->write((uint64_t*)&cgen_var_572, 1 * 8);
+ uint64_t cgen_var_576;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_576, 1);
+ stream->write((uint64_t*)&cgen_var_576, 1 * 8);
stream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
@@ -8127,6 +8349,7 @@
uint32_t regionCount,
const VkBufferImageCopy* pRegions)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage encode");
mImpl->log("start vkCmdCopyBufferToImage");
auto stream = mImpl->stream();
@@ -8163,15 +8386,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_573;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_573, 1);
- countingStream->write((uint64_t*)&cgen_var_573, 1 * 8);
- uint64_t cgen_var_574;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_574, 1);
- countingStream->write((uint64_t*)&cgen_var_574, 1 * 8);
- uint64_t cgen_var_575;
- countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_575, 1);
- countingStream->write((uint64_t*)&cgen_var_575, 1 * 8);
+ uint64_t cgen_var_577;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_577, 1);
+ countingStream->write((uint64_t*)&cgen_var_577, 1 * 8);
+ uint64_t cgen_var_578;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_578, 1);
+ countingStream->write((uint64_t*)&cgen_var_578, 1 * 8);
+ uint64_t cgen_var_579;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_579, 1);
+ countingStream->write((uint64_t*)&cgen_var_579, 1 * 8);
countingStream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
@@ -8184,15 +8407,15 @@
uint32_t opcode_vkCmdCopyBufferToImage = OP_vkCmdCopyBufferToImage;
stream->write(&opcode_vkCmdCopyBufferToImage, sizeof(uint32_t));
stream->write(&packetSize_vkCmdCopyBufferToImage, sizeof(uint32_t));
- uint64_t cgen_var_576;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_576, 1);
- stream->write((uint64_t*)&cgen_var_576, 1 * 8);
- uint64_t cgen_var_577;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_577, 1);
- stream->write((uint64_t*)&cgen_var_577, 1 * 8);
- uint64_t cgen_var_578;
- stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_578, 1);
- stream->write((uint64_t*)&cgen_var_578, 1 * 8);
+ uint64_t cgen_var_580;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_580, 1);
+ stream->write((uint64_t*)&cgen_var_580, 1 * 8);
+ uint64_t cgen_var_581;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_srcBuffer, &cgen_var_581, 1);
+ stream->write((uint64_t*)&cgen_var_581, 1 * 8);
+ uint64_t cgen_var_582;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_582, 1);
+ stream->write((uint64_t*)&cgen_var_582, 1 * 8);
stream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
@@ -8212,6 +8435,7 @@
uint32_t regionCount,
const VkBufferImageCopy* pRegions)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer encode");
mImpl->log("start vkCmdCopyImageToBuffer");
auto stream = mImpl->stream();
@@ -8248,16 +8472,16 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_579;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_579, 1);
- countingStream->write((uint64_t*)&cgen_var_579, 1 * 8);
- uint64_t cgen_var_580;
- countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_580, 1);
- countingStream->write((uint64_t*)&cgen_var_580, 1 * 8);
+ uint64_t cgen_var_583;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_583, 1);
+ countingStream->write((uint64_t*)&cgen_var_583, 1 * 8);
+ uint64_t cgen_var_584;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_584, 1);
+ countingStream->write((uint64_t*)&cgen_var_584, 1 * 8);
countingStream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
- uint64_t cgen_var_581;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_581, 1);
- countingStream->write((uint64_t*)&cgen_var_581, 1 * 8);
+ uint64_t cgen_var_585;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_585, 1);
+ countingStream->write((uint64_t*)&cgen_var_585, 1 * 8);
countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
@@ -8269,16 +8493,16 @@
uint32_t opcode_vkCmdCopyImageToBuffer = OP_vkCmdCopyImageToBuffer;
stream->write(&opcode_vkCmdCopyImageToBuffer, sizeof(uint32_t));
stream->write(&packetSize_vkCmdCopyImageToBuffer, sizeof(uint32_t));
- uint64_t cgen_var_582;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_582, 1);
- stream->write((uint64_t*)&cgen_var_582, 1 * 8);
- uint64_t cgen_var_583;
- stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_583, 1);
- stream->write((uint64_t*)&cgen_var_583, 1 * 8);
+ uint64_t cgen_var_586;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_586, 1);
+ stream->write((uint64_t*)&cgen_var_586, 1 * 8);
+ uint64_t cgen_var_587;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_587, 1);
+ stream->write((uint64_t*)&cgen_var_587, 1 * 8);
stream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
- uint64_t cgen_var_584;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_584, 1);
- stream->write((uint64_t*)&cgen_var_584, 1 * 8);
+ uint64_t cgen_var_588;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_588, 1);
+ stream->write((uint64_t*)&cgen_var_588, 1 * 8);
stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
{
@@ -8296,6 +8520,7 @@
VkDeviceSize dataSize,
const void* pData)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdUpdateBuffer encode");
mImpl->log("start vkCmdUpdateBuffer");
auto stream = mImpl->stream();
@@ -8319,12 +8544,12 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_585;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_585, 1);
- countingStream->write((uint64_t*)&cgen_var_585, 1 * 8);
- uint64_t cgen_var_586;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_586, 1);
- countingStream->write((uint64_t*)&cgen_var_586, 1 * 8);
+ uint64_t cgen_var_589;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_589, 1);
+ countingStream->write((uint64_t*)&cgen_var_589, 1 * 8);
+ uint64_t cgen_var_590;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_590, 1);
+ countingStream->write((uint64_t*)&cgen_var_590, 1 * 8);
countingStream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
countingStream->write((VkDeviceSize*)&local_dataSize, sizeof(VkDeviceSize));
countingStream->write((void*)local_pData, ((dataSize)) * sizeof(uint8_t));
@@ -8334,12 +8559,12 @@
uint32_t opcode_vkCmdUpdateBuffer = OP_vkCmdUpdateBuffer;
stream->write(&opcode_vkCmdUpdateBuffer, sizeof(uint32_t));
stream->write(&packetSize_vkCmdUpdateBuffer, sizeof(uint32_t));
- uint64_t cgen_var_587;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_587, 1);
- stream->write((uint64_t*)&cgen_var_587, 1 * 8);
- uint64_t cgen_var_588;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_588, 1);
- stream->write((uint64_t*)&cgen_var_588, 1 * 8);
+ uint64_t cgen_var_591;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_591, 1);
+ stream->write((uint64_t*)&cgen_var_591, 1 * 8);
+ uint64_t cgen_var_592;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_592, 1);
+ stream->write((uint64_t*)&cgen_var_592, 1 * 8);
stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
stream->write((VkDeviceSize*)&local_dataSize, sizeof(VkDeviceSize));
stream->write((void*)local_pData, ((dataSize)) * sizeof(uint8_t));
@@ -8355,6 +8580,7 @@
VkDeviceSize size,
uint32_t data)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdFillBuffer encode");
mImpl->log("start vkCmdFillBuffer");
auto stream = mImpl->stream();
@@ -8374,12 +8600,12 @@
local_data = data;
countingStream->rewind();
{
- uint64_t cgen_var_589;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_589, 1);
- countingStream->write((uint64_t*)&cgen_var_589, 1 * 8);
- uint64_t cgen_var_590;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_590, 1);
- countingStream->write((uint64_t*)&cgen_var_590, 1 * 8);
+ uint64_t cgen_var_593;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_593, 1);
+ countingStream->write((uint64_t*)&cgen_var_593, 1 * 8);
+ uint64_t cgen_var_594;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_594, 1);
+ countingStream->write((uint64_t*)&cgen_var_594, 1 * 8);
countingStream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
countingStream->write((VkDeviceSize*)&local_size, sizeof(VkDeviceSize));
countingStream->write((uint32_t*)&local_data, sizeof(uint32_t));
@@ -8389,12 +8615,12 @@
uint32_t opcode_vkCmdFillBuffer = OP_vkCmdFillBuffer;
stream->write(&opcode_vkCmdFillBuffer, sizeof(uint32_t));
stream->write(&packetSize_vkCmdFillBuffer, sizeof(uint32_t));
- uint64_t cgen_var_591;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_591, 1);
- stream->write((uint64_t*)&cgen_var_591, 1 * 8);
- uint64_t cgen_var_592;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_592, 1);
- stream->write((uint64_t*)&cgen_var_592, 1 * 8);
+ uint64_t cgen_var_595;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_595, 1);
+ stream->write((uint64_t*)&cgen_var_595, 1 * 8);
+ uint64_t cgen_var_596;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_596, 1);
+ stream->write((uint64_t*)&cgen_var_596, 1 * 8);
stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
stream->write((VkDeviceSize*)&local_size, sizeof(VkDeviceSize));
stream->write((uint32_t*)&local_data, sizeof(uint32_t));
@@ -8411,6 +8637,7 @@
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdClearColorImage encode");
mImpl->log("start vkCmdClearColorImage");
auto stream = mImpl->stream();
@@ -8456,12 +8683,12 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_593;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_593, 1);
- countingStream->write((uint64_t*)&cgen_var_593, 1 * 8);
- uint64_t cgen_var_594;
- countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_594, 1);
- countingStream->write((uint64_t*)&cgen_var_594, 1 * 8);
+ uint64_t cgen_var_597;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_597, 1);
+ countingStream->write((uint64_t*)&cgen_var_597, 1 * 8);
+ uint64_t cgen_var_598;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_598, 1);
+ countingStream->write((uint64_t*)&cgen_var_598, 1 * 8);
countingStream->write((VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
marshal_VkClearColorValue(countingStream, (VkClearColorValue*)(local_pColor));
countingStream->write((uint32_t*)&local_rangeCount, sizeof(uint32_t));
@@ -8475,12 +8702,12 @@
uint32_t opcode_vkCmdClearColorImage = OP_vkCmdClearColorImage;
stream->write(&opcode_vkCmdClearColorImage, sizeof(uint32_t));
stream->write(&packetSize_vkCmdClearColorImage, sizeof(uint32_t));
- uint64_t cgen_var_595;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_595, 1);
- stream->write((uint64_t*)&cgen_var_595, 1 * 8);
- uint64_t cgen_var_596;
- stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_596, 1);
- stream->write((uint64_t*)&cgen_var_596, 1 * 8);
+ uint64_t cgen_var_599;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_599, 1);
+ stream->write((uint64_t*)&cgen_var_599, 1 * 8);
+ uint64_t cgen_var_600;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_600, 1);
+ stream->write((uint64_t*)&cgen_var_600, 1 * 8);
stream->write((VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
marshal_VkClearColorValue(stream, (VkClearColorValue*)(local_pColor));
stream->write((uint32_t*)&local_rangeCount, sizeof(uint32_t));
@@ -8501,6 +8728,7 @@
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage encode");
mImpl->log("start vkCmdClearDepthStencilImage");
auto stream = mImpl->stream();
@@ -8546,12 +8774,12 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_597;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_597, 1);
- countingStream->write((uint64_t*)&cgen_var_597, 1 * 8);
- uint64_t cgen_var_598;
- countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_598, 1);
- countingStream->write((uint64_t*)&cgen_var_598, 1 * 8);
+ uint64_t cgen_var_601;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_601, 1);
+ countingStream->write((uint64_t*)&cgen_var_601, 1 * 8);
+ uint64_t cgen_var_602;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_602, 1);
+ countingStream->write((uint64_t*)&cgen_var_602, 1 * 8);
countingStream->write((VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
marshal_VkClearDepthStencilValue(countingStream, (VkClearDepthStencilValue*)(local_pDepthStencil));
countingStream->write((uint32_t*)&local_rangeCount, sizeof(uint32_t));
@@ -8565,12 +8793,12 @@
uint32_t opcode_vkCmdClearDepthStencilImage = OP_vkCmdClearDepthStencilImage;
stream->write(&opcode_vkCmdClearDepthStencilImage, sizeof(uint32_t));
stream->write(&packetSize_vkCmdClearDepthStencilImage, sizeof(uint32_t));
- uint64_t cgen_var_599;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_599, 1);
- stream->write((uint64_t*)&cgen_var_599, 1 * 8);
- uint64_t cgen_var_600;
- stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_600, 1);
- stream->write((uint64_t*)&cgen_var_600, 1 * 8);
+ uint64_t cgen_var_603;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_603, 1);
+ stream->write((uint64_t*)&cgen_var_603, 1 * 8);
+ uint64_t cgen_var_604;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_604, 1);
+ stream->write((uint64_t*)&cgen_var_604, 1 * 8);
stream->write((VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
marshal_VkClearDepthStencilValue(stream, (VkClearDepthStencilValue*)(local_pDepthStencil));
stream->write((uint32_t*)&local_rangeCount, sizeof(uint32_t));
@@ -8590,6 +8818,7 @@
uint32_t rectCount,
const VkClearRect* pRects)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdClearAttachments encode");
mImpl->log("start vkCmdClearAttachments");
auto stream = mImpl->stream();
@@ -8639,9 +8868,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_601;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_601, 1);
- countingStream->write((uint64_t*)&cgen_var_601, 1 * 8);
+ uint64_t cgen_var_605;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_605, 1);
+ countingStream->write((uint64_t*)&cgen_var_605, 1 * 8);
countingStream->write((uint32_t*)&local_attachmentCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
{
@@ -8658,9 +8887,9 @@
uint32_t opcode_vkCmdClearAttachments = OP_vkCmdClearAttachments;
stream->write(&opcode_vkCmdClearAttachments, sizeof(uint32_t));
stream->write(&packetSize_vkCmdClearAttachments, sizeof(uint32_t));
- uint64_t cgen_var_602;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_602, 1);
- stream->write((uint64_t*)&cgen_var_602, 1 * 8);
+ uint64_t cgen_var_606;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_606, 1);
+ stream->write((uint64_t*)&cgen_var_606, 1 * 8);
stream->write((uint32_t*)&local_attachmentCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
{
@@ -8685,6 +8914,7 @@
uint32_t regionCount,
const VkImageResolve* pRegions)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdResolveImage encode");
mImpl->log("start vkCmdResolveImage");
auto stream = mImpl->stream();
@@ -8723,16 +8953,16 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_603;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_603, 1);
- countingStream->write((uint64_t*)&cgen_var_603, 1 * 8);
- uint64_t cgen_var_604;
- countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_604, 1);
- countingStream->write((uint64_t*)&cgen_var_604, 1 * 8);
+ uint64_t cgen_var_607;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_607, 1);
+ countingStream->write((uint64_t*)&cgen_var_607, 1 * 8);
+ uint64_t cgen_var_608;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_608, 1);
+ countingStream->write((uint64_t*)&cgen_var_608, 1 * 8);
countingStream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
- uint64_t cgen_var_605;
- countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_605, 1);
- countingStream->write((uint64_t*)&cgen_var_605, 1 * 8);
+ uint64_t cgen_var_609;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_609, 1);
+ countingStream->write((uint64_t*)&cgen_var_609, 1 * 8);
countingStream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
countingStream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
@@ -8745,16 +8975,16 @@
uint32_t opcode_vkCmdResolveImage = OP_vkCmdResolveImage;
stream->write(&opcode_vkCmdResolveImage, sizeof(uint32_t));
stream->write(&packetSize_vkCmdResolveImage, sizeof(uint32_t));
- uint64_t cgen_var_606;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_606, 1);
- stream->write((uint64_t*)&cgen_var_606, 1 * 8);
- uint64_t cgen_var_607;
- stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_607, 1);
- stream->write((uint64_t*)&cgen_var_607, 1 * 8);
+ uint64_t cgen_var_610;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_610, 1);
+ stream->write((uint64_t*)&cgen_var_610, 1 * 8);
+ uint64_t cgen_var_611;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_srcImage, &cgen_var_611, 1);
+ stream->write((uint64_t*)&cgen_var_611, 1 * 8);
stream->write((VkImageLayout*)&local_srcImageLayout, sizeof(VkImageLayout));
- uint64_t cgen_var_608;
- stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_608, 1);
- stream->write((uint64_t*)&cgen_var_608, 1 * 8);
+ uint64_t cgen_var_612;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_dstImage, &cgen_var_612, 1);
+ stream->write((uint64_t*)&cgen_var_612, 1 * 8);
stream->write((VkImageLayout*)&local_dstImageLayout, sizeof(VkImageLayout));
stream->write((uint32_t*)&local_regionCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
@@ -8771,6 +9001,7 @@
VkEvent event,
VkPipelineStageFlags stageMask)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdSetEvent encode");
mImpl->log("start vkCmdSetEvent");
auto stream = mImpl->stream();
@@ -8786,51 +9017,6 @@
local_stageMask = stageMask;
countingStream->rewind();
{
- uint64_t cgen_var_609;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_609, 1);
- countingStream->write((uint64_t*)&cgen_var_609, 1 * 8);
- uint64_t cgen_var_610;
- countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_610, 1);
- countingStream->write((uint64_t*)&cgen_var_610, 1 * 8);
- countingStream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
- }
- uint32_t packetSize_vkCmdSetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
- countingStream->rewind();
- uint32_t opcode_vkCmdSetEvent = OP_vkCmdSetEvent;
- stream->write(&opcode_vkCmdSetEvent, sizeof(uint32_t));
- stream->write(&packetSize_vkCmdSetEvent, sizeof(uint32_t));
- uint64_t cgen_var_611;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_611, 1);
- stream->write((uint64_t*)&cgen_var_611, 1 * 8);
- uint64_t cgen_var_612;
- stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_612, 1);
- stream->write((uint64_t*)&cgen_var_612, 1 * 8);
- stream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
- AEMU_SCOPED_TRACE("vkCmdSetEvent readParams");
- AEMU_SCOPED_TRACE("vkCmdSetEvent returnUnmarshal");
- mImpl->log("finish vkCmdSetEvent");;
-}
-
-void VkEncoder::vkCmdResetEvent(
- VkCommandBuffer commandBuffer,
- VkEvent event,
- VkPipelineStageFlags stageMask)
-{
- AEMU_SCOPED_TRACE("vkCmdResetEvent encode");
- mImpl->log("start vkCmdResetEvent");
- auto stream = mImpl->stream();
- auto countingStream = mImpl->countingStream();
- auto resources = mImpl->resources();
- auto pool = mImpl->pool();
- stream->setHandleMapping(resources->unwrapMapping());
- VkCommandBuffer local_commandBuffer;
- VkEvent local_event;
- VkPipelineStageFlags local_stageMask;
- local_commandBuffer = commandBuffer;
- local_event = event;
- local_stageMask = stageMask;
- countingStream->rewind();
- {
uint64_t cgen_var_613;
countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_613, 1);
countingStream->write((uint64_t*)&cgen_var_613, 1 * 8);
@@ -8839,11 +9025,11 @@
countingStream->write((uint64_t*)&cgen_var_614, 1 * 8);
countingStream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
}
- uint32_t packetSize_vkCmdResetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ uint32_t packetSize_vkCmdSetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
- uint32_t opcode_vkCmdResetEvent = OP_vkCmdResetEvent;
- stream->write(&opcode_vkCmdResetEvent, sizeof(uint32_t));
- stream->write(&packetSize_vkCmdResetEvent, sizeof(uint32_t));
+ uint32_t opcode_vkCmdSetEvent = OP_vkCmdSetEvent;
+ stream->write(&opcode_vkCmdSetEvent, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdSetEvent, sizeof(uint32_t));
uint64_t cgen_var_615;
stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_615, 1);
stream->write((uint64_t*)&cgen_var_615, 1 * 8);
@@ -8851,6 +9037,52 @@
stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_616, 1);
stream->write((uint64_t*)&cgen_var_616, 1 * 8);
stream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
+ AEMU_SCOPED_TRACE("vkCmdSetEvent readParams");
+ AEMU_SCOPED_TRACE("vkCmdSetEvent returnUnmarshal");
+ mImpl->log("finish vkCmdSetEvent");;
+}
+
+void VkEncoder::vkCmdResetEvent(
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask)
+{
+ AutoLock encoderLock(mImpl->lock);
+ AEMU_SCOPED_TRACE("vkCmdResetEvent encode");
+ mImpl->log("start vkCmdResetEvent");
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkEvent local_event;
+ VkPipelineStageFlags local_stageMask;
+ local_commandBuffer = commandBuffer;
+ local_event = event;
+ local_stageMask = stageMask;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_617;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_617, 1);
+ countingStream->write((uint64_t*)&cgen_var_617, 1 * 8);
+ uint64_t cgen_var_618;
+ countingStream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_618, 1);
+ countingStream->write((uint64_t*)&cgen_var_618, 1 * 8);
+ countingStream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
+ }
+ uint32_t packetSize_vkCmdResetEvent = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdResetEvent = OP_vkCmdResetEvent;
+ stream->write(&opcode_vkCmdResetEvent, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdResetEvent, sizeof(uint32_t));
+ uint64_t cgen_var_619;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_619, 1);
+ stream->write((uint64_t*)&cgen_var_619, 1 * 8);
+ uint64_t cgen_var_620;
+ stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_620, 1);
+ stream->write((uint64_t*)&cgen_var_620, 1 * 8);
+ stream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
AEMU_SCOPED_TRACE("vkCmdResetEvent readParams");
AEMU_SCOPED_TRACE("vkCmdResetEvent returnUnmarshal");
mImpl->log("finish vkCmdResetEvent");;
@@ -8869,6 +9101,7 @@
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier* pImageMemoryBarriers)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdWaitEvents encode");
mImpl->log("start vkCmdWaitEvents");
auto stream = mImpl->stream();
@@ -8949,16 +9182,16 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_617;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_617, 1);
- countingStream->write((uint64_t*)&cgen_var_617, 1 * 8);
+ uint64_t cgen_var_621;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_621, 1);
+ countingStream->write((uint64_t*)&cgen_var_621, 1 * 8);
countingStream->write((uint32_t*)&local_eventCount, sizeof(uint32_t));
if (((eventCount)))
{
- uint64_t* cgen_var_618;
- countingStream->alloc((void**)&cgen_var_618, ((eventCount)) * 8);
- countingStream->handleMapping()->mapHandles_VkEvent_u64(local_pEvents, cgen_var_618, ((eventCount)));
- countingStream->write((uint64_t*)cgen_var_618, ((eventCount)) * 8);
+ uint64_t* cgen_var_622;
+ countingStream->alloc((void**)&cgen_var_622, ((eventCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkEvent_u64(local_pEvents, cgen_var_622, ((eventCount)));
+ countingStream->write((uint64_t*)cgen_var_622, ((eventCount)) * 8);
}
countingStream->write((VkPipelineStageFlags*)&local_srcStageMask, sizeof(VkPipelineStageFlags));
countingStream->write((VkPipelineStageFlags*)&local_dstStageMask, sizeof(VkPipelineStageFlags));
@@ -8983,16 +9216,16 @@
uint32_t opcode_vkCmdWaitEvents = OP_vkCmdWaitEvents;
stream->write(&opcode_vkCmdWaitEvents, sizeof(uint32_t));
stream->write(&packetSize_vkCmdWaitEvents, sizeof(uint32_t));
- uint64_t cgen_var_619;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_619, 1);
- stream->write((uint64_t*)&cgen_var_619, 1 * 8);
+ uint64_t cgen_var_623;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_623, 1);
+ stream->write((uint64_t*)&cgen_var_623, 1 * 8);
stream->write((uint32_t*)&local_eventCount, sizeof(uint32_t));
if (((eventCount)))
{
- uint64_t* cgen_var_620;
- stream->alloc((void**)&cgen_var_620, ((eventCount)) * 8);
- stream->handleMapping()->mapHandles_VkEvent_u64(local_pEvents, cgen_var_620, ((eventCount)));
- stream->write((uint64_t*)cgen_var_620, ((eventCount)) * 8);
+ uint64_t* cgen_var_624;
+ stream->alloc((void**)&cgen_var_624, ((eventCount)) * 8);
+ stream->handleMapping()->mapHandles_VkEvent_u64(local_pEvents, cgen_var_624, ((eventCount)));
+ stream->write((uint64_t*)cgen_var_624, ((eventCount)) * 8);
}
stream->write((VkPipelineStageFlags*)&local_srcStageMask, sizeof(VkPipelineStageFlags));
stream->write((VkPipelineStageFlags*)&local_dstStageMask, sizeof(VkPipelineStageFlags));
@@ -9028,6 +9261,7 @@
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier* pImageMemoryBarriers)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdPipelineBarrier encode");
mImpl->log("start vkCmdPipelineBarrier");
auto stream = mImpl->stream();
@@ -9102,9 +9336,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_621;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_621, 1);
- countingStream->write((uint64_t*)&cgen_var_621, 1 * 8);
+ uint64_t cgen_var_625;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_625, 1);
+ countingStream->write((uint64_t*)&cgen_var_625, 1 * 8);
countingStream->write((VkPipelineStageFlags*)&local_srcStageMask, sizeof(VkPipelineStageFlags));
countingStream->write((VkPipelineStageFlags*)&local_dstStageMask, sizeof(VkPipelineStageFlags));
countingStream->write((VkDependencyFlags*)&local_dependencyFlags, sizeof(VkDependencyFlags));
@@ -9129,9 +9363,9 @@
uint32_t opcode_vkCmdPipelineBarrier = OP_vkCmdPipelineBarrier;
stream->write(&opcode_vkCmdPipelineBarrier, sizeof(uint32_t));
stream->write(&packetSize_vkCmdPipelineBarrier, sizeof(uint32_t));
- uint64_t cgen_var_622;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_622, 1);
- stream->write((uint64_t*)&cgen_var_622, 1 * 8);
+ uint64_t cgen_var_626;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_626, 1);
+ stream->write((uint64_t*)&cgen_var_626, 1 * 8);
stream->write((VkPipelineStageFlags*)&local_srcStageMask, sizeof(VkPipelineStageFlags));
stream->write((VkPipelineStageFlags*)&local_dstStageMask, sizeof(VkPipelineStageFlags));
stream->write((VkDependencyFlags*)&local_dependencyFlags, sizeof(VkDependencyFlags));
@@ -9161,6 +9395,7 @@
uint32_t query,
VkQueryControlFlags flags)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdBeginQuery encode");
mImpl->log("start vkCmdBeginQuery");
auto stream = mImpl->stream();
@@ -9178,12 +9413,12 @@
local_flags = flags;
countingStream->rewind();
{
- uint64_t cgen_var_623;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_623, 1);
- countingStream->write((uint64_t*)&cgen_var_623, 1 * 8);
- uint64_t cgen_var_624;
- countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_624, 1);
- countingStream->write((uint64_t*)&cgen_var_624, 1 * 8);
+ uint64_t cgen_var_627;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_627, 1);
+ countingStream->write((uint64_t*)&cgen_var_627, 1 * 8);
+ uint64_t cgen_var_628;
+ countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_628, 1);
+ countingStream->write((uint64_t*)&cgen_var_628, 1 * 8);
countingStream->write((uint32_t*)&local_query, sizeof(uint32_t));
countingStream->write((VkQueryControlFlags*)&local_flags, sizeof(VkQueryControlFlags));
}
@@ -9192,12 +9427,12 @@
uint32_t opcode_vkCmdBeginQuery = OP_vkCmdBeginQuery;
stream->write(&opcode_vkCmdBeginQuery, sizeof(uint32_t));
stream->write(&packetSize_vkCmdBeginQuery, sizeof(uint32_t));
- uint64_t cgen_var_625;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_625, 1);
- stream->write((uint64_t*)&cgen_var_625, 1 * 8);
- uint64_t cgen_var_626;
- stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_626, 1);
- stream->write((uint64_t*)&cgen_var_626, 1 * 8);
+ uint64_t cgen_var_629;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_629, 1);
+ stream->write((uint64_t*)&cgen_var_629, 1 * 8);
+ uint64_t cgen_var_630;
+ stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_630, 1);
+ stream->write((uint64_t*)&cgen_var_630, 1 * 8);
stream->write((uint32_t*)&local_query, sizeof(uint32_t));
stream->write((VkQueryControlFlags*)&local_flags, sizeof(VkQueryControlFlags));
AEMU_SCOPED_TRACE("vkCmdBeginQuery readParams");
@@ -9210,6 +9445,7 @@
VkQueryPool queryPool,
uint32_t query)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdEndQuery encode");
mImpl->log("start vkCmdEndQuery");
auto stream = mImpl->stream();
@@ -9225,12 +9461,12 @@
local_query = query;
countingStream->rewind();
{
- uint64_t cgen_var_627;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_627, 1);
- countingStream->write((uint64_t*)&cgen_var_627, 1 * 8);
- uint64_t cgen_var_628;
- countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_628, 1);
- countingStream->write((uint64_t*)&cgen_var_628, 1 * 8);
+ uint64_t cgen_var_631;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_631, 1);
+ countingStream->write((uint64_t*)&cgen_var_631, 1 * 8);
+ uint64_t cgen_var_632;
+ countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_632, 1);
+ countingStream->write((uint64_t*)&cgen_var_632, 1 * 8);
countingStream->write((uint32_t*)&local_query, sizeof(uint32_t));
}
uint32_t packetSize_vkCmdEndQuery = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -9238,12 +9474,12 @@
uint32_t opcode_vkCmdEndQuery = OP_vkCmdEndQuery;
stream->write(&opcode_vkCmdEndQuery, sizeof(uint32_t));
stream->write(&packetSize_vkCmdEndQuery, sizeof(uint32_t));
- uint64_t cgen_var_629;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_629, 1);
- stream->write((uint64_t*)&cgen_var_629, 1 * 8);
- uint64_t cgen_var_630;
- stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_630, 1);
- stream->write((uint64_t*)&cgen_var_630, 1 * 8);
+ uint64_t cgen_var_633;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_633, 1);
+ stream->write((uint64_t*)&cgen_var_633, 1 * 8);
+ uint64_t cgen_var_634;
+ stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_634, 1);
+ stream->write((uint64_t*)&cgen_var_634, 1 * 8);
stream->write((uint32_t*)&local_query, sizeof(uint32_t));
AEMU_SCOPED_TRACE("vkCmdEndQuery readParams");
AEMU_SCOPED_TRACE("vkCmdEndQuery returnUnmarshal");
@@ -9256,6 +9492,7 @@
uint32_t firstQuery,
uint32_t queryCount)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdResetQueryPool encode");
mImpl->log("start vkCmdResetQueryPool");
auto stream = mImpl->stream();
@@ -9273,12 +9510,12 @@
local_queryCount = queryCount;
countingStream->rewind();
{
- uint64_t cgen_var_631;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_631, 1);
- countingStream->write((uint64_t*)&cgen_var_631, 1 * 8);
- uint64_t cgen_var_632;
- countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_632, 1);
- countingStream->write((uint64_t*)&cgen_var_632, 1 * 8);
+ uint64_t cgen_var_635;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_635, 1);
+ countingStream->write((uint64_t*)&cgen_var_635, 1 * 8);
+ uint64_t cgen_var_636;
+ countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_636, 1);
+ countingStream->write((uint64_t*)&cgen_var_636, 1 * 8);
countingStream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
}
@@ -9287,12 +9524,12 @@
uint32_t opcode_vkCmdResetQueryPool = OP_vkCmdResetQueryPool;
stream->write(&opcode_vkCmdResetQueryPool, sizeof(uint32_t));
stream->write(&packetSize_vkCmdResetQueryPool, sizeof(uint32_t));
- uint64_t cgen_var_633;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_633, 1);
- stream->write((uint64_t*)&cgen_var_633, 1 * 8);
- uint64_t cgen_var_634;
- stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_634, 1);
- stream->write((uint64_t*)&cgen_var_634, 1 * 8);
+ uint64_t cgen_var_637;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_637, 1);
+ stream->write((uint64_t*)&cgen_var_637, 1 * 8);
+ uint64_t cgen_var_638;
+ stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_638, 1);
+ stream->write((uint64_t*)&cgen_var_638, 1 * 8);
stream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
stream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
AEMU_SCOPED_TRACE("vkCmdResetQueryPool readParams");
@@ -9306,6 +9543,7 @@
VkQueryPool queryPool,
uint32_t query)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdWriteTimestamp encode");
mImpl->log("start vkCmdWriteTimestamp");
auto stream = mImpl->stream();
@@ -9323,13 +9561,13 @@
local_query = query;
countingStream->rewind();
{
- uint64_t cgen_var_635;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_635, 1);
- countingStream->write((uint64_t*)&cgen_var_635, 1 * 8);
+ uint64_t cgen_var_639;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_639, 1);
+ countingStream->write((uint64_t*)&cgen_var_639, 1 * 8);
countingStream->write((VkPipelineStageFlagBits*)&local_pipelineStage, sizeof(VkPipelineStageFlagBits));
- uint64_t cgen_var_636;
- countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_636, 1);
- countingStream->write((uint64_t*)&cgen_var_636, 1 * 8);
+ uint64_t cgen_var_640;
+ countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_640, 1);
+ countingStream->write((uint64_t*)&cgen_var_640, 1 * 8);
countingStream->write((uint32_t*)&local_query, sizeof(uint32_t));
}
uint32_t packetSize_vkCmdWriteTimestamp = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -9337,13 +9575,13 @@
uint32_t opcode_vkCmdWriteTimestamp = OP_vkCmdWriteTimestamp;
stream->write(&opcode_vkCmdWriteTimestamp, sizeof(uint32_t));
stream->write(&packetSize_vkCmdWriteTimestamp, sizeof(uint32_t));
- uint64_t cgen_var_637;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_637, 1);
- stream->write((uint64_t*)&cgen_var_637, 1 * 8);
+ uint64_t cgen_var_641;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_641, 1);
+ stream->write((uint64_t*)&cgen_var_641, 1 * 8);
stream->write((VkPipelineStageFlagBits*)&local_pipelineStage, sizeof(VkPipelineStageFlagBits));
- uint64_t cgen_var_638;
- stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_638, 1);
- stream->write((uint64_t*)&cgen_var_638, 1 * 8);
+ uint64_t cgen_var_642;
+ stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_642, 1);
+ stream->write((uint64_t*)&cgen_var_642, 1 * 8);
stream->write((uint32_t*)&local_query, sizeof(uint32_t));
AEMU_SCOPED_TRACE("vkCmdWriteTimestamp readParams");
AEMU_SCOPED_TRACE("vkCmdWriteTimestamp returnUnmarshal");
@@ -9360,6 +9598,7 @@
VkDeviceSize stride,
VkQueryResultFlags flags)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults encode");
mImpl->log("start vkCmdCopyQueryPoolResults");
auto stream = mImpl->stream();
@@ -9385,17 +9624,17 @@
local_flags = flags;
countingStream->rewind();
{
- uint64_t cgen_var_639;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_639, 1);
- countingStream->write((uint64_t*)&cgen_var_639, 1 * 8);
- uint64_t cgen_var_640;
- countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_640, 1);
- countingStream->write((uint64_t*)&cgen_var_640, 1 * 8);
+ uint64_t cgen_var_643;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_643, 1);
+ countingStream->write((uint64_t*)&cgen_var_643, 1 * 8);
+ uint64_t cgen_var_644;
+ countingStream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_644, 1);
+ countingStream->write((uint64_t*)&cgen_var_644, 1 * 8);
countingStream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
- uint64_t cgen_var_641;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_641, 1);
- countingStream->write((uint64_t*)&cgen_var_641, 1 * 8);
+ uint64_t cgen_var_645;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_645, 1);
+ countingStream->write((uint64_t*)&cgen_var_645, 1 * 8);
countingStream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
countingStream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize));
countingStream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
@@ -9405,17 +9644,17 @@
uint32_t opcode_vkCmdCopyQueryPoolResults = OP_vkCmdCopyQueryPoolResults;
stream->write(&opcode_vkCmdCopyQueryPoolResults, sizeof(uint32_t));
stream->write(&packetSize_vkCmdCopyQueryPoolResults, sizeof(uint32_t));
- uint64_t cgen_var_642;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_642, 1);
- stream->write((uint64_t*)&cgen_var_642, 1 * 8);
- uint64_t cgen_var_643;
- stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_643, 1);
- stream->write((uint64_t*)&cgen_var_643, 1 * 8);
+ uint64_t cgen_var_646;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_646, 1);
+ stream->write((uint64_t*)&cgen_var_646, 1 * 8);
+ uint64_t cgen_var_647;
+ stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_647, 1);
+ stream->write((uint64_t*)&cgen_var_647, 1 * 8);
stream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t));
stream->write((uint32_t*)&local_queryCount, sizeof(uint32_t));
- uint64_t cgen_var_644;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_644, 1);
- stream->write((uint64_t*)&cgen_var_644, 1 * 8);
+ uint64_t cgen_var_648;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_648, 1);
+ stream->write((uint64_t*)&cgen_var_648, 1 * 8);
stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
stream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize));
stream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
@@ -9432,6 +9671,7 @@
uint32_t size,
const void* pValues)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdPushConstants encode");
mImpl->log("start vkCmdPushConstants");
auto stream = mImpl->stream();
@@ -9457,12 +9697,12 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_645;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_645, 1);
- countingStream->write((uint64_t*)&cgen_var_645, 1 * 8);
- uint64_t cgen_var_646;
- countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_646, 1);
- countingStream->write((uint64_t*)&cgen_var_646, 1 * 8);
+ uint64_t cgen_var_649;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_649, 1);
+ countingStream->write((uint64_t*)&cgen_var_649, 1 * 8);
+ uint64_t cgen_var_650;
+ countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_650, 1);
+ countingStream->write((uint64_t*)&cgen_var_650, 1 * 8);
countingStream->write((VkShaderStageFlags*)&local_stageFlags, sizeof(VkShaderStageFlags));
countingStream->write((uint32_t*)&local_offset, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_size, sizeof(uint32_t));
@@ -9473,12 +9713,12 @@
uint32_t opcode_vkCmdPushConstants = OP_vkCmdPushConstants;
stream->write(&opcode_vkCmdPushConstants, sizeof(uint32_t));
stream->write(&packetSize_vkCmdPushConstants, sizeof(uint32_t));
- uint64_t cgen_var_647;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_647, 1);
- stream->write((uint64_t*)&cgen_var_647, 1 * 8);
- uint64_t cgen_var_648;
- stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_648, 1);
- stream->write((uint64_t*)&cgen_var_648, 1 * 8);
+ uint64_t cgen_var_651;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_651, 1);
+ stream->write((uint64_t*)&cgen_var_651, 1 * 8);
+ uint64_t cgen_var_652;
+ stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_652, 1);
+ stream->write((uint64_t*)&cgen_var_652, 1 * 8);
stream->write((VkShaderStageFlags*)&local_stageFlags, sizeof(VkShaderStageFlags));
stream->write((uint32_t*)&local_offset, sizeof(uint32_t));
stream->write((uint32_t*)&local_size, sizeof(uint32_t));
@@ -9493,6 +9733,7 @@
const VkRenderPassBeginInfo* pRenderPassBegin,
VkSubpassContents contents)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdBeginRenderPass encode");
mImpl->log("start vkCmdBeginRenderPass");
auto stream = mImpl->stream();
@@ -9517,9 +9758,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_649;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_649, 1);
- countingStream->write((uint64_t*)&cgen_var_649, 1 * 8);
+ uint64_t cgen_var_653;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_653, 1);
+ countingStream->write((uint64_t*)&cgen_var_653, 1 * 8);
marshal_VkRenderPassBeginInfo(countingStream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
countingStream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
}
@@ -9528,9 +9769,9 @@
uint32_t opcode_vkCmdBeginRenderPass = OP_vkCmdBeginRenderPass;
stream->write(&opcode_vkCmdBeginRenderPass, sizeof(uint32_t));
stream->write(&packetSize_vkCmdBeginRenderPass, sizeof(uint32_t));
- uint64_t cgen_var_650;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_650, 1);
- stream->write((uint64_t*)&cgen_var_650, 1 * 8);
+ uint64_t cgen_var_654;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_654, 1);
+ stream->write((uint64_t*)&cgen_var_654, 1 * 8);
marshal_VkRenderPassBeginInfo(stream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
stream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
AEMU_SCOPED_TRACE("vkCmdBeginRenderPass readParams");
@@ -9542,6 +9783,7 @@
VkCommandBuffer commandBuffer,
VkSubpassContents contents)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdNextSubpass encode");
mImpl->log("start vkCmdNextSubpass");
auto stream = mImpl->stream();
@@ -9555,9 +9797,9 @@
local_contents = contents;
countingStream->rewind();
{
- uint64_t cgen_var_651;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_651, 1);
- countingStream->write((uint64_t*)&cgen_var_651, 1 * 8);
+ uint64_t cgen_var_655;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_655, 1);
+ countingStream->write((uint64_t*)&cgen_var_655, 1 * 8);
countingStream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
}
uint32_t packetSize_vkCmdNextSubpass = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -9565,9 +9807,9 @@
uint32_t opcode_vkCmdNextSubpass = OP_vkCmdNextSubpass;
stream->write(&opcode_vkCmdNextSubpass, sizeof(uint32_t));
stream->write(&packetSize_vkCmdNextSubpass, sizeof(uint32_t));
- uint64_t cgen_var_652;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_652, 1);
- stream->write((uint64_t*)&cgen_var_652, 1 * 8);
+ uint64_t cgen_var_656;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_656, 1);
+ stream->write((uint64_t*)&cgen_var_656, 1 * 8);
stream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
AEMU_SCOPED_TRACE("vkCmdNextSubpass readParams");
AEMU_SCOPED_TRACE("vkCmdNextSubpass returnUnmarshal");
@@ -9577,6 +9819,7 @@
void VkEncoder::vkCmdEndRenderPass(
VkCommandBuffer commandBuffer)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdEndRenderPass encode");
mImpl->log("start vkCmdEndRenderPass");
auto stream = mImpl->stream();
@@ -9588,18 +9831,18 @@
local_commandBuffer = commandBuffer;
countingStream->rewind();
{
- uint64_t cgen_var_653;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_653, 1);
- countingStream->write((uint64_t*)&cgen_var_653, 1 * 8);
+ uint64_t cgen_var_657;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_657, 1);
+ countingStream->write((uint64_t*)&cgen_var_657, 1 * 8);
}
uint32_t packetSize_vkCmdEndRenderPass = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCmdEndRenderPass = OP_vkCmdEndRenderPass;
stream->write(&opcode_vkCmdEndRenderPass, sizeof(uint32_t));
stream->write(&packetSize_vkCmdEndRenderPass, sizeof(uint32_t));
- uint64_t cgen_var_654;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_654, 1);
- stream->write((uint64_t*)&cgen_var_654, 1 * 8);
+ uint64_t cgen_var_658;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_658, 1);
+ stream->write((uint64_t*)&cgen_var_658, 1 * 8);
AEMU_SCOPED_TRACE("vkCmdEndRenderPass readParams");
AEMU_SCOPED_TRACE("vkCmdEndRenderPass returnUnmarshal");
mImpl->log("finish vkCmdEndRenderPass");;
@@ -9610,6 +9853,7 @@
uint32_t commandBufferCount,
const VkCommandBuffer* pCommandBuffers)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdExecuteCommands encode");
mImpl->log("start vkCmdExecuteCommands");
auto stream = mImpl->stream();
@@ -9629,16 +9873,16 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_655;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_655, 1);
- countingStream->write((uint64_t*)&cgen_var_655, 1 * 8);
+ uint64_t cgen_var_659;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_659, 1);
+ countingStream->write((uint64_t*)&cgen_var_659, 1 * 8);
countingStream->write((uint32_t*)&local_commandBufferCount, sizeof(uint32_t));
if (((commandBufferCount)))
{
- uint64_t* cgen_var_656;
- countingStream->alloc((void**)&cgen_var_656, ((commandBufferCount)) * 8);
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_656, ((commandBufferCount)));
- countingStream->write((uint64_t*)cgen_var_656, ((commandBufferCount)) * 8);
+ uint64_t* cgen_var_660;
+ countingStream->alloc((void**)&cgen_var_660, ((commandBufferCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_660, ((commandBufferCount)));
+ countingStream->write((uint64_t*)cgen_var_660, ((commandBufferCount)) * 8);
}
}
uint32_t packetSize_vkCmdExecuteCommands = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -9646,16 +9890,16 @@
uint32_t opcode_vkCmdExecuteCommands = OP_vkCmdExecuteCommands;
stream->write(&opcode_vkCmdExecuteCommands, sizeof(uint32_t));
stream->write(&packetSize_vkCmdExecuteCommands, sizeof(uint32_t));
- uint64_t cgen_var_657;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_657, 1);
- stream->write((uint64_t*)&cgen_var_657, 1 * 8);
+ uint64_t cgen_var_661;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_661, 1);
+ stream->write((uint64_t*)&cgen_var_661, 1 * 8);
stream->write((uint32_t*)&local_commandBufferCount, sizeof(uint32_t));
if (((commandBufferCount)))
{
- uint64_t* cgen_var_658;
- stream->alloc((void**)&cgen_var_658, ((commandBufferCount)) * 8);
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_658, ((commandBufferCount)));
- stream->write((uint64_t*)cgen_var_658, ((commandBufferCount)) * 8);
+ uint64_t* cgen_var_662;
+ stream->alloc((void**)&cgen_var_662, ((commandBufferCount)) * 8);
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_662, ((commandBufferCount)));
+ stream->write((uint64_t*)cgen_var_662, ((commandBufferCount)) * 8);
}
AEMU_SCOPED_TRACE("vkCmdExecuteCommands readParams");
AEMU_SCOPED_TRACE("vkCmdExecuteCommands returnUnmarshal");
@@ -9667,6 +9911,7 @@
VkResult VkEncoder::vkEnumerateInstanceVersion(
uint32_t* pApiVersion)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion encode");
mImpl->log("start vkEnumerateInstanceVersion");
auto stream = mImpl->stream();
@@ -9701,6 +9946,7 @@
uint32_t bindInfoCount,
const VkBindBufferMemoryInfo* pBindInfos)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkBindBufferMemory2 encode");
mImpl->log("start vkBindBufferMemory2");
auto stream = mImpl->stream();
@@ -9731,9 +9977,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_659;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_659, 1);
- countingStream->write((uint64_t*)&cgen_var_659, 1 * 8);
+ uint64_t cgen_var_663;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_663, 1);
+ countingStream->write((uint64_t*)&cgen_var_663, 1 * 8);
countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
@@ -9745,9 +9991,9 @@
uint32_t opcode_vkBindBufferMemory2 = OP_vkBindBufferMemory2;
stream->write(&opcode_vkBindBufferMemory2, sizeof(uint32_t));
stream->write(&packetSize_vkBindBufferMemory2, sizeof(uint32_t));
- uint64_t cgen_var_660;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_660, 1);
- stream->write((uint64_t*)&cgen_var_660, 1 * 8);
+ uint64_t cgen_var_664;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_664, 1);
+ stream->write((uint64_t*)&cgen_var_664, 1 * 8);
stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
@@ -9769,6 +10015,7 @@
uint32_t bindInfoCount,
const VkBindImageMemoryInfo* pBindInfos)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkBindImageMemory2 encode");
mImpl->log("start vkBindImageMemory2");
auto stream = mImpl->stream();
@@ -9799,9 +10046,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_661;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_661, 1);
- countingStream->write((uint64_t*)&cgen_var_661, 1 * 8);
+ uint64_t cgen_var_665;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_665, 1);
+ countingStream->write((uint64_t*)&cgen_var_665, 1 * 8);
countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
@@ -9813,9 +10060,9 @@
uint32_t opcode_vkBindImageMemory2 = OP_vkBindImageMemory2;
stream->write(&opcode_vkBindImageMemory2, sizeof(uint32_t));
stream->write(&packetSize_vkBindImageMemory2, sizeof(uint32_t));
- uint64_t cgen_var_662;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_662, 1);
- stream->write((uint64_t*)&cgen_var_662, 1 * 8);
+ uint64_t cgen_var_666;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_666, 1);
+ stream->write((uint64_t*)&cgen_var_666, 1 * 8);
stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
@@ -9839,6 +10086,7 @@
uint32_t remoteDeviceIndex,
VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures encode");
mImpl->log("start vkGetDeviceGroupPeerMemoryFeatures");
auto stream = mImpl->stream();
@@ -9856,9 +10104,9 @@
local_remoteDeviceIndex = remoteDeviceIndex;
countingStream->rewind();
{
- uint64_t cgen_var_663;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_663, 1);
- countingStream->write((uint64_t*)&cgen_var_663, 1 * 8);
+ uint64_t cgen_var_667;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_667, 1);
+ countingStream->write((uint64_t*)&cgen_var_667, 1 * 8);
countingStream->write((uint32_t*)&local_heapIndex, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
@@ -9869,9 +10117,9 @@
uint32_t opcode_vkGetDeviceGroupPeerMemoryFeatures = OP_vkGetDeviceGroupPeerMemoryFeatures;
stream->write(&opcode_vkGetDeviceGroupPeerMemoryFeatures, sizeof(uint32_t));
stream->write(&packetSize_vkGetDeviceGroupPeerMemoryFeatures, sizeof(uint32_t));
- uint64_t cgen_var_664;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_664, 1);
- stream->write((uint64_t*)&cgen_var_664, 1 * 8);
+ uint64_t cgen_var_668;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_668, 1);
+ stream->write((uint64_t*)&cgen_var_668, 1 * 8);
stream->write((uint32_t*)&local_heapIndex, sizeof(uint32_t));
stream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t));
stream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
@@ -9886,6 +10134,7 @@
VkCommandBuffer commandBuffer,
uint32_t deviceMask)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdSetDeviceMask encode");
mImpl->log("start vkCmdSetDeviceMask");
auto stream = mImpl->stream();
@@ -9899,9 +10148,9 @@
local_deviceMask = deviceMask;
countingStream->rewind();
{
- uint64_t cgen_var_665;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_665, 1);
- countingStream->write((uint64_t*)&cgen_var_665, 1 * 8);
+ uint64_t cgen_var_669;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_669, 1);
+ countingStream->write((uint64_t*)&cgen_var_669, 1 * 8);
countingStream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
}
uint32_t packetSize_vkCmdSetDeviceMask = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -9909,9 +10158,9 @@
uint32_t opcode_vkCmdSetDeviceMask = OP_vkCmdSetDeviceMask;
stream->write(&opcode_vkCmdSetDeviceMask, sizeof(uint32_t));
stream->write(&packetSize_vkCmdSetDeviceMask, sizeof(uint32_t));
- uint64_t cgen_var_666;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_666, 1);
- stream->write((uint64_t*)&cgen_var_666, 1 * 8);
+ uint64_t cgen_var_670;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_670, 1);
+ stream->write((uint64_t*)&cgen_var_670, 1 * 8);
stream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
AEMU_SCOPED_TRACE("vkCmdSetDeviceMask readParams");
AEMU_SCOPED_TRACE("vkCmdSetDeviceMask returnUnmarshal");
@@ -9927,6 +10176,7 @@
uint32_t groupCountY,
uint32_t groupCountZ)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdDispatchBase encode");
mImpl->log("start vkCmdDispatchBase");
auto stream = mImpl->stream();
@@ -9950,9 +10200,9 @@
local_groupCountZ = groupCountZ;
countingStream->rewind();
{
- uint64_t cgen_var_667;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_667, 1);
- countingStream->write((uint64_t*)&cgen_var_667, 1 * 8);
+ uint64_t cgen_var_671;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_671, 1);
+ countingStream->write((uint64_t*)&cgen_var_671, 1 * 8);
countingStream->write((uint32_t*)&local_baseGroupX, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_baseGroupY, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_baseGroupZ, sizeof(uint32_t));
@@ -9965,9 +10215,9 @@
uint32_t opcode_vkCmdDispatchBase = OP_vkCmdDispatchBase;
stream->write(&opcode_vkCmdDispatchBase, sizeof(uint32_t));
stream->write(&packetSize_vkCmdDispatchBase, sizeof(uint32_t));
- uint64_t cgen_var_668;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_668, 1);
- stream->write((uint64_t*)&cgen_var_668, 1 * 8);
+ uint64_t cgen_var_672;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_672, 1);
+ stream->write((uint64_t*)&cgen_var_672, 1 * 8);
stream->write((uint32_t*)&local_baseGroupX, sizeof(uint32_t));
stream->write((uint32_t*)&local_baseGroupY, sizeof(uint32_t));
stream->write((uint32_t*)&local_baseGroupZ, sizeof(uint32_t));
@@ -9984,6 +10234,7 @@
uint32_t* pPhysicalDeviceGroupCount,
VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroups encode");
mImpl->log("start vkEnumeratePhysicalDeviceGroups");
auto stream = mImpl->stream();
@@ -9995,19 +10246,19 @@
local_instance = instance;
countingStream->rewind();
{
- uint64_t cgen_var_669;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_669, 1);
- countingStream->write((uint64_t*)&cgen_var_669, 1 * 8);
+ uint64_t cgen_var_673;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_673, 1);
+ countingStream->write((uint64_t*)&cgen_var_673, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_670 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
- countingStream->putBe64(cgen_var_670);
+ uint64_t cgen_var_674 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
+ countingStream->putBe64(cgen_var_674);
if (pPhysicalDeviceGroupCount)
{
countingStream->write((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_671 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
- countingStream->putBe64(cgen_var_671);
+ uint64_t cgen_var_675 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
+ countingStream->putBe64(cgen_var_675);
if (pPhysicalDeviceGroupProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
@@ -10021,19 +10272,19 @@
uint32_t opcode_vkEnumeratePhysicalDeviceGroups = OP_vkEnumeratePhysicalDeviceGroups;
stream->write(&opcode_vkEnumeratePhysicalDeviceGroups, sizeof(uint32_t));
stream->write(&packetSize_vkEnumeratePhysicalDeviceGroups, sizeof(uint32_t));
- uint64_t cgen_var_672;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_672, 1);
- stream->write((uint64_t*)&cgen_var_672, 1 * 8);
+ uint64_t cgen_var_676;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_676, 1);
+ stream->write((uint64_t*)&cgen_var_676, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_673 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
- stream->putBe64(cgen_var_673);
+ uint64_t cgen_var_677 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
+ stream->putBe64(cgen_var_677);
if (pPhysicalDeviceGroupCount)
{
stream->write((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_674 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
- stream->putBe64(cgen_var_674);
+ uint64_t cgen_var_678 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
+ stream->putBe64(cgen_var_678);
if (pPhysicalDeviceGroupProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
@@ -10089,6 +10340,7 @@
const VkImageMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2 encode");
mImpl->log("start vkGetImageMemoryRequirements2");
auto stream = mImpl->stream();
@@ -10111,9 +10363,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_677;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_677, 1);
- countingStream->write((uint64_t*)&cgen_var_677, 1 * 8);
+ uint64_t cgen_var_681;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_681, 1);
+ countingStream->write((uint64_t*)&cgen_var_681, 1 * 8);
marshal_VkImageMemoryRequirementsInfo2(countingStream, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
marshal_VkMemoryRequirements2(countingStream, (VkMemoryRequirements2*)(pMemoryRequirements));
}
@@ -10122,9 +10374,9 @@
uint32_t opcode_vkGetImageMemoryRequirements2 = OP_vkGetImageMemoryRequirements2;
stream->write(&opcode_vkGetImageMemoryRequirements2, sizeof(uint32_t));
stream->write(&packetSize_vkGetImageMemoryRequirements2, sizeof(uint32_t));
- uint64_t cgen_var_678;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_678, 1);
- stream->write((uint64_t*)&cgen_var_678, 1 * 8);
+ uint64_t cgen_var_682;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_682, 1);
+ stream->write((uint64_t*)&cgen_var_682, 1 * 8);
marshal_VkImageMemoryRequirementsInfo2(stream, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2 readParams");
@@ -10142,6 +10394,7 @@
const VkBufferMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2 encode");
mImpl->log("start vkGetBufferMemoryRequirements2");
auto stream = mImpl->stream();
@@ -10164,9 +10417,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_679;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_679, 1);
- countingStream->write((uint64_t*)&cgen_var_679, 1 * 8);
+ uint64_t cgen_var_683;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_683, 1);
+ countingStream->write((uint64_t*)&cgen_var_683, 1 * 8);
marshal_VkBufferMemoryRequirementsInfo2(countingStream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
marshal_VkMemoryRequirements2(countingStream, (VkMemoryRequirements2*)(pMemoryRequirements));
}
@@ -10175,9 +10428,9 @@
uint32_t opcode_vkGetBufferMemoryRequirements2 = OP_vkGetBufferMemoryRequirements2;
stream->write(&opcode_vkGetBufferMemoryRequirements2, sizeof(uint32_t));
stream->write(&packetSize_vkGetBufferMemoryRequirements2, sizeof(uint32_t));
- uint64_t cgen_var_680;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_680, 1);
- stream->write((uint64_t*)&cgen_var_680, 1 * 8);
+ uint64_t cgen_var_684;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_684, 1);
+ stream->write((uint64_t*)&cgen_var_684, 1 * 8);
marshal_VkBufferMemoryRequirementsInfo2(stream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2 readParams");
@@ -10196,6 +10449,7 @@
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2 encode");
mImpl->log("start vkGetImageSparseMemoryRequirements2");
auto stream = mImpl->stream();
@@ -10218,20 +10472,20 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_681;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_681, 1);
- countingStream->write((uint64_t*)&cgen_var_681, 1 * 8);
+ uint64_t cgen_var_685;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_685, 1);
+ countingStream->write((uint64_t*)&cgen_var_685, 1 * 8);
marshal_VkImageSparseMemoryRequirementsInfo2(countingStream, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_682 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
- countingStream->putBe64(cgen_var_682);
+ uint64_t cgen_var_686 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+ countingStream->putBe64(cgen_var_686);
if (pSparseMemoryRequirementCount)
{
countingStream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_683 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
- countingStream->putBe64(cgen_var_683);
+ uint64_t cgen_var_687 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+ countingStream->putBe64(cgen_var_687);
if (pSparseMemoryRequirements)
{
for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
@@ -10245,20 +10499,20 @@
uint32_t opcode_vkGetImageSparseMemoryRequirements2 = OP_vkGetImageSparseMemoryRequirements2;
stream->write(&opcode_vkGetImageSparseMemoryRequirements2, sizeof(uint32_t));
stream->write(&packetSize_vkGetImageSparseMemoryRequirements2, sizeof(uint32_t));
- uint64_t cgen_var_684;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_684, 1);
- stream->write((uint64_t*)&cgen_var_684, 1 * 8);
+ uint64_t cgen_var_688;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_688, 1);
+ stream->write((uint64_t*)&cgen_var_688, 1 * 8);
marshal_VkImageSparseMemoryRequirementsInfo2(stream, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_685 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
- stream->putBe64(cgen_var_685);
+ uint64_t cgen_var_689 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+ stream->putBe64(cgen_var_689);
if (pSparseMemoryRequirementCount)
{
stream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_686 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
- stream->putBe64(cgen_var_686);
+ uint64_t cgen_var_690 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+ stream->putBe64(cgen_var_690);
if (pSparseMemoryRequirements)
{
for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
@@ -10307,6 +10561,7 @@
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures2* pFeatures)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2 encode");
mImpl->log("start vkGetPhysicalDeviceFeatures2");
auto stream = mImpl->stream();
@@ -10318,9 +10573,9 @@
local_physicalDevice = physicalDevice;
countingStream->rewind();
{
- uint64_t cgen_var_689;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_689, 1);
- countingStream->write((uint64_t*)&cgen_var_689, 1 * 8);
+ uint64_t cgen_var_693;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_693, 1);
+ countingStream->write((uint64_t*)&cgen_var_693, 1 * 8);
marshal_VkPhysicalDeviceFeatures2(countingStream, (VkPhysicalDeviceFeatures2*)(pFeatures));
}
uint32_t packetSize_vkGetPhysicalDeviceFeatures2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -10328,9 +10583,9 @@
uint32_t opcode_vkGetPhysicalDeviceFeatures2 = OP_vkGetPhysicalDeviceFeatures2;
stream->write(&opcode_vkGetPhysicalDeviceFeatures2, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceFeatures2, sizeof(uint32_t));
- uint64_t cgen_var_690;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_690, 1);
- stream->write((uint64_t*)&cgen_var_690, 1 * 8);
+ uint64_t cgen_var_694;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_694, 1);
+ stream->write((uint64_t*)&cgen_var_694, 1 * 8);
marshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2 readParams");
unmarshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
@@ -10346,6 +10601,7 @@
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties2* pProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2 encode");
mImpl->log("start vkGetPhysicalDeviceProperties2");
auto stream = mImpl->stream();
@@ -10357,9 +10613,9 @@
local_physicalDevice = physicalDevice;
countingStream->rewind();
{
- uint64_t cgen_var_691;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_691, 1);
- countingStream->write((uint64_t*)&cgen_var_691, 1 * 8);
+ uint64_t cgen_var_695;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_695, 1);
+ countingStream->write((uint64_t*)&cgen_var_695, 1 * 8);
marshal_VkPhysicalDeviceProperties2(countingStream, (VkPhysicalDeviceProperties2*)(pProperties));
}
uint32_t packetSize_vkGetPhysicalDeviceProperties2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -10367,9 +10623,9 @@
uint32_t opcode_vkGetPhysicalDeviceProperties2 = OP_vkGetPhysicalDeviceProperties2;
stream->write(&opcode_vkGetPhysicalDeviceProperties2, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceProperties2, sizeof(uint32_t));
- uint64_t cgen_var_692;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_692, 1);
- stream->write((uint64_t*)&cgen_var_692, 1 * 8);
+ uint64_t cgen_var_696;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_696, 1);
+ stream->write((uint64_t*)&cgen_var_696, 1 * 8);
marshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2 readParams");
unmarshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties));
@@ -10386,6 +10642,7 @@
VkFormat format,
VkFormatProperties2* pFormatProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2 encode");
mImpl->log("start vkGetPhysicalDeviceFormatProperties2");
auto stream = mImpl->stream();
@@ -10399,9 +10656,9 @@
local_format = format;
countingStream->rewind();
{
- uint64_t cgen_var_693;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_693, 1);
- countingStream->write((uint64_t*)&cgen_var_693, 1 * 8);
+ uint64_t cgen_var_697;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_697, 1);
+ countingStream->write((uint64_t*)&cgen_var_697, 1 * 8);
countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
marshal_VkFormatProperties2(countingStream, (VkFormatProperties2*)(pFormatProperties));
}
@@ -10410,9 +10667,9 @@
uint32_t opcode_vkGetPhysicalDeviceFormatProperties2 = OP_vkGetPhysicalDeviceFormatProperties2;
stream->write(&opcode_vkGetPhysicalDeviceFormatProperties2, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceFormatProperties2, sizeof(uint32_t));
- uint64_t cgen_var_694;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_694, 1);
- stream->write((uint64_t*)&cgen_var_694, 1 * 8);
+ uint64_t cgen_var_698;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_698, 1);
+ stream->write((uint64_t*)&cgen_var_698, 1 * 8);
stream->write((VkFormat*)&local_format, sizeof(VkFormat));
marshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2 readParams");
@@ -10430,6 +10687,7 @@
const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
VkImageFormatProperties2* pImageFormatProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2 encode");
mImpl->log("start vkGetPhysicalDeviceImageFormatProperties2");
auto stream = mImpl->stream();
@@ -10452,9 +10710,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_695;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_695, 1);
- countingStream->write((uint64_t*)&cgen_var_695, 1 * 8);
+ uint64_t cgen_var_699;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_699, 1);
+ countingStream->write((uint64_t*)&cgen_var_699, 1 * 8);
marshal_VkPhysicalDeviceImageFormatInfo2(countingStream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
marshal_VkImageFormatProperties2(countingStream, (VkImageFormatProperties2*)(pImageFormatProperties));
}
@@ -10463,9 +10721,9 @@
uint32_t opcode_vkGetPhysicalDeviceImageFormatProperties2 = OP_vkGetPhysicalDeviceImageFormatProperties2;
stream->write(&opcode_vkGetPhysicalDeviceImageFormatProperties2, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceImageFormatProperties2, sizeof(uint32_t));
- uint64_t cgen_var_696;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_696, 1);
- stream->write((uint64_t*)&cgen_var_696, 1 * 8);
+ uint64_t cgen_var_700;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_700, 1);
+ stream->write((uint64_t*)&cgen_var_700, 1 * 8);
marshal_VkPhysicalDeviceImageFormatInfo2(stream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
marshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2 readParams");
@@ -10489,6 +10747,7 @@
uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties2* pQueueFamilyProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2 encode");
mImpl->log("start vkGetPhysicalDeviceQueueFamilyProperties2");
auto stream = mImpl->stream();
@@ -10500,19 +10759,19 @@
local_physicalDevice = physicalDevice;
countingStream->rewind();
{
- uint64_t cgen_var_697;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_697, 1);
- countingStream->write((uint64_t*)&cgen_var_697, 1 * 8);
+ uint64_t cgen_var_701;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_701, 1);
+ countingStream->write((uint64_t*)&cgen_var_701, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_698 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
- countingStream->putBe64(cgen_var_698);
+ uint64_t cgen_var_702 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+ countingStream->putBe64(cgen_var_702);
if (pQueueFamilyPropertyCount)
{
countingStream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_699 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
- countingStream->putBe64(cgen_var_699);
+ uint64_t cgen_var_703 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+ countingStream->putBe64(cgen_var_703);
if (pQueueFamilyProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
@@ -10526,19 +10785,19 @@
uint32_t opcode_vkGetPhysicalDeviceQueueFamilyProperties2 = OP_vkGetPhysicalDeviceQueueFamilyProperties2;
stream->write(&opcode_vkGetPhysicalDeviceQueueFamilyProperties2, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceQueueFamilyProperties2, sizeof(uint32_t));
- uint64_t cgen_var_700;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_700, 1);
- stream->write((uint64_t*)&cgen_var_700, 1 * 8);
+ uint64_t cgen_var_704;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_704, 1);
+ stream->write((uint64_t*)&cgen_var_704, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_701 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
- stream->putBe64(cgen_var_701);
+ uint64_t cgen_var_705 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+ stream->putBe64(cgen_var_705);
if (pQueueFamilyPropertyCount)
{
stream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_702 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
- stream->putBe64(cgen_var_702);
+ uint64_t cgen_var_706 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+ stream->putBe64(cgen_var_706);
if (pQueueFamilyProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
@@ -10587,6 +10846,7 @@
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2 encode");
mImpl->log("start vkGetPhysicalDeviceMemoryProperties2");
auto stream = mImpl->stream();
@@ -10598,9 +10858,9 @@
local_physicalDevice = physicalDevice;
countingStream->rewind();
{
- uint64_t cgen_var_705;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_705, 1);
- countingStream->write((uint64_t*)&cgen_var_705, 1 * 8);
+ uint64_t cgen_var_709;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_709, 1);
+ countingStream->write((uint64_t*)&cgen_var_709, 1 * 8);
marshal_VkPhysicalDeviceMemoryProperties2(countingStream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
}
uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -10608,9 +10868,9 @@
uint32_t opcode_vkGetPhysicalDeviceMemoryProperties2 = OP_vkGetPhysicalDeviceMemoryProperties2;
stream->write(&opcode_vkGetPhysicalDeviceMemoryProperties2, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceMemoryProperties2, sizeof(uint32_t));
- uint64_t cgen_var_706;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_706, 1);
- stream->write((uint64_t*)&cgen_var_706, 1 * 8);
+ uint64_t cgen_var_710;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_710, 1);
+ stream->write((uint64_t*)&cgen_var_710, 1 * 8);
marshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2 readParams");
unmarshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
@@ -10619,7 +10879,9 @@
transform_fromhost_VkPhysicalDeviceMemoryProperties2(mImpl->resources(), (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
}
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2 returnUnmarshal");
+ encoderLock.unlock();
mImpl->resources()->on_vkGetPhysicalDeviceMemoryProperties2(this, physicalDevice, pMemoryProperties);
+ encoderLock.lock();
mImpl->log("finish vkGetPhysicalDeviceMemoryProperties2");;
}
@@ -10629,6 +10891,7 @@
uint32_t* pPropertyCount,
VkSparseImageFormatProperties2* pProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2 encode");
mImpl->log("start vkGetPhysicalDeviceSparseImageFormatProperties2");
auto stream = mImpl->stream();
@@ -10651,20 +10914,20 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_707;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_707, 1);
- countingStream->write((uint64_t*)&cgen_var_707, 1 * 8);
+ uint64_t cgen_var_711;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_711, 1);
+ countingStream->write((uint64_t*)&cgen_var_711, 1 * 8);
marshal_VkPhysicalDeviceSparseImageFormatInfo2(countingStream, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_708 = (uint64_t)(uintptr_t)pPropertyCount;
- countingStream->putBe64(cgen_var_708);
+ uint64_t cgen_var_712 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_712);
if (pPropertyCount)
{
countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_709 = (uint64_t)(uintptr_t)pProperties;
- countingStream->putBe64(cgen_var_709);
+ uint64_t cgen_var_713 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_713);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -10678,20 +10941,20 @@
uint32_t opcode_vkGetPhysicalDeviceSparseImageFormatProperties2 = OP_vkGetPhysicalDeviceSparseImageFormatProperties2;
stream->write(&opcode_vkGetPhysicalDeviceSparseImageFormatProperties2, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2, sizeof(uint32_t));
- uint64_t cgen_var_710;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_710, 1);
- stream->write((uint64_t*)&cgen_var_710, 1 * 8);
+ uint64_t cgen_var_714;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_714, 1);
+ stream->write((uint64_t*)&cgen_var_714, 1 * 8);
marshal_VkPhysicalDeviceSparseImageFormatInfo2(stream, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_711 = (uint64_t)(uintptr_t)pPropertyCount;
- stream->putBe64(cgen_var_711);
+ uint64_t cgen_var_715 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_715);
if (pPropertyCount)
{
stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_712 = (uint64_t)(uintptr_t)pProperties;
- stream->putBe64(cgen_var_712);
+ uint64_t cgen_var_716 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_716);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -10741,6 +11004,7 @@
VkCommandPool commandPool,
VkCommandPoolTrimFlags flags)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkTrimCommandPool encode");
mImpl->log("start vkTrimCommandPool");
auto stream = mImpl->stream();
@@ -10756,12 +11020,12 @@
local_flags = flags;
countingStream->rewind();
{
- uint64_t cgen_var_715;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_715, 1);
- countingStream->write((uint64_t*)&cgen_var_715, 1 * 8);
- uint64_t cgen_var_716;
- countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_716, 1);
- countingStream->write((uint64_t*)&cgen_var_716, 1 * 8);
+ uint64_t cgen_var_719;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_719, 1);
+ countingStream->write((uint64_t*)&cgen_var_719, 1 * 8);
+ uint64_t cgen_var_720;
+ countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_720, 1);
+ countingStream->write((uint64_t*)&cgen_var_720, 1 * 8);
countingStream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
}
uint32_t packetSize_vkTrimCommandPool = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -10769,12 +11033,12 @@
uint32_t opcode_vkTrimCommandPool = OP_vkTrimCommandPool;
stream->write(&opcode_vkTrimCommandPool, sizeof(uint32_t));
stream->write(&packetSize_vkTrimCommandPool, sizeof(uint32_t));
- uint64_t cgen_var_717;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_717, 1);
- stream->write((uint64_t*)&cgen_var_717, 1 * 8);
- uint64_t cgen_var_718;
- stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_718, 1);
- stream->write((uint64_t*)&cgen_var_718, 1 * 8);
+ uint64_t cgen_var_721;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_721, 1);
+ stream->write((uint64_t*)&cgen_var_721, 1 * 8);
+ uint64_t cgen_var_722;
+ stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_722, 1);
+ stream->write((uint64_t*)&cgen_var_722, 1 * 8);
stream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
AEMU_SCOPED_TRACE("vkTrimCommandPool readParams");
AEMU_SCOPED_TRACE("vkTrimCommandPool returnUnmarshal");
@@ -10786,6 +11050,7 @@
const VkDeviceQueueInfo2* pQueueInfo,
VkQueue* pQueue)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetDeviceQueue2 encode");
mImpl->log("start vkGetDeviceQueue2");
auto stream = mImpl->stream();
@@ -10808,32 +11073,32 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_719;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_719, 1);
- countingStream->write((uint64_t*)&cgen_var_719, 1 * 8);
+ uint64_t cgen_var_723;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_723, 1);
+ countingStream->write((uint64_t*)&cgen_var_723, 1 * 8);
marshal_VkDeviceQueueInfo2(countingStream, (VkDeviceQueueInfo2*)(local_pQueueInfo));
- uint64_t cgen_var_720;
- countingStream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_720, 1);
- countingStream->write((uint64_t*)&cgen_var_720, 8);
+ uint64_t cgen_var_724;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_724, 1);
+ countingStream->write((uint64_t*)&cgen_var_724, 8);
}
uint32_t packetSize_vkGetDeviceQueue2 = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkGetDeviceQueue2 = OP_vkGetDeviceQueue2;
stream->write(&opcode_vkGetDeviceQueue2, sizeof(uint32_t));
stream->write(&packetSize_vkGetDeviceQueue2, sizeof(uint32_t));
- uint64_t cgen_var_721;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_721, 1);
- stream->write((uint64_t*)&cgen_var_721, 1 * 8);
+ uint64_t cgen_var_725;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_725, 1);
+ stream->write((uint64_t*)&cgen_var_725, 1 * 8);
marshal_VkDeviceQueueInfo2(stream, (VkDeviceQueueInfo2*)(local_pQueueInfo));
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_722;
- stream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_722, 1);
- stream->write((uint64_t*)&cgen_var_722, 8);
+ uint64_t cgen_var_726;
+ stream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_726, 1);
+ stream->write((uint64_t*)&cgen_var_726, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkGetDeviceQueue2 readParams");
- uint64_t cgen_var_723;
- stream->read((uint64_t*)&cgen_var_723, 8);
- stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_723, (VkQueue*)pQueue, 1);
+ uint64_t cgen_var_727;
+ stream->read((uint64_t*)&cgen_var_727, 8);
+ stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_727, (VkQueue*)pQueue, 1);
AEMU_SCOPED_TRACE("vkGetDeviceQueue2 returnUnmarshal");
mImpl->log("finish vkGetDeviceQueue2");;
}
@@ -10844,6 +11109,7 @@
const VkAllocationCallbacks* pAllocator,
VkSamplerYcbcrConversion* pYcbcrConversion)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion encode");
mImpl->log("start vkCreateSamplerYcbcrConversion");
auto stream = mImpl->stream();
@@ -10878,47 +11144,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_724;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_724, 1);
- countingStream->write((uint64_t*)&cgen_var_724, 1 * 8);
+ uint64_t cgen_var_728;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_728, 1);
+ countingStream->write((uint64_t*)&cgen_var_728, 1 * 8);
marshal_VkSamplerYcbcrConversionCreateInfo(countingStream, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_725 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_725);
+ uint64_t cgen_var_729 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_729);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_726;
- countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_726, 1);
- countingStream->write((uint64_t*)&cgen_var_726, 8);
+ uint64_t cgen_var_730;
+ countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_730, 1);
+ countingStream->write((uint64_t*)&cgen_var_730, 8);
}
uint32_t packetSize_vkCreateSamplerYcbcrConversion = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateSamplerYcbcrConversion = OP_vkCreateSamplerYcbcrConversion;
stream->write(&opcode_vkCreateSamplerYcbcrConversion, sizeof(uint32_t));
stream->write(&packetSize_vkCreateSamplerYcbcrConversion, sizeof(uint32_t));
- uint64_t cgen_var_727;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_727, 1);
- stream->write((uint64_t*)&cgen_var_727, 1 * 8);
+ uint64_t cgen_var_731;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_731, 1);
+ stream->write((uint64_t*)&cgen_var_731, 1 * 8);
marshal_VkSamplerYcbcrConversionCreateInfo(stream, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_728 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_728);
+ uint64_t cgen_var_732 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_732);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_729;
- stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_729, 1);
- stream->write((uint64_t*)&cgen_var_729, 8);
+ uint64_t cgen_var_733;
+ stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_733, 1);
+ stream->write((uint64_t*)&cgen_var_733, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_730;
- stream->read((uint64_t*)&cgen_var_730, 8);
- stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_730, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
+ uint64_t cgen_var_734;
+ stream->read((uint64_t*)&cgen_var_734, 8);
+ stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_734, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion returnUnmarshal");
VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
@@ -10935,6 +11201,7 @@
VkSamplerYcbcrConversion ycbcrConversion,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion encode");
mImpl->log("start vkDestroySamplerYcbcrConversion");
auto stream = mImpl->stream();
@@ -10960,15 +11227,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_731;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_731, 1);
- countingStream->write((uint64_t*)&cgen_var_731, 1 * 8);
- uint64_t cgen_var_732;
- countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_732, 1);
- countingStream->write((uint64_t*)&cgen_var_732, 1 * 8);
+ uint64_t cgen_var_735;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_735, 1);
+ countingStream->write((uint64_t*)&cgen_var_735, 1 * 8);
+ uint64_t cgen_var_736;
+ countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_736, 1);
+ countingStream->write((uint64_t*)&cgen_var_736, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_733 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_733);
+ uint64_t cgen_var_737 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_737);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -10979,15 +11246,15 @@
uint32_t opcode_vkDestroySamplerYcbcrConversion = OP_vkDestroySamplerYcbcrConversion;
stream->write(&opcode_vkDestroySamplerYcbcrConversion, sizeof(uint32_t));
stream->write(&packetSize_vkDestroySamplerYcbcrConversion, sizeof(uint32_t));
- uint64_t cgen_var_734;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_734, 1);
- stream->write((uint64_t*)&cgen_var_734, 1 * 8);
- uint64_t cgen_var_735;
- stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_735, 1);
- stream->write((uint64_t*)&cgen_var_735, 1 * 8);
+ uint64_t cgen_var_738;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_738, 1);
+ stream->write((uint64_t*)&cgen_var_738, 1 * 8);
+ uint64_t cgen_var_739;
+ stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_739, 1);
+ stream->write((uint64_t*)&cgen_var_739, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_736 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_736);
+ uint64_t cgen_var_740 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_740);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -11004,6 +11271,7 @@
const VkAllocationCallbacks* pAllocator,
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate encode");
mImpl->log("start vkCreateDescriptorUpdateTemplate");
auto stream = mImpl->stream();
@@ -11038,47 +11306,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_737;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_737, 1);
- countingStream->write((uint64_t*)&cgen_var_737, 1 * 8);
+ uint64_t cgen_var_741;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_741, 1);
+ countingStream->write((uint64_t*)&cgen_var_741, 1 * 8);
marshal_VkDescriptorUpdateTemplateCreateInfo(countingStream, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_738 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_738);
+ uint64_t cgen_var_742 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_742);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_739;
- countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_739, 1);
- countingStream->write((uint64_t*)&cgen_var_739, 8);
+ uint64_t cgen_var_743;
+ countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_743, 1);
+ countingStream->write((uint64_t*)&cgen_var_743, 8);
}
uint32_t packetSize_vkCreateDescriptorUpdateTemplate = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateDescriptorUpdateTemplate = OP_vkCreateDescriptorUpdateTemplate;
stream->write(&opcode_vkCreateDescriptorUpdateTemplate, sizeof(uint32_t));
stream->write(&packetSize_vkCreateDescriptorUpdateTemplate, sizeof(uint32_t));
- uint64_t cgen_var_740;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_740, 1);
- stream->write((uint64_t*)&cgen_var_740, 1 * 8);
+ uint64_t cgen_var_744;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_744, 1);
+ stream->write((uint64_t*)&cgen_var_744, 1 * 8);
marshal_VkDescriptorUpdateTemplateCreateInfo(stream, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_741 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_741);
+ uint64_t cgen_var_745 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_745);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_742;
- stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_742, 1);
- stream->write((uint64_t*)&cgen_var_742, 8);
+ uint64_t cgen_var_746;
+ stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_746, 1);
+ stream->write((uint64_t*)&cgen_var_746, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_743;
- stream->read((uint64_t*)&cgen_var_743, 8);
- stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(&cgen_var_743, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
+ uint64_t cgen_var_747;
+ stream->read((uint64_t*)&cgen_var_747, 8);
+ stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(&cgen_var_747, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate returnUnmarshal");
VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
@@ -11086,7 +11354,9 @@
countingStream->clearPool();
stream->clearPool();
pool->freeAll();
+ encoderLock.unlock();
mImpl->resources()->on_vkCreateDescriptorUpdateTemplate(this, vkCreateDescriptorUpdateTemplate_VkResult_return, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+ encoderLock.lock();
mImpl->log("finish vkCreateDescriptorUpdateTemplate");;
return vkCreateDescriptorUpdateTemplate_VkResult_return;
}
@@ -11096,6 +11366,7 @@
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate encode");
mImpl->log("start vkDestroyDescriptorUpdateTemplate");
auto stream = mImpl->stream();
@@ -11121,15 +11392,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_744;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_744, 1);
- countingStream->write((uint64_t*)&cgen_var_744, 1 * 8);
- uint64_t cgen_var_745;
- countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_745, 1);
- countingStream->write((uint64_t*)&cgen_var_745, 1 * 8);
+ uint64_t cgen_var_748;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_748, 1);
+ countingStream->write((uint64_t*)&cgen_var_748, 1 * 8);
+ uint64_t cgen_var_749;
+ countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_749, 1);
+ countingStream->write((uint64_t*)&cgen_var_749, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_746 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_746);
+ uint64_t cgen_var_750 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_750);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -11140,15 +11411,15 @@
uint32_t opcode_vkDestroyDescriptorUpdateTemplate = OP_vkDestroyDescriptorUpdateTemplate;
stream->write(&opcode_vkDestroyDescriptorUpdateTemplate, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyDescriptorUpdateTemplate, sizeof(uint32_t));
- uint64_t cgen_var_747;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_747, 1);
- stream->write((uint64_t*)&cgen_var_747, 1 * 8);
- uint64_t cgen_var_748;
- stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_748, 1);
- stream->write((uint64_t*)&cgen_var_748, 1 * 8);
+ uint64_t cgen_var_751;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_751, 1);
+ stream->write((uint64_t*)&cgen_var_751, 1 * 8);
+ uint64_t cgen_var_752;
+ stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_752, 1);
+ stream->write((uint64_t*)&cgen_var_752, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_749 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_749);
+ uint64_t cgen_var_753 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_753);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -11165,6 +11436,7 @@
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const void* pData)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate encode");
mImpl->log("start vkUpdateDescriptorSetWithTemplate");
auto stream = mImpl->stream();
@@ -11186,18 +11458,18 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_750;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_750, 1);
- countingStream->write((uint64_t*)&cgen_var_750, 1 * 8);
- uint64_t cgen_var_751;
- countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_751, 1);
- countingStream->write((uint64_t*)&cgen_var_751, 1 * 8);
- uint64_t cgen_var_752;
- countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_752, 1);
- countingStream->write((uint64_t*)&cgen_var_752, 1 * 8);
+ uint64_t cgen_var_754;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_754, 1);
+ countingStream->write((uint64_t*)&cgen_var_754, 1 * 8);
+ uint64_t cgen_var_755;
+ countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_755, 1);
+ countingStream->write((uint64_t*)&cgen_var_755, 1 * 8);
+ uint64_t cgen_var_756;
+ countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_756, 1);
+ countingStream->write((uint64_t*)&cgen_var_756, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_753 = (uint64_t)(uintptr_t)local_pData;
- countingStream->putBe64(cgen_var_753);
+ uint64_t cgen_var_757 = (uint64_t)(uintptr_t)local_pData;
+ countingStream->putBe64(cgen_var_757);
if (local_pData)
{
countingStream->write((void*)local_pData, sizeof(uint8_t));
@@ -11208,18 +11480,18 @@
uint32_t opcode_vkUpdateDescriptorSetWithTemplate = OP_vkUpdateDescriptorSetWithTemplate;
stream->write(&opcode_vkUpdateDescriptorSetWithTemplate, sizeof(uint32_t));
stream->write(&packetSize_vkUpdateDescriptorSetWithTemplate, sizeof(uint32_t));
- uint64_t cgen_var_754;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_754, 1);
- stream->write((uint64_t*)&cgen_var_754, 1 * 8);
- uint64_t cgen_var_755;
- stream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_755, 1);
- stream->write((uint64_t*)&cgen_var_755, 1 * 8);
- uint64_t cgen_var_756;
- stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_756, 1);
- stream->write((uint64_t*)&cgen_var_756, 1 * 8);
+ uint64_t cgen_var_758;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_758, 1);
+ stream->write((uint64_t*)&cgen_var_758, 1 * 8);
+ uint64_t cgen_var_759;
+ stream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_759, 1);
+ stream->write((uint64_t*)&cgen_var_759, 1 * 8);
+ uint64_t cgen_var_760;
+ stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_760, 1);
+ stream->write((uint64_t*)&cgen_var_760, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_757 = (uint64_t)(uintptr_t)local_pData;
- stream->putBe64(cgen_var_757);
+ uint64_t cgen_var_761 = (uint64_t)(uintptr_t)local_pData;
+ stream->putBe64(cgen_var_761);
if (local_pData)
{
stream->write((void*)local_pData, sizeof(uint8_t));
@@ -11234,6 +11506,7 @@
const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
VkExternalBufferProperties* pExternalBufferProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties encode");
mImpl->log("start vkGetPhysicalDeviceExternalBufferProperties");
auto stream = mImpl->stream();
@@ -11257,9 +11530,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_758;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_758, 1);
- countingStream->write((uint64_t*)&cgen_var_758, 1 * 8);
+ uint64_t cgen_var_762;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_762, 1);
+ countingStream->write((uint64_t*)&cgen_var_762, 1 * 8);
marshal_VkPhysicalDeviceExternalBufferInfo(countingStream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
marshal_VkExternalBufferProperties(countingStream, (VkExternalBufferProperties*)(pExternalBufferProperties));
}
@@ -11268,9 +11541,9 @@
uint32_t opcode_vkGetPhysicalDeviceExternalBufferProperties = OP_vkGetPhysicalDeviceExternalBufferProperties;
stream->write(&opcode_vkGetPhysicalDeviceExternalBufferProperties, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceExternalBufferProperties, sizeof(uint32_t));
- uint64_t cgen_var_759;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_759, 1);
- stream->write((uint64_t*)&cgen_var_759, 1 * 8);
+ uint64_t cgen_var_763;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_763, 1);
+ stream->write((uint64_t*)&cgen_var_763, 1 * 8);
marshal_VkPhysicalDeviceExternalBufferInfo(stream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
marshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties readParams");
@@ -11289,6 +11562,7 @@
const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
VkExternalFenceProperties* pExternalFenceProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties encode");
mImpl->log("start vkGetPhysicalDeviceExternalFenceProperties");
auto stream = mImpl->stream();
@@ -11311,9 +11585,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_760;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_760, 1);
- countingStream->write((uint64_t*)&cgen_var_760, 1 * 8);
+ uint64_t cgen_var_764;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_764, 1);
+ countingStream->write((uint64_t*)&cgen_var_764, 1 * 8);
marshal_VkPhysicalDeviceExternalFenceInfo(countingStream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
marshal_VkExternalFenceProperties(countingStream, (VkExternalFenceProperties*)(pExternalFenceProperties));
}
@@ -11322,9 +11596,9 @@
uint32_t opcode_vkGetPhysicalDeviceExternalFenceProperties = OP_vkGetPhysicalDeviceExternalFenceProperties;
stream->write(&opcode_vkGetPhysicalDeviceExternalFenceProperties, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceExternalFenceProperties, sizeof(uint32_t));
- uint64_t cgen_var_761;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_761, 1);
- stream->write((uint64_t*)&cgen_var_761, 1 * 8);
+ uint64_t cgen_var_765;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_765, 1);
+ stream->write((uint64_t*)&cgen_var_765, 1 * 8);
marshal_VkPhysicalDeviceExternalFenceInfo(stream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
marshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties readParams");
@@ -11342,6 +11616,7 @@
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties encode");
mImpl->log("start vkGetPhysicalDeviceExternalSemaphoreProperties");
auto stream = mImpl->stream();
@@ -11364,9 +11639,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_762;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_762, 1);
- countingStream->write((uint64_t*)&cgen_var_762, 1 * 8);
+ uint64_t cgen_var_766;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_766, 1);
+ countingStream->write((uint64_t*)&cgen_var_766, 1 * 8);
marshal_VkPhysicalDeviceExternalSemaphoreInfo(countingStream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
marshal_VkExternalSemaphoreProperties(countingStream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
}
@@ -11375,9 +11650,9 @@
uint32_t opcode_vkGetPhysicalDeviceExternalSemaphoreProperties = OP_vkGetPhysicalDeviceExternalSemaphoreProperties;
stream->write(&opcode_vkGetPhysicalDeviceExternalSemaphoreProperties, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceExternalSemaphoreProperties, sizeof(uint32_t));
- uint64_t cgen_var_763;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_763, 1);
- stream->write((uint64_t*)&cgen_var_763, 1 * 8);
+ uint64_t cgen_var_767;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_767, 1);
+ stream->write((uint64_t*)&cgen_var_767, 1 * 8);
marshal_VkPhysicalDeviceExternalSemaphoreInfo(stream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
marshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties readParams");
@@ -11395,6 +11670,7 @@
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayoutSupport* pSupport)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport encode");
mImpl->log("start vkGetDescriptorSetLayoutSupport");
auto stream = mImpl->stream();
@@ -11417,9 +11693,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_764;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_764, 1);
- countingStream->write((uint64_t*)&cgen_var_764, 1 * 8);
+ uint64_t cgen_var_768;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_768, 1);
+ countingStream->write((uint64_t*)&cgen_var_768, 1 * 8);
marshal_VkDescriptorSetLayoutCreateInfo(countingStream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
marshal_VkDescriptorSetLayoutSupport(countingStream, (VkDescriptorSetLayoutSupport*)(pSupport));
}
@@ -11428,9 +11704,9 @@
uint32_t opcode_vkGetDescriptorSetLayoutSupport = OP_vkGetDescriptorSetLayoutSupport;
stream->write(&opcode_vkGetDescriptorSetLayoutSupport, sizeof(uint32_t));
stream->write(&packetSize_vkGetDescriptorSetLayoutSupport, sizeof(uint32_t));
- uint64_t cgen_var_765;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_765, 1);
- stream->write((uint64_t*)&cgen_var_765, 1 * 8);
+ uint64_t cgen_var_769;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_769, 1);
+ stream->write((uint64_t*)&cgen_var_769, 1 * 8);
marshal_VkDescriptorSetLayoutCreateInfo(stream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
marshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport));
AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport readParams");
@@ -11450,6 +11726,7 @@
VkSurfaceKHR surface,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroySurfaceKHR encode");
mImpl->log("start vkDestroySurfaceKHR");
auto stream = mImpl->stream();
@@ -11475,15 +11752,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_766;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_766, 1);
- countingStream->write((uint64_t*)&cgen_var_766, 1 * 8);
- uint64_t cgen_var_767;
- countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_767, 1);
- countingStream->write((uint64_t*)&cgen_var_767, 1 * 8);
+ uint64_t cgen_var_770;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_770, 1);
+ countingStream->write((uint64_t*)&cgen_var_770, 1 * 8);
+ uint64_t cgen_var_771;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_771, 1);
+ countingStream->write((uint64_t*)&cgen_var_771, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_768 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_768);
+ uint64_t cgen_var_772 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_772);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -11494,15 +11771,15 @@
uint32_t opcode_vkDestroySurfaceKHR = OP_vkDestroySurfaceKHR;
stream->write(&opcode_vkDestroySurfaceKHR, sizeof(uint32_t));
stream->write(&packetSize_vkDestroySurfaceKHR, sizeof(uint32_t));
- uint64_t cgen_var_769;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_769, 1);
- stream->write((uint64_t*)&cgen_var_769, 1 * 8);
- uint64_t cgen_var_770;
- stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_770, 1);
- stream->write((uint64_t*)&cgen_var_770, 1 * 8);
+ uint64_t cgen_var_773;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_773, 1);
+ stream->write((uint64_t*)&cgen_var_773, 1 * 8);
+ uint64_t cgen_var_774;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_774, 1);
+ stream->write((uint64_t*)&cgen_var_774, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_771 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_771);
+ uint64_t cgen_var_775 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_775);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -11519,6 +11796,7 @@
VkSurfaceKHR surface,
VkBool32* pSupported)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceSupportKHR encode");
mImpl->log("start vkGetPhysicalDeviceSurfaceSupportKHR");
auto stream = mImpl->stream();
@@ -11534,13 +11812,13 @@
local_surface = surface;
countingStream->rewind();
{
- uint64_t cgen_var_772;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_772, 1);
- countingStream->write((uint64_t*)&cgen_var_772, 1 * 8);
+ uint64_t cgen_var_776;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_776, 1);
+ countingStream->write((uint64_t*)&cgen_var_776, 1 * 8);
countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
- uint64_t cgen_var_773;
- countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_773, 1);
- countingStream->write((uint64_t*)&cgen_var_773, 1 * 8);
+ uint64_t cgen_var_777;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_777, 1);
+ countingStream->write((uint64_t*)&cgen_var_777, 1 * 8);
countingStream->write((VkBool32*)pSupported, sizeof(VkBool32));
}
uint32_t packetSize_vkGetPhysicalDeviceSurfaceSupportKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -11548,13 +11826,13 @@
uint32_t opcode_vkGetPhysicalDeviceSurfaceSupportKHR = OP_vkGetPhysicalDeviceSurfaceSupportKHR;
stream->write(&opcode_vkGetPhysicalDeviceSurfaceSupportKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceSurfaceSupportKHR, sizeof(uint32_t));
- uint64_t cgen_var_774;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_774, 1);
- stream->write((uint64_t*)&cgen_var_774, 1 * 8);
+ uint64_t cgen_var_778;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_778, 1);
+ stream->write((uint64_t*)&cgen_var_778, 1 * 8);
stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
- uint64_t cgen_var_775;
- stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_775, 1);
- stream->write((uint64_t*)&cgen_var_775, 1 * 8);
+ uint64_t cgen_var_779;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_779, 1);
+ stream->write((uint64_t*)&cgen_var_779, 1 * 8);
stream->write((VkBool32*)pSupported, sizeof(VkBool32));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceSupportKHR readParams");
stream->read((VkBool32*)pSupported, sizeof(VkBool32));
@@ -11573,6 +11851,7 @@
VkSurfaceKHR surface,
VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilitiesKHR encode");
mImpl->log("start vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
auto stream = mImpl->stream();
@@ -11586,12 +11865,12 @@
local_surface = surface;
countingStream->rewind();
{
- uint64_t cgen_var_776;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_776, 1);
- countingStream->write((uint64_t*)&cgen_var_776, 1 * 8);
- uint64_t cgen_var_777;
- countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_777, 1);
- countingStream->write((uint64_t*)&cgen_var_777, 1 * 8);
+ uint64_t cgen_var_780;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_780, 1);
+ countingStream->write((uint64_t*)&cgen_var_780, 1 * 8);
+ uint64_t cgen_var_781;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_781, 1);
+ countingStream->write((uint64_t*)&cgen_var_781, 1 * 8);
marshal_VkSurfaceCapabilitiesKHR(countingStream, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
}
uint32_t packetSize_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -11599,12 +11878,12 @@
uint32_t opcode_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = OP_vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
stream->write(&opcode_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, sizeof(uint32_t));
- uint64_t cgen_var_778;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_778, 1);
- stream->write((uint64_t*)&cgen_var_778, 1 * 8);
- uint64_t cgen_var_779;
- stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_779, 1);
- stream->write((uint64_t*)&cgen_var_779, 1 * 8);
+ uint64_t cgen_var_782;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_782, 1);
+ stream->write((uint64_t*)&cgen_var_782, 1 * 8);
+ uint64_t cgen_var_783;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_783, 1);
+ stream->write((uint64_t*)&cgen_var_783, 1 * 8);
marshal_VkSurfaceCapabilitiesKHR(stream, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilitiesKHR readParams");
unmarshal_VkSurfaceCapabilitiesKHR(stream, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
@@ -11628,6 +11907,7 @@
uint32_t* pSurfaceFormatCount,
VkSurfaceFormatKHR* pSurfaceFormats)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormatsKHR encode");
mImpl->log("start vkGetPhysicalDeviceSurfaceFormatsKHR");
auto stream = mImpl->stream();
@@ -11641,22 +11921,22 @@
local_surface = surface;
countingStream->rewind();
{
- uint64_t cgen_var_780;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_780, 1);
- countingStream->write((uint64_t*)&cgen_var_780, 1 * 8);
- uint64_t cgen_var_781;
- countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_781, 1);
- countingStream->write((uint64_t*)&cgen_var_781, 1 * 8);
+ uint64_t cgen_var_784;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_784, 1);
+ countingStream->write((uint64_t*)&cgen_var_784, 1 * 8);
+ uint64_t cgen_var_785;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_785, 1);
+ countingStream->write((uint64_t*)&cgen_var_785, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_782 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
- countingStream->putBe64(cgen_var_782);
+ uint64_t cgen_var_786 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
+ countingStream->putBe64(cgen_var_786);
if (pSurfaceFormatCount)
{
countingStream->write((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_783 = (uint64_t)(uintptr_t)pSurfaceFormats;
- countingStream->putBe64(cgen_var_783);
+ uint64_t cgen_var_787 = (uint64_t)(uintptr_t)pSurfaceFormats;
+ countingStream->putBe64(cgen_var_787);
if (pSurfaceFormats)
{
for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
@@ -11670,22 +11950,22 @@
uint32_t opcode_vkGetPhysicalDeviceSurfaceFormatsKHR = OP_vkGetPhysicalDeviceSurfaceFormatsKHR;
stream->write(&opcode_vkGetPhysicalDeviceSurfaceFormatsKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceSurfaceFormatsKHR, sizeof(uint32_t));
- uint64_t cgen_var_784;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_784, 1);
- stream->write((uint64_t*)&cgen_var_784, 1 * 8);
- uint64_t cgen_var_785;
- stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_785, 1);
- stream->write((uint64_t*)&cgen_var_785, 1 * 8);
+ uint64_t cgen_var_788;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_788, 1);
+ stream->write((uint64_t*)&cgen_var_788, 1 * 8);
+ uint64_t cgen_var_789;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_789, 1);
+ stream->write((uint64_t*)&cgen_var_789, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_786 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
- stream->putBe64(cgen_var_786);
+ uint64_t cgen_var_790 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
+ stream->putBe64(cgen_var_790);
if (pSurfaceFormatCount)
{
stream->write((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_787 = (uint64_t)(uintptr_t)pSurfaceFormats;
- stream->putBe64(cgen_var_787);
+ uint64_t cgen_var_791 = (uint64_t)(uintptr_t)pSurfaceFormats;
+ stream->putBe64(cgen_var_791);
if (pSurfaceFormats)
{
for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
@@ -11742,6 +12022,7 @@
uint32_t* pPresentModeCount,
VkPresentModeKHR* pPresentModes)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfacePresentModesKHR encode");
mImpl->log("start vkGetPhysicalDeviceSurfacePresentModesKHR");
auto stream = mImpl->stream();
@@ -11755,22 +12036,22 @@
local_surface = surface;
countingStream->rewind();
{
- uint64_t cgen_var_790;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_790, 1);
- countingStream->write((uint64_t*)&cgen_var_790, 1 * 8);
- uint64_t cgen_var_791;
- countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_791, 1);
- countingStream->write((uint64_t*)&cgen_var_791, 1 * 8);
+ uint64_t cgen_var_794;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_794, 1);
+ countingStream->write((uint64_t*)&cgen_var_794, 1 * 8);
+ uint64_t cgen_var_795;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_795, 1);
+ countingStream->write((uint64_t*)&cgen_var_795, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_792 = (uint64_t)(uintptr_t)pPresentModeCount;
- countingStream->putBe64(cgen_var_792);
+ uint64_t cgen_var_796 = (uint64_t)(uintptr_t)pPresentModeCount;
+ countingStream->putBe64(cgen_var_796);
if (pPresentModeCount)
{
countingStream->write((uint32_t*)pPresentModeCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_793 = (uint64_t)(uintptr_t)pPresentModes;
- countingStream->putBe64(cgen_var_793);
+ uint64_t cgen_var_797 = (uint64_t)(uintptr_t)pPresentModes;
+ countingStream->putBe64(cgen_var_797);
if (pPresentModes)
{
countingStream->write((VkPresentModeKHR*)pPresentModes, (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
@@ -11781,22 +12062,22 @@
uint32_t opcode_vkGetPhysicalDeviceSurfacePresentModesKHR = OP_vkGetPhysicalDeviceSurfacePresentModesKHR;
stream->write(&opcode_vkGetPhysicalDeviceSurfacePresentModesKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceSurfacePresentModesKHR, sizeof(uint32_t));
- uint64_t cgen_var_794;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_794, 1);
- stream->write((uint64_t*)&cgen_var_794, 1 * 8);
- uint64_t cgen_var_795;
- stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_795, 1);
- stream->write((uint64_t*)&cgen_var_795, 1 * 8);
+ uint64_t cgen_var_798;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_798, 1);
+ stream->write((uint64_t*)&cgen_var_798, 1 * 8);
+ uint64_t cgen_var_799;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_799, 1);
+ stream->write((uint64_t*)&cgen_var_799, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_796 = (uint64_t)(uintptr_t)pPresentModeCount;
- stream->putBe64(cgen_var_796);
+ uint64_t cgen_var_800 = (uint64_t)(uintptr_t)pPresentModeCount;
+ stream->putBe64(cgen_var_800);
if (pPresentModeCount)
{
stream->write((uint32_t*)pPresentModeCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_797 = (uint64_t)(uintptr_t)pPresentModes;
- stream->putBe64(cgen_var_797);
+ uint64_t cgen_var_801 = (uint64_t)(uintptr_t)pPresentModes;
+ stream->putBe64(cgen_var_801);
if (pPresentModes)
{
stream->write((VkPresentModeKHR*)pPresentModes, (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
@@ -11842,6 +12123,7 @@
const VkAllocationCallbacks* pAllocator,
VkSwapchainKHR* pSwapchain)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateSwapchainKHR encode");
mImpl->log("start vkCreateSwapchainKHR");
auto stream = mImpl->stream();
@@ -11876,47 +12158,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_800;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_800, 1);
- countingStream->write((uint64_t*)&cgen_var_800, 1 * 8);
+ uint64_t cgen_var_804;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_804, 1);
+ countingStream->write((uint64_t*)&cgen_var_804, 1 * 8);
marshal_VkSwapchainCreateInfoKHR(countingStream, (VkSwapchainCreateInfoKHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_801 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_801);
+ uint64_t cgen_var_805 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_805);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_802;
- countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchain, &cgen_var_802, 1);
- countingStream->write((uint64_t*)&cgen_var_802, 8);
+ uint64_t cgen_var_806;
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchain, &cgen_var_806, 1);
+ countingStream->write((uint64_t*)&cgen_var_806, 8);
}
uint32_t packetSize_vkCreateSwapchainKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateSwapchainKHR = OP_vkCreateSwapchainKHR;
stream->write(&opcode_vkCreateSwapchainKHR, sizeof(uint32_t));
stream->write(&packetSize_vkCreateSwapchainKHR, sizeof(uint32_t));
- uint64_t cgen_var_803;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_803, 1);
- stream->write((uint64_t*)&cgen_var_803, 1 * 8);
+ uint64_t cgen_var_807;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_807, 1);
+ stream->write((uint64_t*)&cgen_var_807, 1 * 8);
marshal_VkSwapchainCreateInfoKHR(stream, (VkSwapchainCreateInfoKHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_804 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_804);
+ uint64_t cgen_var_808 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_808);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_805;
- stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchain, &cgen_var_805, 1);
- stream->write((uint64_t*)&cgen_var_805, 8);
+ uint64_t cgen_var_809;
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchain, &cgen_var_809, 1);
+ stream->write((uint64_t*)&cgen_var_809, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateSwapchainKHR readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_806;
- stream->read((uint64_t*)&cgen_var_806, 8);
- stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_806, (VkSwapchainKHR*)pSwapchain, 1);
+ uint64_t cgen_var_810;
+ stream->read((uint64_t*)&cgen_var_810, 8);
+ stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_810, (VkSwapchainKHR*)pSwapchain, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateSwapchainKHR returnUnmarshal");
VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
@@ -11933,6 +12215,7 @@
VkSwapchainKHR swapchain,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroySwapchainKHR encode");
mImpl->log("start vkDestroySwapchainKHR");
auto stream = mImpl->stream();
@@ -11958,15 +12241,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_807;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_807, 1);
- countingStream->write((uint64_t*)&cgen_var_807, 1 * 8);
- uint64_t cgen_var_808;
- countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_808, 1);
- countingStream->write((uint64_t*)&cgen_var_808, 1 * 8);
+ uint64_t cgen_var_811;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_811, 1);
+ countingStream->write((uint64_t*)&cgen_var_811, 1 * 8);
+ uint64_t cgen_var_812;
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_812, 1);
+ countingStream->write((uint64_t*)&cgen_var_812, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_809 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_809);
+ uint64_t cgen_var_813 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_813);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -11977,15 +12260,15 @@
uint32_t opcode_vkDestroySwapchainKHR = OP_vkDestroySwapchainKHR;
stream->write(&opcode_vkDestroySwapchainKHR, sizeof(uint32_t));
stream->write(&packetSize_vkDestroySwapchainKHR, sizeof(uint32_t));
- uint64_t cgen_var_810;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_810, 1);
- stream->write((uint64_t*)&cgen_var_810, 1 * 8);
- uint64_t cgen_var_811;
- stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_811, 1);
- stream->write((uint64_t*)&cgen_var_811, 1 * 8);
+ uint64_t cgen_var_814;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_814, 1);
+ stream->write((uint64_t*)&cgen_var_814, 1 * 8);
+ uint64_t cgen_var_815;
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_815, 1);
+ stream->write((uint64_t*)&cgen_var_815, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_812 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_812);
+ uint64_t cgen_var_816 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_816);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -12002,6 +12285,7 @@
uint32_t* pSwapchainImageCount,
VkImage* pSwapchainImages)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetSwapchainImagesKHR encode");
mImpl->log("start vkGetSwapchainImagesKHR");
auto stream = mImpl->stream();
@@ -12015,30 +12299,30 @@
local_swapchain = swapchain;
countingStream->rewind();
{
- uint64_t cgen_var_813;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_813, 1);
- countingStream->write((uint64_t*)&cgen_var_813, 1 * 8);
- uint64_t cgen_var_814;
- countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_814, 1);
- countingStream->write((uint64_t*)&cgen_var_814, 1 * 8);
+ uint64_t cgen_var_817;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_817, 1);
+ countingStream->write((uint64_t*)&cgen_var_817, 1 * 8);
+ uint64_t cgen_var_818;
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_818, 1);
+ countingStream->write((uint64_t*)&cgen_var_818, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_815 = (uint64_t)(uintptr_t)pSwapchainImageCount;
- countingStream->putBe64(cgen_var_815);
+ uint64_t cgen_var_819 = (uint64_t)(uintptr_t)pSwapchainImageCount;
+ countingStream->putBe64(cgen_var_819);
if (pSwapchainImageCount)
{
countingStream->write((uint32_t*)pSwapchainImageCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_816 = (uint64_t)(uintptr_t)pSwapchainImages;
- countingStream->putBe64(cgen_var_816);
+ uint64_t cgen_var_820 = (uint64_t)(uintptr_t)pSwapchainImages;
+ countingStream->putBe64(cgen_var_820);
if (pSwapchainImages)
{
if ((*(pSwapchainImageCount)))
{
- uint64_t* cgen_var_817;
- countingStream->alloc((void**)&cgen_var_817, (*(pSwapchainImageCount)) * 8);
- countingStream->handleMapping()->mapHandles_VkImage_u64(pSwapchainImages, cgen_var_817, (*(pSwapchainImageCount)));
- countingStream->write((uint64_t*)cgen_var_817, (*(pSwapchainImageCount)) * 8);
+ uint64_t* cgen_var_821;
+ countingStream->alloc((void**)&cgen_var_821, (*(pSwapchainImageCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkImage_u64(pSwapchainImages, cgen_var_821, (*(pSwapchainImageCount)));
+ countingStream->write((uint64_t*)cgen_var_821, (*(pSwapchainImageCount)) * 8);
}
}
}
@@ -12047,31 +12331,31 @@
uint32_t opcode_vkGetSwapchainImagesKHR = OP_vkGetSwapchainImagesKHR;
stream->write(&opcode_vkGetSwapchainImagesKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetSwapchainImagesKHR, sizeof(uint32_t));
- uint64_t cgen_var_818;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_818, 1);
- stream->write((uint64_t*)&cgen_var_818, 1 * 8);
- uint64_t cgen_var_819;
- stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_819, 1);
- stream->write((uint64_t*)&cgen_var_819, 1 * 8);
+ uint64_t cgen_var_822;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_822, 1);
+ stream->write((uint64_t*)&cgen_var_822, 1 * 8);
+ uint64_t cgen_var_823;
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_823, 1);
+ stream->write((uint64_t*)&cgen_var_823, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_820 = (uint64_t)(uintptr_t)pSwapchainImageCount;
- stream->putBe64(cgen_var_820);
+ uint64_t cgen_var_824 = (uint64_t)(uintptr_t)pSwapchainImageCount;
+ stream->putBe64(cgen_var_824);
if (pSwapchainImageCount)
{
stream->write((uint32_t*)pSwapchainImageCount, sizeof(uint32_t));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
// WARNING PTR CHECK
- uint64_t cgen_var_821 = (uint64_t)(uintptr_t)pSwapchainImages;
- stream->putBe64(cgen_var_821);
+ uint64_t cgen_var_825 = (uint64_t)(uintptr_t)pSwapchainImages;
+ stream->putBe64(cgen_var_825);
if (pSwapchainImages)
{
if ((*(pSwapchainImageCount)))
{
- uint64_t* cgen_var_822;
- stream->alloc((void**)&cgen_var_822, (*(pSwapchainImageCount)) * 8);
- stream->handleMapping()->mapHandles_VkImage_u64(pSwapchainImages, cgen_var_822, (*(pSwapchainImageCount)));
- stream->write((uint64_t*)cgen_var_822, (*(pSwapchainImageCount)) * 8);
+ uint64_t* cgen_var_826;
+ stream->alloc((void**)&cgen_var_826, (*(pSwapchainImageCount)) * 8);
+ stream->handleMapping()->mapHandles_VkImage_u64(pSwapchainImages, cgen_var_826, (*(pSwapchainImageCount)));
+ stream->write((uint64_t*)cgen_var_826, (*(pSwapchainImageCount)) * 8);
}
}
stream->setHandleMapping(resources->unwrapMapping());
@@ -12098,10 +12382,10 @@
}
if ((*(pSwapchainImageCount)))
{
- uint64_t* cgen_var_825;
- stream->alloc((void**)&cgen_var_825, (*(pSwapchainImageCount)) * 8);
- stream->read((uint64_t*)cgen_var_825, (*(pSwapchainImageCount)) * 8);
- stream->handleMapping()->mapHandles_u64_VkImage(cgen_var_825, (VkImage*)pSwapchainImages, (*(pSwapchainImageCount)));
+ uint64_t* cgen_var_829;
+ stream->alloc((void**)&cgen_var_829, (*(pSwapchainImageCount)) * 8);
+ stream->read((uint64_t*)cgen_var_829, (*(pSwapchainImageCount)) * 8);
+ stream->handleMapping()->mapHandles_u64_VkImage(cgen_var_829, (VkImage*)pSwapchainImages, (*(pSwapchainImageCount)));
}
}
AEMU_SCOPED_TRACE("vkGetSwapchainImagesKHR returnUnmarshal");
@@ -12122,6 +12406,7 @@
VkFence fence,
uint32_t* pImageIndex)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkAcquireNextImageKHR encode");
mImpl->log("start vkAcquireNextImageKHR");
auto stream = mImpl->stream();
@@ -12141,19 +12426,19 @@
local_fence = fence;
countingStream->rewind();
{
- uint64_t cgen_var_826;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_826, 1);
- countingStream->write((uint64_t*)&cgen_var_826, 1 * 8);
- uint64_t cgen_var_827;
- countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_827, 1);
- countingStream->write((uint64_t*)&cgen_var_827, 1 * 8);
+ uint64_t cgen_var_830;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_830, 1);
+ countingStream->write((uint64_t*)&cgen_var_830, 1 * 8);
+ uint64_t cgen_var_831;
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_831, 1);
+ countingStream->write((uint64_t*)&cgen_var_831, 1 * 8);
countingStream->write((uint64_t*)&local_timeout, sizeof(uint64_t));
- uint64_t cgen_var_828;
- countingStream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_828, 1);
- countingStream->write((uint64_t*)&cgen_var_828, 1 * 8);
- uint64_t cgen_var_829;
- countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_829, 1);
- countingStream->write((uint64_t*)&cgen_var_829, 1 * 8);
+ uint64_t cgen_var_832;
+ countingStream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_832, 1);
+ countingStream->write((uint64_t*)&cgen_var_832, 1 * 8);
+ uint64_t cgen_var_833;
+ countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_833, 1);
+ countingStream->write((uint64_t*)&cgen_var_833, 1 * 8);
countingStream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
}
uint32_t packetSize_vkAcquireNextImageKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -12161,19 +12446,19 @@
uint32_t opcode_vkAcquireNextImageKHR = OP_vkAcquireNextImageKHR;
stream->write(&opcode_vkAcquireNextImageKHR, sizeof(uint32_t));
stream->write(&packetSize_vkAcquireNextImageKHR, sizeof(uint32_t));
- uint64_t cgen_var_830;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_830, 1);
- stream->write((uint64_t*)&cgen_var_830, 1 * 8);
- uint64_t cgen_var_831;
- stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_831, 1);
- stream->write((uint64_t*)&cgen_var_831, 1 * 8);
+ uint64_t cgen_var_834;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_834, 1);
+ stream->write((uint64_t*)&cgen_var_834, 1 * 8);
+ uint64_t cgen_var_835;
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_835, 1);
+ stream->write((uint64_t*)&cgen_var_835, 1 * 8);
stream->write((uint64_t*)&local_timeout, sizeof(uint64_t));
- uint64_t cgen_var_832;
- stream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_832, 1);
- stream->write((uint64_t*)&cgen_var_832, 1 * 8);
- uint64_t cgen_var_833;
- stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_833, 1);
- stream->write((uint64_t*)&cgen_var_833, 1 * 8);
+ uint64_t cgen_var_836;
+ stream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_836, 1);
+ stream->write((uint64_t*)&cgen_var_836, 1 * 8);
+ uint64_t cgen_var_837;
+ stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_837, 1);
+ stream->write((uint64_t*)&cgen_var_837, 1 * 8);
stream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
AEMU_SCOPED_TRACE("vkAcquireNextImageKHR readParams");
stream->read((uint32_t*)pImageIndex, sizeof(uint32_t));
@@ -12191,6 +12476,7 @@
VkQueue queue,
const VkPresentInfoKHR* pPresentInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkQueuePresentKHR encode");
mImpl->log("start vkQueuePresentKHR");
auto stream = mImpl->stream();
@@ -12213,9 +12499,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_834;
- countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_834, 1);
- countingStream->write((uint64_t*)&cgen_var_834, 1 * 8);
+ uint64_t cgen_var_838;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_838, 1);
+ countingStream->write((uint64_t*)&cgen_var_838, 1 * 8);
marshal_VkPresentInfoKHR(countingStream, (VkPresentInfoKHR*)(local_pPresentInfo));
}
uint32_t packetSize_vkQueuePresentKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -12223,9 +12509,9 @@
uint32_t opcode_vkQueuePresentKHR = OP_vkQueuePresentKHR;
stream->write(&opcode_vkQueuePresentKHR, sizeof(uint32_t));
stream->write(&packetSize_vkQueuePresentKHR, sizeof(uint32_t));
- uint64_t cgen_var_835;
- stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_835, 1);
- stream->write((uint64_t*)&cgen_var_835, 1 * 8);
+ uint64_t cgen_var_839;
+ stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_839, 1);
+ stream->write((uint64_t*)&cgen_var_839, 1 * 8);
marshal_VkPresentInfoKHR(stream, (VkPresentInfoKHR*)(local_pPresentInfo));
AEMU_SCOPED_TRACE("vkQueuePresentKHR readParams");
AEMU_SCOPED_TRACE("vkQueuePresentKHR returnUnmarshal");
@@ -12242,6 +12528,7 @@
VkDevice device,
VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetDeviceGroupPresentCapabilitiesKHR encode");
mImpl->log("start vkGetDeviceGroupPresentCapabilitiesKHR");
auto stream = mImpl->stream();
@@ -12253,9 +12540,9 @@
local_device = device;
countingStream->rewind();
{
- uint64_t cgen_var_836;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_836, 1);
- countingStream->write((uint64_t*)&cgen_var_836, 1 * 8);
+ uint64_t cgen_var_840;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_840, 1);
+ countingStream->write((uint64_t*)&cgen_var_840, 1 * 8);
marshal_VkDeviceGroupPresentCapabilitiesKHR(countingStream, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
}
uint32_t packetSize_vkGetDeviceGroupPresentCapabilitiesKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -12263,9 +12550,9 @@
uint32_t opcode_vkGetDeviceGroupPresentCapabilitiesKHR = OP_vkGetDeviceGroupPresentCapabilitiesKHR;
stream->write(&opcode_vkGetDeviceGroupPresentCapabilitiesKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetDeviceGroupPresentCapabilitiesKHR, sizeof(uint32_t));
- uint64_t cgen_var_837;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_837, 1);
- stream->write((uint64_t*)&cgen_var_837, 1 * 8);
+ uint64_t cgen_var_841;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_841, 1);
+ stream->write((uint64_t*)&cgen_var_841, 1 * 8);
marshal_VkDeviceGroupPresentCapabilitiesKHR(stream, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
AEMU_SCOPED_TRACE("vkGetDeviceGroupPresentCapabilitiesKHR readParams");
unmarshal_VkDeviceGroupPresentCapabilitiesKHR(stream, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
@@ -12288,6 +12575,7 @@
VkSurfaceKHR surface,
VkDeviceGroupPresentModeFlagsKHR* pModes)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModesKHR encode");
mImpl->log("start vkGetDeviceGroupSurfacePresentModesKHR");
auto stream = mImpl->stream();
@@ -12301,15 +12589,15 @@
local_surface = surface;
countingStream->rewind();
{
- uint64_t cgen_var_838;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_838, 1);
- countingStream->write((uint64_t*)&cgen_var_838, 1 * 8);
- uint64_t cgen_var_839;
- countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_839, 1);
- countingStream->write((uint64_t*)&cgen_var_839, 1 * 8);
+ uint64_t cgen_var_842;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_842, 1);
+ countingStream->write((uint64_t*)&cgen_var_842, 1 * 8);
+ uint64_t cgen_var_843;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_843, 1);
+ countingStream->write((uint64_t*)&cgen_var_843, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_840 = (uint64_t)(uintptr_t)pModes;
- countingStream->putBe64(cgen_var_840);
+ uint64_t cgen_var_844 = (uint64_t)(uintptr_t)pModes;
+ countingStream->putBe64(cgen_var_844);
if (pModes)
{
countingStream->write((VkDeviceGroupPresentModeFlagsKHR*)pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
@@ -12320,15 +12608,15 @@
uint32_t opcode_vkGetDeviceGroupSurfacePresentModesKHR = OP_vkGetDeviceGroupSurfacePresentModesKHR;
stream->write(&opcode_vkGetDeviceGroupSurfacePresentModesKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetDeviceGroupSurfacePresentModesKHR, sizeof(uint32_t));
- uint64_t cgen_var_841;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_841, 1);
- stream->write((uint64_t*)&cgen_var_841, 1 * 8);
- uint64_t cgen_var_842;
- stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_842, 1);
- stream->write((uint64_t*)&cgen_var_842, 1 * 8);
+ uint64_t cgen_var_845;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_845, 1);
+ stream->write((uint64_t*)&cgen_var_845, 1 * 8);
+ uint64_t cgen_var_846;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_846, 1);
+ stream->write((uint64_t*)&cgen_var_846, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_843 = (uint64_t)(uintptr_t)pModes;
- stream->putBe64(cgen_var_843);
+ uint64_t cgen_var_847 = (uint64_t)(uintptr_t)pModes;
+ stream->putBe64(cgen_var_847);
if (pModes)
{
stream->write((VkDeviceGroupPresentModeFlagsKHR*)pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
@@ -12361,6 +12649,7 @@
uint32_t* pRectCount,
VkRect2D* pRects)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDevicePresentRectanglesKHR encode");
mImpl->log("start vkGetPhysicalDevicePresentRectanglesKHR");
auto stream = mImpl->stream();
@@ -12374,22 +12663,22 @@
local_surface = surface;
countingStream->rewind();
{
- uint64_t cgen_var_845;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_845, 1);
- countingStream->write((uint64_t*)&cgen_var_845, 1 * 8);
- uint64_t cgen_var_846;
- countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_846, 1);
- countingStream->write((uint64_t*)&cgen_var_846, 1 * 8);
+ uint64_t cgen_var_849;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_849, 1);
+ countingStream->write((uint64_t*)&cgen_var_849, 1 * 8);
+ uint64_t cgen_var_850;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_850, 1);
+ countingStream->write((uint64_t*)&cgen_var_850, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_847 = (uint64_t)(uintptr_t)pRectCount;
- countingStream->putBe64(cgen_var_847);
+ uint64_t cgen_var_851 = (uint64_t)(uintptr_t)pRectCount;
+ countingStream->putBe64(cgen_var_851);
if (pRectCount)
{
countingStream->write((uint32_t*)pRectCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_848 = (uint64_t)(uintptr_t)pRects;
- countingStream->putBe64(cgen_var_848);
+ uint64_t cgen_var_852 = (uint64_t)(uintptr_t)pRects;
+ countingStream->putBe64(cgen_var_852);
if (pRects)
{
for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i)
@@ -12403,22 +12692,22 @@
uint32_t opcode_vkGetPhysicalDevicePresentRectanglesKHR = OP_vkGetPhysicalDevicePresentRectanglesKHR;
stream->write(&opcode_vkGetPhysicalDevicePresentRectanglesKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDevicePresentRectanglesKHR, sizeof(uint32_t));
- uint64_t cgen_var_849;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_849, 1);
- stream->write((uint64_t*)&cgen_var_849, 1 * 8);
- uint64_t cgen_var_850;
- stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_850, 1);
- stream->write((uint64_t*)&cgen_var_850, 1 * 8);
+ uint64_t cgen_var_853;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_853, 1);
+ stream->write((uint64_t*)&cgen_var_853, 1 * 8);
+ uint64_t cgen_var_854;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_854, 1);
+ stream->write((uint64_t*)&cgen_var_854, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_851 = (uint64_t)(uintptr_t)pRectCount;
- stream->putBe64(cgen_var_851);
+ uint64_t cgen_var_855 = (uint64_t)(uintptr_t)pRectCount;
+ stream->putBe64(cgen_var_855);
if (pRectCount)
{
stream->write((uint32_t*)pRectCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_852 = (uint64_t)(uintptr_t)pRects;
- stream->putBe64(cgen_var_852);
+ uint64_t cgen_var_856 = (uint64_t)(uintptr_t)pRects;
+ stream->putBe64(cgen_var_856);
if (pRects)
{
for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i)
@@ -12474,6 +12763,7 @@
const VkAcquireNextImageInfoKHR* pAcquireInfo,
uint32_t* pImageIndex)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkAcquireNextImage2KHR encode");
mImpl->log("start vkAcquireNextImage2KHR");
auto stream = mImpl->stream();
@@ -12496,9 +12786,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_855;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_855, 1);
- countingStream->write((uint64_t*)&cgen_var_855, 1 * 8);
+ uint64_t cgen_var_859;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_859, 1);
+ countingStream->write((uint64_t*)&cgen_var_859, 1 * 8);
marshal_VkAcquireNextImageInfoKHR(countingStream, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo));
countingStream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
}
@@ -12507,9 +12797,9 @@
uint32_t opcode_vkAcquireNextImage2KHR = OP_vkAcquireNextImage2KHR;
stream->write(&opcode_vkAcquireNextImage2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkAcquireNextImage2KHR, sizeof(uint32_t));
- uint64_t cgen_var_856;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_856, 1);
- stream->write((uint64_t*)&cgen_var_856, 1 * 8);
+ uint64_t cgen_var_860;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_860, 1);
+ stream->write((uint64_t*)&cgen_var_860, 1 * 8);
marshal_VkAcquireNextImageInfoKHR(stream, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo));
stream->write((uint32_t*)pImageIndex, sizeof(uint32_t));
AEMU_SCOPED_TRACE("vkAcquireNextImage2KHR readParams");
@@ -12531,6 +12821,7 @@
uint32_t* pPropertyCount,
VkDisplayPropertiesKHR* pProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPropertiesKHR encode");
mImpl->log("start vkGetPhysicalDeviceDisplayPropertiesKHR");
auto stream = mImpl->stream();
@@ -12542,19 +12833,19 @@
local_physicalDevice = physicalDevice;
countingStream->rewind();
{
- uint64_t cgen_var_857;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_857, 1);
- countingStream->write((uint64_t*)&cgen_var_857, 1 * 8);
+ uint64_t cgen_var_861;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_861, 1);
+ countingStream->write((uint64_t*)&cgen_var_861, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_858 = (uint64_t)(uintptr_t)pPropertyCount;
- countingStream->putBe64(cgen_var_858);
+ uint64_t cgen_var_862 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_862);
if (pPropertyCount)
{
countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_859 = (uint64_t)(uintptr_t)pProperties;
- countingStream->putBe64(cgen_var_859);
+ uint64_t cgen_var_863 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_863);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -12568,19 +12859,19 @@
uint32_t opcode_vkGetPhysicalDeviceDisplayPropertiesKHR = OP_vkGetPhysicalDeviceDisplayPropertiesKHR;
stream->write(&opcode_vkGetPhysicalDeviceDisplayPropertiesKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceDisplayPropertiesKHR, sizeof(uint32_t));
- uint64_t cgen_var_860;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_860, 1);
- stream->write((uint64_t*)&cgen_var_860, 1 * 8);
+ uint64_t cgen_var_864;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_864, 1);
+ stream->write((uint64_t*)&cgen_var_864, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_861 = (uint64_t)(uintptr_t)pPropertyCount;
- stream->putBe64(cgen_var_861);
+ uint64_t cgen_var_865 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_865);
if (pPropertyCount)
{
stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_862 = (uint64_t)(uintptr_t)pProperties;
- stream->putBe64(cgen_var_862);
+ uint64_t cgen_var_866 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_866);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -12636,6 +12927,7 @@
uint32_t* pPropertyCount,
VkDisplayPlanePropertiesKHR* pProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlanePropertiesKHR encode");
mImpl->log("start vkGetPhysicalDeviceDisplayPlanePropertiesKHR");
auto stream = mImpl->stream();
@@ -12647,19 +12939,19 @@
local_physicalDevice = physicalDevice;
countingStream->rewind();
{
- uint64_t cgen_var_865;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_865, 1);
- countingStream->write((uint64_t*)&cgen_var_865, 1 * 8);
+ uint64_t cgen_var_869;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_869, 1);
+ countingStream->write((uint64_t*)&cgen_var_869, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_866 = (uint64_t)(uintptr_t)pPropertyCount;
- countingStream->putBe64(cgen_var_866);
+ uint64_t cgen_var_870 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_870);
if (pPropertyCount)
{
countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_867 = (uint64_t)(uintptr_t)pProperties;
- countingStream->putBe64(cgen_var_867);
+ uint64_t cgen_var_871 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_871);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -12673,19 +12965,19 @@
uint32_t opcode_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = OP_vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
stream->write(&opcode_vkGetPhysicalDeviceDisplayPlanePropertiesKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceDisplayPlanePropertiesKHR, sizeof(uint32_t));
- uint64_t cgen_var_868;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_868, 1);
- stream->write((uint64_t*)&cgen_var_868, 1 * 8);
+ uint64_t cgen_var_872;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_872, 1);
+ stream->write((uint64_t*)&cgen_var_872, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_869 = (uint64_t)(uintptr_t)pPropertyCount;
- stream->putBe64(cgen_var_869);
+ uint64_t cgen_var_873 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_873);
if (pPropertyCount)
{
stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_870 = (uint64_t)(uintptr_t)pProperties;
- stream->putBe64(cgen_var_870);
+ uint64_t cgen_var_874 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_874);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -12742,6 +13034,7 @@
uint32_t* pDisplayCount,
VkDisplayKHR* pDisplays)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetDisplayPlaneSupportedDisplaysKHR encode");
mImpl->log("start vkGetDisplayPlaneSupportedDisplaysKHR");
auto stream = mImpl->stream();
@@ -12755,28 +13048,28 @@
local_planeIndex = planeIndex;
countingStream->rewind();
{
- uint64_t cgen_var_873;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_873, 1);
- countingStream->write((uint64_t*)&cgen_var_873, 1 * 8);
+ uint64_t cgen_var_877;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_877, 1);
+ countingStream->write((uint64_t*)&cgen_var_877, 1 * 8);
countingStream->write((uint32_t*)&local_planeIndex, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_874 = (uint64_t)(uintptr_t)pDisplayCount;
- countingStream->putBe64(cgen_var_874);
+ uint64_t cgen_var_878 = (uint64_t)(uintptr_t)pDisplayCount;
+ countingStream->putBe64(cgen_var_878);
if (pDisplayCount)
{
countingStream->write((uint32_t*)pDisplayCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_875 = (uint64_t)(uintptr_t)pDisplays;
- countingStream->putBe64(cgen_var_875);
+ uint64_t cgen_var_879 = (uint64_t)(uintptr_t)pDisplays;
+ countingStream->putBe64(cgen_var_879);
if (pDisplays)
{
if ((*(pDisplayCount)))
{
- uint64_t* cgen_var_876;
- countingStream->alloc((void**)&cgen_var_876, (*(pDisplayCount)) * 8);
- countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplays, cgen_var_876, (*(pDisplayCount)));
- countingStream->write((uint64_t*)cgen_var_876, (*(pDisplayCount)) * 8);
+ uint64_t* cgen_var_880;
+ countingStream->alloc((void**)&cgen_var_880, (*(pDisplayCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplays, cgen_var_880, (*(pDisplayCount)));
+ countingStream->write((uint64_t*)cgen_var_880, (*(pDisplayCount)) * 8);
}
}
}
@@ -12785,29 +13078,29 @@
uint32_t opcode_vkGetDisplayPlaneSupportedDisplaysKHR = OP_vkGetDisplayPlaneSupportedDisplaysKHR;
stream->write(&opcode_vkGetDisplayPlaneSupportedDisplaysKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetDisplayPlaneSupportedDisplaysKHR, sizeof(uint32_t));
- uint64_t cgen_var_877;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_877, 1);
- stream->write((uint64_t*)&cgen_var_877, 1 * 8);
+ uint64_t cgen_var_881;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_881, 1);
+ stream->write((uint64_t*)&cgen_var_881, 1 * 8);
stream->write((uint32_t*)&local_planeIndex, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_878 = (uint64_t)(uintptr_t)pDisplayCount;
- stream->putBe64(cgen_var_878);
+ uint64_t cgen_var_882 = (uint64_t)(uintptr_t)pDisplayCount;
+ stream->putBe64(cgen_var_882);
if (pDisplayCount)
{
stream->write((uint32_t*)pDisplayCount, sizeof(uint32_t));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
// WARNING PTR CHECK
- uint64_t cgen_var_879 = (uint64_t)(uintptr_t)pDisplays;
- stream->putBe64(cgen_var_879);
+ uint64_t cgen_var_883 = (uint64_t)(uintptr_t)pDisplays;
+ stream->putBe64(cgen_var_883);
if (pDisplays)
{
if ((*(pDisplayCount)))
{
- uint64_t* cgen_var_880;
- stream->alloc((void**)&cgen_var_880, (*(pDisplayCount)) * 8);
- stream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplays, cgen_var_880, (*(pDisplayCount)));
- stream->write((uint64_t*)cgen_var_880, (*(pDisplayCount)) * 8);
+ uint64_t* cgen_var_884;
+ stream->alloc((void**)&cgen_var_884, (*(pDisplayCount)) * 8);
+ stream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplays, cgen_var_884, (*(pDisplayCount)));
+ stream->write((uint64_t*)cgen_var_884, (*(pDisplayCount)) * 8);
}
}
stream->setHandleMapping(resources->unwrapMapping());
@@ -12834,10 +13127,10 @@
}
if ((*(pDisplayCount)))
{
- uint64_t* cgen_var_883;
- stream->alloc((void**)&cgen_var_883, (*(pDisplayCount)) * 8);
- stream->read((uint64_t*)cgen_var_883, (*(pDisplayCount)) * 8);
- stream->handleMapping()->mapHandles_u64_VkDisplayKHR(cgen_var_883, (VkDisplayKHR*)pDisplays, (*(pDisplayCount)));
+ uint64_t* cgen_var_887;
+ stream->alloc((void**)&cgen_var_887, (*(pDisplayCount)) * 8);
+ stream->read((uint64_t*)cgen_var_887, (*(pDisplayCount)) * 8);
+ stream->handleMapping()->mapHandles_u64_VkDisplayKHR(cgen_var_887, (VkDisplayKHR*)pDisplays, (*(pDisplayCount)));
}
}
AEMU_SCOPED_TRACE("vkGetDisplayPlaneSupportedDisplaysKHR returnUnmarshal");
@@ -12856,6 +13149,7 @@
uint32_t* pPropertyCount,
VkDisplayModePropertiesKHR* pProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetDisplayModePropertiesKHR encode");
mImpl->log("start vkGetDisplayModePropertiesKHR");
auto stream = mImpl->stream();
@@ -12869,22 +13163,22 @@
local_display = display;
countingStream->rewind();
{
- uint64_t cgen_var_884;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_884, 1);
- countingStream->write((uint64_t*)&cgen_var_884, 1 * 8);
- uint64_t cgen_var_885;
- countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_885, 1);
- countingStream->write((uint64_t*)&cgen_var_885, 1 * 8);
+ uint64_t cgen_var_888;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_888, 1);
+ countingStream->write((uint64_t*)&cgen_var_888, 1 * 8);
+ uint64_t cgen_var_889;
+ countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_889, 1);
+ countingStream->write((uint64_t*)&cgen_var_889, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_886 = (uint64_t)(uintptr_t)pPropertyCount;
- countingStream->putBe64(cgen_var_886);
+ uint64_t cgen_var_890 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_890);
if (pPropertyCount)
{
countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_887 = (uint64_t)(uintptr_t)pProperties;
- countingStream->putBe64(cgen_var_887);
+ uint64_t cgen_var_891 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_891);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -12898,22 +13192,22 @@
uint32_t opcode_vkGetDisplayModePropertiesKHR = OP_vkGetDisplayModePropertiesKHR;
stream->write(&opcode_vkGetDisplayModePropertiesKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetDisplayModePropertiesKHR, sizeof(uint32_t));
- uint64_t cgen_var_888;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_888, 1);
- stream->write((uint64_t*)&cgen_var_888, 1 * 8);
- uint64_t cgen_var_889;
- stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_889, 1);
- stream->write((uint64_t*)&cgen_var_889, 1 * 8);
+ uint64_t cgen_var_892;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_892, 1);
+ stream->write((uint64_t*)&cgen_var_892, 1 * 8);
+ uint64_t cgen_var_893;
+ stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_893, 1);
+ stream->write((uint64_t*)&cgen_var_893, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_890 = (uint64_t)(uintptr_t)pPropertyCount;
- stream->putBe64(cgen_var_890);
+ uint64_t cgen_var_894 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_894);
if (pPropertyCount)
{
stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_891 = (uint64_t)(uintptr_t)pProperties;
- stream->putBe64(cgen_var_891);
+ uint64_t cgen_var_895 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_895);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -12971,6 +13265,7 @@
const VkAllocationCallbacks* pAllocator,
VkDisplayModeKHR* pMode)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateDisplayModeKHR encode");
mImpl->log("start vkCreateDisplayModeKHR");
auto stream = mImpl->stream();
@@ -13007,53 +13302,53 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_894;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_894, 1);
- countingStream->write((uint64_t*)&cgen_var_894, 1 * 8);
- uint64_t cgen_var_895;
- countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_895, 1);
- countingStream->write((uint64_t*)&cgen_var_895, 1 * 8);
+ uint64_t cgen_var_898;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_898, 1);
+ countingStream->write((uint64_t*)&cgen_var_898, 1 * 8);
+ uint64_t cgen_var_899;
+ countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_899, 1);
+ countingStream->write((uint64_t*)&cgen_var_899, 1 * 8);
marshal_VkDisplayModeCreateInfoKHR(countingStream, (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_896 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_896);
+ uint64_t cgen_var_900 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_900);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_897;
- countingStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(pMode, &cgen_var_897, 1);
- countingStream->write((uint64_t*)&cgen_var_897, 8);
+ uint64_t cgen_var_901;
+ countingStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(pMode, &cgen_var_901, 1);
+ countingStream->write((uint64_t*)&cgen_var_901, 8);
}
uint32_t packetSize_vkCreateDisplayModeKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateDisplayModeKHR = OP_vkCreateDisplayModeKHR;
stream->write(&opcode_vkCreateDisplayModeKHR, sizeof(uint32_t));
stream->write(&packetSize_vkCreateDisplayModeKHR, sizeof(uint32_t));
- uint64_t cgen_var_898;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_898, 1);
- stream->write((uint64_t*)&cgen_var_898, 1 * 8);
- uint64_t cgen_var_899;
- stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_899, 1);
- stream->write((uint64_t*)&cgen_var_899, 1 * 8);
+ uint64_t cgen_var_902;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_902, 1);
+ stream->write((uint64_t*)&cgen_var_902, 1 * 8);
+ uint64_t cgen_var_903;
+ stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_903, 1);
+ stream->write((uint64_t*)&cgen_var_903, 1 * 8);
marshal_VkDisplayModeCreateInfoKHR(stream, (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_900 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_900);
+ uint64_t cgen_var_904 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_904);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_901;
- stream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(pMode, &cgen_var_901, 1);
- stream->write((uint64_t*)&cgen_var_901, 8);
+ uint64_t cgen_var_905;
+ stream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(pMode, &cgen_var_905, 1);
+ stream->write((uint64_t*)&cgen_var_905, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateDisplayModeKHR readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_902;
- stream->read((uint64_t*)&cgen_var_902, 8);
- stream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_902, (VkDisplayModeKHR*)pMode, 1);
+ uint64_t cgen_var_906;
+ stream->read((uint64_t*)&cgen_var_906, 8);
+ stream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_906, (VkDisplayModeKHR*)pMode, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateDisplayModeKHR returnUnmarshal");
VkResult vkCreateDisplayModeKHR_VkResult_return = (VkResult)0;
@@ -13071,6 +13366,7 @@
uint32_t planeIndex,
VkDisplayPlaneCapabilitiesKHR* pCapabilities)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilitiesKHR encode");
mImpl->log("start vkGetDisplayPlaneCapabilitiesKHR");
auto stream = mImpl->stream();
@@ -13086,12 +13382,12 @@
local_planeIndex = planeIndex;
countingStream->rewind();
{
- uint64_t cgen_var_903;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_903, 1);
- countingStream->write((uint64_t*)&cgen_var_903, 1 * 8);
- uint64_t cgen_var_904;
- countingStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&local_mode, &cgen_var_904, 1);
- countingStream->write((uint64_t*)&cgen_var_904, 1 * 8);
+ uint64_t cgen_var_907;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_907, 1);
+ countingStream->write((uint64_t*)&cgen_var_907, 1 * 8);
+ uint64_t cgen_var_908;
+ countingStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&local_mode, &cgen_var_908, 1);
+ countingStream->write((uint64_t*)&cgen_var_908, 1 * 8);
countingStream->write((uint32_t*)&local_planeIndex, sizeof(uint32_t));
marshal_VkDisplayPlaneCapabilitiesKHR(countingStream, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities));
}
@@ -13100,12 +13396,12 @@
uint32_t opcode_vkGetDisplayPlaneCapabilitiesKHR = OP_vkGetDisplayPlaneCapabilitiesKHR;
stream->write(&opcode_vkGetDisplayPlaneCapabilitiesKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetDisplayPlaneCapabilitiesKHR, sizeof(uint32_t));
- uint64_t cgen_var_905;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_905, 1);
- stream->write((uint64_t*)&cgen_var_905, 1 * 8);
- uint64_t cgen_var_906;
- stream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&local_mode, &cgen_var_906, 1);
- stream->write((uint64_t*)&cgen_var_906, 1 * 8);
+ uint64_t cgen_var_909;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_909, 1);
+ stream->write((uint64_t*)&cgen_var_909, 1 * 8);
+ uint64_t cgen_var_910;
+ stream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&local_mode, &cgen_var_910, 1);
+ stream->write((uint64_t*)&cgen_var_910, 1 * 8);
stream->write((uint32_t*)&local_planeIndex, sizeof(uint32_t));
marshal_VkDisplayPlaneCapabilitiesKHR(stream, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities));
AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilitiesKHR readParams");
@@ -13130,6 +13426,7 @@
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateDisplayPlaneSurfaceKHR encode");
mImpl->log("start vkCreateDisplayPlaneSurfaceKHR");
auto stream = mImpl->stream();
@@ -13164,46 +13461,46 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_907;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_907, 1);
- countingStream->write((uint64_t*)&cgen_var_907, 1 * 8);
+ uint64_t cgen_var_911;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_911, 1);
+ countingStream->write((uint64_t*)&cgen_var_911, 1 * 8);
marshal_VkDisplaySurfaceCreateInfoKHR(countingStream, (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_908 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_908);
+ uint64_t cgen_var_912 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_912);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_909;
- countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_909, 1);
- countingStream->write((uint64_t*)&cgen_var_909, 8);
+ uint64_t cgen_var_913;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_913, 1);
+ countingStream->write((uint64_t*)&cgen_var_913, 8);
}
uint32_t packetSize_vkCreateDisplayPlaneSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateDisplayPlaneSurfaceKHR = OP_vkCreateDisplayPlaneSurfaceKHR;
stream->write(&opcode_vkCreateDisplayPlaneSurfaceKHR, sizeof(uint32_t));
stream->write(&packetSize_vkCreateDisplayPlaneSurfaceKHR, sizeof(uint32_t));
- uint64_t cgen_var_910;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_910, 1);
- stream->write((uint64_t*)&cgen_var_910, 1 * 8);
+ uint64_t cgen_var_914;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_914, 1);
+ stream->write((uint64_t*)&cgen_var_914, 1 * 8);
marshal_VkDisplaySurfaceCreateInfoKHR(stream, (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_911 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_911);
+ uint64_t cgen_var_915 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_915);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_912;
- stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_912, 1);
- stream->write((uint64_t*)&cgen_var_912, 8);
+ uint64_t cgen_var_916;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_916, 1);
+ stream->write((uint64_t*)&cgen_var_916, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateDisplayPlaneSurfaceKHR readParams");
- uint64_t cgen_var_913;
- stream->read((uint64_t*)&cgen_var_913, 8);
- stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_913, (VkSurfaceKHR*)pSurface, 1);
+ uint64_t cgen_var_917;
+ stream->read((uint64_t*)&cgen_var_917, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_917, (VkSurfaceKHR*)pSurface, 1);
AEMU_SCOPED_TRACE("vkCreateDisplayPlaneSurfaceKHR returnUnmarshal");
VkResult vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateDisplayPlaneSurfaceKHR_VkResult_return, sizeof(VkResult));
@@ -13223,6 +13520,7 @@
const VkAllocationCallbacks* pAllocator,
VkSwapchainKHR* pSwapchains)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateSharedSwapchainsKHR encode");
mImpl->log("start vkCreateSharedSwapchainsKHR");
auto stream = mImpl->stream();
@@ -13265,27 +13563,27 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_914;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_914, 1);
- countingStream->write((uint64_t*)&cgen_var_914, 1 * 8);
+ uint64_t cgen_var_918;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_918, 1);
+ countingStream->write((uint64_t*)&cgen_var_918, 1 * 8);
countingStream->write((uint32_t*)&local_swapchainCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
{
marshal_VkSwapchainCreateInfoKHR(countingStream, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i));
}
// WARNING PTR CHECK
- uint64_t cgen_var_915 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_915);
+ uint64_t cgen_var_919 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_919);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
if (((swapchainCount)))
{
- uint64_t* cgen_var_916;
- countingStream->alloc((void**)&cgen_var_916, ((swapchainCount)) * 8);
- countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchains, cgen_var_916, ((swapchainCount)));
- countingStream->write((uint64_t*)cgen_var_916, ((swapchainCount)) * 8);
+ uint64_t* cgen_var_920;
+ countingStream->alloc((void**)&cgen_var_920, ((swapchainCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchains, cgen_var_920, ((swapchainCount)));
+ countingStream->write((uint64_t*)cgen_var_920, ((swapchainCount)) * 8);
}
}
uint32_t packetSize_vkCreateSharedSwapchainsKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -13293,17 +13591,17 @@
uint32_t opcode_vkCreateSharedSwapchainsKHR = OP_vkCreateSharedSwapchainsKHR;
stream->write(&opcode_vkCreateSharedSwapchainsKHR, sizeof(uint32_t));
stream->write(&packetSize_vkCreateSharedSwapchainsKHR, sizeof(uint32_t));
- uint64_t cgen_var_917;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_917, 1);
- stream->write((uint64_t*)&cgen_var_917, 1 * 8);
+ uint64_t cgen_var_921;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_921, 1);
+ stream->write((uint64_t*)&cgen_var_921, 1 * 8);
stream->write((uint32_t*)&local_swapchainCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
{
marshal_VkSwapchainCreateInfoKHR(stream, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i));
}
// WARNING PTR CHECK
- uint64_t cgen_var_918 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_918);
+ uint64_t cgen_var_922 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_922);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -13311,19 +13609,19 @@
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
if (((swapchainCount)))
{
- uint64_t* cgen_var_919;
- stream->alloc((void**)&cgen_var_919, ((swapchainCount)) * 8);
- stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchains, cgen_var_919, ((swapchainCount)));
- stream->write((uint64_t*)cgen_var_919, ((swapchainCount)) * 8);
+ uint64_t* cgen_var_923;
+ stream->alloc((void**)&cgen_var_923, ((swapchainCount)) * 8);
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchains, cgen_var_923, ((swapchainCount)));
+ stream->write((uint64_t*)cgen_var_923, ((swapchainCount)) * 8);
}
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateSharedSwapchainsKHR readParams");
if (((swapchainCount)))
{
- uint64_t* cgen_var_920;
- stream->alloc((void**)&cgen_var_920, ((swapchainCount)) * 8);
- stream->read((uint64_t*)cgen_var_920, ((swapchainCount)) * 8);
- stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(cgen_var_920, (VkSwapchainKHR*)pSwapchains, ((swapchainCount)));
+ uint64_t* cgen_var_924;
+ stream->alloc((void**)&cgen_var_924, ((swapchainCount)) * 8);
+ stream->read((uint64_t*)cgen_var_924, ((swapchainCount)) * 8);
+ stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(cgen_var_924, (VkSwapchainKHR*)pSwapchains, ((swapchainCount)));
}
AEMU_SCOPED_TRACE("vkCreateSharedSwapchainsKHR returnUnmarshal");
VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
@@ -13343,6 +13641,7 @@
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateXlibSurfaceKHR encode");
mImpl->log("start vkCreateXlibSurfaceKHR");
auto stream = mImpl->stream();
@@ -13377,46 +13676,46 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_921;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_921, 1);
- countingStream->write((uint64_t*)&cgen_var_921, 1 * 8);
+ uint64_t cgen_var_925;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_925, 1);
+ countingStream->write((uint64_t*)&cgen_var_925, 1 * 8);
marshal_VkXlibSurfaceCreateInfoKHR(countingStream, (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_922 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_922);
+ uint64_t cgen_var_926 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_926);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_923;
- countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_923, 1);
- countingStream->write((uint64_t*)&cgen_var_923, 8);
+ uint64_t cgen_var_927;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_927, 1);
+ countingStream->write((uint64_t*)&cgen_var_927, 8);
}
uint32_t packetSize_vkCreateXlibSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateXlibSurfaceKHR = OP_vkCreateXlibSurfaceKHR;
stream->write(&opcode_vkCreateXlibSurfaceKHR, sizeof(uint32_t));
stream->write(&packetSize_vkCreateXlibSurfaceKHR, sizeof(uint32_t));
- uint64_t cgen_var_924;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_924, 1);
- stream->write((uint64_t*)&cgen_var_924, 1 * 8);
+ uint64_t cgen_var_928;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_928, 1);
+ stream->write((uint64_t*)&cgen_var_928, 1 * 8);
marshal_VkXlibSurfaceCreateInfoKHR(stream, (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_925 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_925);
+ uint64_t cgen_var_929 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_929);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_926;
- stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_926, 1);
- stream->write((uint64_t*)&cgen_var_926, 8);
+ uint64_t cgen_var_930;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_930, 1);
+ stream->write((uint64_t*)&cgen_var_930, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateXlibSurfaceKHR readParams");
- uint64_t cgen_var_927;
- stream->read((uint64_t*)&cgen_var_927, 8);
- stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_927, (VkSurfaceKHR*)pSurface, 1);
+ uint64_t cgen_var_931;
+ stream->read((uint64_t*)&cgen_var_931, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_931, (VkSurfaceKHR*)pSurface, 1);
AEMU_SCOPED_TRACE("vkCreateXlibSurfaceKHR returnUnmarshal");
VkResult vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateXlibSurfaceKHR_VkResult_return, sizeof(VkResult));
@@ -13433,6 +13732,7 @@
Display* dpy,
VisualID visualID)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXlibPresentationSupportKHR encode");
mImpl->log("start vkGetPhysicalDeviceXlibPresentationSupportKHR");
auto stream = mImpl->stream();
@@ -13448,9 +13748,9 @@
local_visualID = visualID;
countingStream->rewind();
{
- uint64_t cgen_var_928;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_928, 1);
- countingStream->write((uint64_t*)&cgen_var_928, 1 * 8);
+ uint64_t cgen_var_932;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_932, 1);
+ countingStream->write((uint64_t*)&cgen_var_932, 1 * 8);
countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
countingStream->write((Display*)dpy, sizeof(Display));
countingStream->write((VisualID*)&local_visualID, sizeof(VisualID));
@@ -13460,9 +13760,9 @@
uint32_t opcode_vkGetPhysicalDeviceXlibPresentationSupportKHR = OP_vkGetPhysicalDeviceXlibPresentationSupportKHR;
stream->write(&opcode_vkGetPhysicalDeviceXlibPresentationSupportKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceXlibPresentationSupportKHR, sizeof(uint32_t));
- uint64_t cgen_var_929;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_929, 1);
- stream->write((uint64_t*)&cgen_var_929, 1 * 8);
+ uint64_t cgen_var_933;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_933, 1);
+ stream->write((uint64_t*)&cgen_var_933, 1 * 8);
stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
stream->write((Display*)dpy, sizeof(Display));
stream->write((VisualID*)&local_visualID, sizeof(VisualID));
@@ -13486,6 +13786,7 @@
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateXcbSurfaceKHR encode");
mImpl->log("start vkCreateXcbSurfaceKHR");
auto stream = mImpl->stream();
@@ -13520,46 +13821,46 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_930;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_930, 1);
- countingStream->write((uint64_t*)&cgen_var_930, 1 * 8);
+ uint64_t cgen_var_934;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_934, 1);
+ countingStream->write((uint64_t*)&cgen_var_934, 1 * 8);
marshal_VkXcbSurfaceCreateInfoKHR(countingStream, (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_931 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_931);
+ uint64_t cgen_var_935 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_935);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_932;
- countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_932, 1);
- countingStream->write((uint64_t*)&cgen_var_932, 8);
+ uint64_t cgen_var_936;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_936, 1);
+ countingStream->write((uint64_t*)&cgen_var_936, 8);
}
uint32_t packetSize_vkCreateXcbSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateXcbSurfaceKHR = OP_vkCreateXcbSurfaceKHR;
stream->write(&opcode_vkCreateXcbSurfaceKHR, sizeof(uint32_t));
stream->write(&packetSize_vkCreateXcbSurfaceKHR, sizeof(uint32_t));
- uint64_t cgen_var_933;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_933, 1);
- stream->write((uint64_t*)&cgen_var_933, 1 * 8);
+ uint64_t cgen_var_937;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_937, 1);
+ stream->write((uint64_t*)&cgen_var_937, 1 * 8);
marshal_VkXcbSurfaceCreateInfoKHR(stream, (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_934 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_934);
+ uint64_t cgen_var_938 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_938);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_935;
- stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_935, 1);
- stream->write((uint64_t*)&cgen_var_935, 8);
+ uint64_t cgen_var_939;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_939, 1);
+ stream->write((uint64_t*)&cgen_var_939, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateXcbSurfaceKHR readParams");
- uint64_t cgen_var_936;
- stream->read((uint64_t*)&cgen_var_936, 8);
- stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_936, (VkSurfaceKHR*)pSurface, 1);
+ uint64_t cgen_var_940;
+ stream->read((uint64_t*)&cgen_var_940, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_940, (VkSurfaceKHR*)pSurface, 1);
AEMU_SCOPED_TRACE("vkCreateXcbSurfaceKHR returnUnmarshal");
VkResult vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateXcbSurfaceKHR_VkResult_return, sizeof(VkResult));
@@ -13576,6 +13877,7 @@
xcb_connection_t* connection,
xcb_visualid_t visual_id)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXcbPresentationSupportKHR encode");
mImpl->log("start vkGetPhysicalDeviceXcbPresentationSupportKHR");
auto stream = mImpl->stream();
@@ -13591,9 +13893,9 @@
local_visual_id = visual_id;
countingStream->rewind();
{
- uint64_t cgen_var_937;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_937, 1);
- countingStream->write((uint64_t*)&cgen_var_937, 1 * 8);
+ uint64_t cgen_var_941;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_941, 1);
+ countingStream->write((uint64_t*)&cgen_var_941, 1 * 8);
countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
countingStream->write((xcb_connection_t*)connection, sizeof(xcb_connection_t));
countingStream->write((xcb_visualid_t*)&local_visual_id, sizeof(xcb_visualid_t));
@@ -13603,9 +13905,9 @@
uint32_t opcode_vkGetPhysicalDeviceXcbPresentationSupportKHR = OP_vkGetPhysicalDeviceXcbPresentationSupportKHR;
stream->write(&opcode_vkGetPhysicalDeviceXcbPresentationSupportKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceXcbPresentationSupportKHR, sizeof(uint32_t));
- uint64_t cgen_var_938;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_938, 1);
- stream->write((uint64_t*)&cgen_var_938, 1 * 8);
+ uint64_t cgen_var_942;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_942, 1);
+ stream->write((uint64_t*)&cgen_var_942, 1 * 8);
stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
stream->write((xcb_connection_t*)connection, sizeof(xcb_connection_t));
stream->write((xcb_visualid_t*)&local_visual_id, sizeof(xcb_visualid_t));
@@ -13629,6 +13931,7 @@
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateWaylandSurfaceKHR encode");
mImpl->log("start vkCreateWaylandSurfaceKHR");
auto stream = mImpl->stream();
@@ -13663,46 +13966,46 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_939;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_939, 1);
- countingStream->write((uint64_t*)&cgen_var_939, 1 * 8);
+ uint64_t cgen_var_943;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_943, 1);
+ countingStream->write((uint64_t*)&cgen_var_943, 1 * 8);
marshal_VkWaylandSurfaceCreateInfoKHR(countingStream, (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_940 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_940);
+ uint64_t cgen_var_944 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_944);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_941;
- countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_941, 1);
- countingStream->write((uint64_t*)&cgen_var_941, 8);
+ uint64_t cgen_var_945;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_945, 1);
+ countingStream->write((uint64_t*)&cgen_var_945, 8);
}
uint32_t packetSize_vkCreateWaylandSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateWaylandSurfaceKHR = OP_vkCreateWaylandSurfaceKHR;
stream->write(&opcode_vkCreateWaylandSurfaceKHR, sizeof(uint32_t));
stream->write(&packetSize_vkCreateWaylandSurfaceKHR, sizeof(uint32_t));
- uint64_t cgen_var_942;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_942, 1);
- stream->write((uint64_t*)&cgen_var_942, 1 * 8);
+ uint64_t cgen_var_946;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_946, 1);
+ stream->write((uint64_t*)&cgen_var_946, 1 * 8);
marshal_VkWaylandSurfaceCreateInfoKHR(stream, (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_943 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_943);
+ uint64_t cgen_var_947 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_947);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_944;
- stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_944, 1);
- stream->write((uint64_t*)&cgen_var_944, 8);
+ uint64_t cgen_var_948;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_948, 1);
+ stream->write((uint64_t*)&cgen_var_948, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateWaylandSurfaceKHR readParams");
- uint64_t cgen_var_945;
- stream->read((uint64_t*)&cgen_var_945, 8);
- stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_945, (VkSurfaceKHR*)pSurface, 1);
+ uint64_t cgen_var_949;
+ stream->read((uint64_t*)&cgen_var_949, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_949, (VkSurfaceKHR*)pSurface, 1);
AEMU_SCOPED_TRACE("vkCreateWaylandSurfaceKHR returnUnmarshal");
VkResult vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateWaylandSurfaceKHR_VkResult_return, sizeof(VkResult));
@@ -13718,6 +14021,7 @@
uint32_t queueFamilyIndex,
wl_display* display)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWaylandPresentationSupportKHR encode");
mImpl->log("start vkGetPhysicalDeviceWaylandPresentationSupportKHR");
auto stream = mImpl->stream();
@@ -13731,9 +14035,9 @@
local_queueFamilyIndex = queueFamilyIndex;
countingStream->rewind();
{
- uint64_t cgen_var_946;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_946, 1);
- countingStream->write((uint64_t*)&cgen_var_946, 1 * 8);
+ uint64_t cgen_var_950;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_950, 1);
+ countingStream->write((uint64_t*)&cgen_var_950, 1 * 8);
countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
countingStream->write((wl_display*)display, sizeof(wl_display));
}
@@ -13742,9 +14046,9 @@
uint32_t opcode_vkGetPhysicalDeviceWaylandPresentationSupportKHR = OP_vkGetPhysicalDeviceWaylandPresentationSupportKHR;
stream->write(&opcode_vkGetPhysicalDeviceWaylandPresentationSupportKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceWaylandPresentationSupportKHR, sizeof(uint32_t));
- uint64_t cgen_var_947;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_947, 1);
- stream->write((uint64_t*)&cgen_var_947, 1 * 8);
+ uint64_t cgen_var_951;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_951, 1);
+ stream->write((uint64_t*)&cgen_var_951, 1 * 8);
stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
stream->write((wl_display*)display, sizeof(wl_display));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWaylandPresentationSupportKHR readParams");
@@ -13767,6 +14071,7 @@
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateMirSurfaceKHR encode");
mImpl->log("start vkCreateMirSurfaceKHR");
auto stream = mImpl->stream();
@@ -13801,46 +14106,46 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_948;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_948, 1);
- countingStream->write((uint64_t*)&cgen_var_948, 1 * 8);
+ uint64_t cgen_var_952;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_952, 1);
+ countingStream->write((uint64_t*)&cgen_var_952, 1 * 8);
marshal_VkMirSurfaceCreateInfoKHR(countingStream, (VkMirSurfaceCreateInfoKHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_949 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_949);
+ uint64_t cgen_var_953 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_953);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_950;
- countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_950, 1);
- countingStream->write((uint64_t*)&cgen_var_950, 8);
+ uint64_t cgen_var_954;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_954, 1);
+ countingStream->write((uint64_t*)&cgen_var_954, 8);
}
uint32_t packetSize_vkCreateMirSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateMirSurfaceKHR = OP_vkCreateMirSurfaceKHR;
stream->write(&opcode_vkCreateMirSurfaceKHR, sizeof(uint32_t));
stream->write(&packetSize_vkCreateMirSurfaceKHR, sizeof(uint32_t));
- uint64_t cgen_var_951;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_951, 1);
- stream->write((uint64_t*)&cgen_var_951, 1 * 8);
+ uint64_t cgen_var_955;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_955, 1);
+ stream->write((uint64_t*)&cgen_var_955, 1 * 8);
marshal_VkMirSurfaceCreateInfoKHR(stream, (VkMirSurfaceCreateInfoKHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_952 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_952);
+ uint64_t cgen_var_956 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_956);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_953;
- stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_953, 1);
- stream->write((uint64_t*)&cgen_var_953, 8);
+ uint64_t cgen_var_957;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_957, 1);
+ stream->write((uint64_t*)&cgen_var_957, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateMirSurfaceKHR readParams");
- uint64_t cgen_var_954;
- stream->read((uint64_t*)&cgen_var_954, 8);
- stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_954, (VkSurfaceKHR*)pSurface, 1);
+ uint64_t cgen_var_958;
+ stream->read((uint64_t*)&cgen_var_958, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_958, (VkSurfaceKHR*)pSurface, 1);
AEMU_SCOPED_TRACE("vkCreateMirSurfaceKHR returnUnmarshal");
VkResult vkCreateMirSurfaceKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateMirSurfaceKHR_VkResult_return, sizeof(VkResult));
@@ -13856,6 +14161,7 @@
uint32_t queueFamilyIndex,
MirConnection* connection)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMirPresentationSupportKHR encode");
mImpl->log("start vkGetPhysicalDeviceMirPresentationSupportKHR");
auto stream = mImpl->stream();
@@ -13869,9 +14175,9 @@
local_queueFamilyIndex = queueFamilyIndex;
countingStream->rewind();
{
- uint64_t cgen_var_955;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_955, 1);
- countingStream->write((uint64_t*)&cgen_var_955, 1 * 8);
+ uint64_t cgen_var_959;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_959, 1);
+ countingStream->write((uint64_t*)&cgen_var_959, 1 * 8);
countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
countingStream->write((MirConnection*)connection, sizeof(MirConnection));
}
@@ -13880,9 +14186,9 @@
uint32_t opcode_vkGetPhysicalDeviceMirPresentationSupportKHR = OP_vkGetPhysicalDeviceMirPresentationSupportKHR;
stream->write(&opcode_vkGetPhysicalDeviceMirPresentationSupportKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceMirPresentationSupportKHR, sizeof(uint32_t));
- uint64_t cgen_var_956;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_956, 1);
- stream->write((uint64_t*)&cgen_var_956, 1 * 8);
+ uint64_t cgen_var_960;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_960, 1);
+ stream->write((uint64_t*)&cgen_var_960, 1 * 8);
stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
stream->write((MirConnection*)connection, sizeof(MirConnection));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMirPresentationSupportKHR readParams");
@@ -13905,6 +14211,7 @@
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateAndroidSurfaceKHR encode");
mImpl->log("start vkCreateAndroidSurfaceKHR");
auto stream = mImpl->stream();
@@ -13939,46 +14246,46 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_957;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_957, 1);
- countingStream->write((uint64_t*)&cgen_var_957, 1 * 8);
+ uint64_t cgen_var_961;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_961, 1);
+ countingStream->write((uint64_t*)&cgen_var_961, 1 * 8);
marshal_VkAndroidSurfaceCreateInfoKHR(countingStream, (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_958 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_958);
+ uint64_t cgen_var_962 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_962);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_959;
- countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_959, 1);
- countingStream->write((uint64_t*)&cgen_var_959, 8);
+ uint64_t cgen_var_963;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_963, 1);
+ countingStream->write((uint64_t*)&cgen_var_963, 8);
}
uint32_t packetSize_vkCreateAndroidSurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateAndroidSurfaceKHR = OP_vkCreateAndroidSurfaceKHR;
stream->write(&opcode_vkCreateAndroidSurfaceKHR, sizeof(uint32_t));
stream->write(&packetSize_vkCreateAndroidSurfaceKHR, sizeof(uint32_t));
- uint64_t cgen_var_960;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_960, 1);
- stream->write((uint64_t*)&cgen_var_960, 1 * 8);
+ uint64_t cgen_var_964;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_964, 1);
+ stream->write((uint64_t*)&cgen_var_964, 1 * 8);
marshal_VkAndroidSurfaceCreateInfoKHR(stream, (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_961 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_961);
+ uint64_t cgen_var_965 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_965);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_962;
- stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_962, 1);
- stream->write((uint64_t*)&cgen_var_962, 8);
+ uint64_t cgen_var_966;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_966, 1);
+ stream->write((uint64_t*)&cgen_var_966, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateAndroidSurfaceKHR readParams");
- uint64_t cgen_var_963;
- stream->read((uint64_t*)&cgen_var_963, 8);
- stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_963, (VkSurfaceKHR*)pSurface, 1);
+ uint64_t cgen_var_967;
+ stream->read((uint64_t*)&cgen_var_967, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_967, (VkSurfaceKHR*)pSurface, 1);
AEMU_SCOPED_TRACE("vkCreateAndroidSurfaceKHR returnUnmarshal");
VkResult vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateAndroidSurfaceKHR_VkResult_return, sizeof(VkResult));
@@ -13997,6 +14304,7 @@
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateWin32SurfaceKHR encode");
mImpl->log("start vkCreateWin32SurfaceKHR");
auto stream = mImpl->stream();
@@ -14031,46 +14339,46 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_964;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_964, 1);
- countingStream->write((uint64_t*)&cgen_var_964, 1 * 8);
+ uint64_t cgen_var_968;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_968, 1);
+ countingStream->write((uint64_t*)&cgen_var_968, 1 * 8);
marshal_VkWin32SurfaceCreateInfoKHR(countingStream, (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_965 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_965);
+ uint64_t cgen_var_969 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_969);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_966;
- countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_966, 1);
- countingStream->write((uint64_t*)&cgen_var_966, 8);
+ uint64_t cgen_var_970;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_970, 1);
+ countingStream->write((uint64_t*)&cgen_var_970, 8);
}
uint32_t packetSize_vkCreateWin32SurfaceKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateWin32SurfaceKHR = OP_vkCreateWin32SurfaceKHR;
stream->write(&opcode_vkCreateWin32SurfaceKHR, sizeof(uint32_t));
stream->write(&packetSize_vkCreateWin32SurfaceKHR, sizeof(uint32_t));
- uint64_t cgen_var_967;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_967, 1);
- stream->write((uint64_t*)&cgen_var_967, 1 * 8);
+ uint64_t cgen_var_971;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_971, 1);
+ stream->write((uint64_t*)&cgen_var_971, 1 * 8);
marshal_VkWin32SurfaceCreateInfoKHR(stream, (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_968 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_968);
+ uint64_t cgen_var_972 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_972);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_969;
- stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_969, 1);
- stream->write((uint64_t*)&cgen_var_969, 8);
+ uint64_t cgen_var_973;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_973, 1);
+ stream->write((uint64_t*)&cgen_var_973, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateWin32SurfaceKHR readParams");
- uint64_t cgen_var_970;
- stream->read((uint64_t*)&cgen_var_970, 8);
- stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_970, (VkSurfaceKHR*)pSurface, 1);
+ uint64_t cgen_var_974;
+ stream->read((uint64_t*)&cgen_var_974, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_974, (VkSurfaceKHR*)pSurface, 1);
AEMU_SCOPED_TRACE("vkCreateWin32SurfaceKHR returnUnmarshal");
VkResult vkCreateWin32SurfaceKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateWin32SurfaceKHR_VkResult_return, sizeof(VkResult));
@@ -14085,6 +14393,7 @@
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWin32PresentationSupportKHR encode");
mImpl->log("start vkGetPhysicalDeviceWin32PresentationSupportKHR");
auto stream = mImpl->stream();
@@ -14098,9 +14407,9 @@
local_queueFamilyIndex = queueFamilyIndex;
countingStream->rewind();
{
- uint64_t cgen_var_971;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_971, 1);
- countingStream->write((uint64_t*)&cgen_var_971, 1 * 8);
+ uint64_t cgen_var_975;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_975, 1);
+ countingStream->write((uint64_t*)&cgen_var_975, 1 * 8);
countingStream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
}
uint32_t packetSize_vkGetPhysicalDeviceWin32PresentationSupportKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -14108,9 +14417,9 @@
uint32_t opcode_vkGetPhysicalDeviceWin32PresentationSupportKHR = OP_vkGetPhysicalDeviceWin32PresentationSupportKHR;
stream->write(&opcode_vkGetPhysicalDeviceWin32PresentationSupportKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceWin32PresentationSupportKHR, sizeof(uint32_t));
- uint64_t cgen_var_972;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_972, 1);
- stream->write((uint64_t*)&cgen_var_972, 1 * 8);
+ uint64_t cgen_var_976;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_976, 1);
+ stream->write((uint64_t*)&cgen_var_976, 1 * 8);
stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWin32PresentationSupportKHR readParams");
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWin32PresentationSupportKHR returnUnmarshal");
@@ -14133,6 +14442,7 @@
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures2* pFeatures)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2KHR encode");
mImpl->log("start vkGetPhysicalDeviceFeatures2KHR");
auto stream = mImpl->stream();
@@ -14144,9 +14454,9 @@
local_physicalDevice = physicalDevice;
countingStream->rewind();
{
- uint64_t cgen_var_973;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_973, 1);
- countingStream->write((uint64_t*)&cgen_var_973, 1 * 8);
+ uint64_t cgen_var_977;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_977, 1);
+ countingStream->write((uint64_t*)&cgen_var_977, 1 * 8);
marshal_VkPhysicalDeviceFeatures2(countingStream, (VkPhysicalDeviceFeatures2*)(pFeatures));
}
uint32_t packetSize_vkGetPhysicalDeviceFeatures2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -14154,9 +14464,9 @@
uint32_t opcode_vkGetPhysicalDeviceFeatures2KHR = OP_vkGetPhysicalDeviceFeatures2KHR;
stream->write(&opcode_vkGetPhysicalDeviceFeatures2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceFeatures2KHR, sizeof(uint32_t));
- uint64_t cgen_var_974;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_974, 1);
- stream->write((uint64_t*)&cgen_var_974, 1 * 8);
+ uint64_t cgen_var_978;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_978, 1);
+ stream->write((uint64_t*)&cgen_var_978, 1 * 8);
marshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2KHR readParams");
unmarshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures));
@@ -14172,6 +14482,7 @@
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties2* pProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2KHR encode");
mImpl->log("start vkGetPhysicalDeviceProperties2KHR");
auto stream = mImpl->stream();
@@ -14183,9 +14494,9 @@
local_physicalDevice = physicalDevice;
countingStream->rewind();
{
- uint64_t cgen_var_975;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_975, 1);
- countingStream->write((uint64_t*)&cgen_var_975, 1 * 8);
+ uint64_t cgen_var_979;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_979, 1);
+ countingStream->write((uint64_t*)&cgen_var_979, 1 * 8);
marshal_VkPhysicalDeviceProperties2(countingStream, (VkPhysicalDeviceProperties2*)(pProperties));
}
uint32_t packetSize_vkGetPhysicalDeviceProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -14193,9 +14504,9 @@
uint32_t opcode_vkGetPhysicalDeviceProperties2KHR = OP_vkGetPhysicalDeviceProperties2KHR;
stream->write(&opcode_vkGetPhysicalDeviceProperties2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceProperties2KHR, sizeof(uint32_t));
- uint64_t cgen_var_976;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_976, 1);
- stream->write((uint64_t*)&cgen_var_976, 1 * 8);
+ uint64_t cgen_var_980;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_980, 1);
+ stream->write((uint64_t*)&cgen_var_980, 1 * 8);
marshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2KHR readParams");
unmarshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties));
@@ -14212,6 +14523,7 @@
VkFormat format,
VkFormatProperties2* pFormatProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2KHR encode");
mImpl->log("start vkGetPhysicalDeviceFormatProperties2KHR");
auto stream = mImpl->stream();
@@ -14225,9 +14537,9 @@
local_format = format;
countingStream->rewind();
{
- uint64_t cgen_var_977;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_977, 1);
- countingStream->write((uint64_t*)&cgen_var_977, 1 * 8);
+ uint64_t cgen_var_981;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_981, 1);
+ countingStream->write((uint64_t*)&cgen_var_981, 1 * 8);
countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
marshal_VkFormatProperties2(countingStream, (VkFormatProperties2*)(pFormatProperties));
}
@@ -14236,9 +14548,9 @@
uint32_t opcode_vkGetPhysicalDeviceFormatProperties2KHR = OP_vkGetPhysicalDeviceFormatProperties2KHR;
stream->write(&opcode_vkGetPhysicalDeviceFormatProperties2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceFormatProperties2KHR, sizeof(uint32_t));
- uint64_t cgen_var_978;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_978, 1);
- stream->write((uint64_t*)&cgen_var_978, 1 * 8);
+ uint64_t cgen_var_982;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_982, 1);
+ stream->write((uint64_t*)&cgen_var_982, 1 * 8);
stream->write((VkFormat*)&local_format, sizeof(VkFormat));
marshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2KHR readParams");
@@ -14256,6 +14568,7 @@
const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
VkImageFormatProperties2* pImageFormatProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2KHR encode");
mImpl->log("start vkGetPhysicalDeviceImageFormatProperties2KHR");
auto stream = mImpl->stream();
@@ -14278,9 +14591,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_979;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_979, 1);
- countingStream->write((uint64_t*)&cgen_var_979, 1 * 8);
+ uint64_t cgen_var_983;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_983, 1);
+ countingStream->write((uint64_t*)&cgen_var_983, 1 * 8);
marshal_VkPhysicalDeviceImageFormatInfo2(countingStream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
marshal_VkImageFormatProperties2(countingStream, (VkImageFormatProperties2*)(pImageFormatProperties));
}
@@ -14289,9 +14602,9 @@
uint32_t opcode_vkGetPhysicalDeviceImageFormatProperties2KHR = OP_vkGetPhysicalDeviceImageFormatProperties2KHR;
stream->write(&opcode_vkGetPhysicalDeviceImageFormatProperties2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceImageFormatProperties2KHR, sizeof(uint32_t));
- uint64_t cgen_var_980;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_980, 1);
- stream->write((uint64_t*)&cgen_var_980, 1 * 8);
+ uint64_t cgen_var_984;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_984, 1);
+ stream->write((uint64_t*)&cgen_var_984, 1 * 8);
marshal_VkPhysicalDeviceImageFormatInfo2(stream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
marshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2KHR readParams");
@@ -14315,6 +14628,7 @@
uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties2* pQueueFamilyProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2KHR encode");
mImpl->log("start vkGetPhysicalDeviceQueueFamilyProperties2KHR");
auto stream = mImpl->stream();
@@ -14326,19 +14640,19 @@
local_physicalDevice = physicalDevice;
countingStream->rewind();
{
- uint64_t cgen_var_981;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_981, 1);
- countingStream->write((uint64_t*)&cgen_var_981, 1 * 8);
+ uint64_t cgen_var_985;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_985, 1);
+ countingStream->write((uint64_t*)&cgen_var_985, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_982 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
- countingStream->putBe64(cgen_var_982);
+ uint64_t cgen_var_986 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+ countingStream->putBe64(cgen_var_986);
if (pQueueFamilyPropertyCount)
{
countingStream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_983 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
- countingStream->putBe64(cgen_var_983);
+ uint64_t cgen_var_987 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+ countingStream->putBe64(cgen_var_987);
if (pQueueFamilyProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
@@ -14352,19 +14666,19 @@
uint32_t opcode_vkGetPhysicalDeviceQueueFamilyProperties2KHR = OP_vkGetPhysicalDeviceQueueFamilyProperties2KHR;
stream->write(&opcode_vkGetPhysicalDeviceQueueFamilyProperties2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceQueueFamilyProperties2KHR, sizeof(uint32_t));
- uint64_t cgen_var_984;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_984, 1);
- stream->write((uint64_t*)&cgen_var_984, 1 * 8);
+ uint64_t cgen_var_988;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_988, 1);
+ stream->write((uint64_t*)&cgen_var_988, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_985 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
- stream->putBe64(cgen_var_985);
+ uint64_t cgen_var_989 = (uint64_t)(uintptr_t)pQueueFamilyPropertyCount;
+ stream->putBe64(cgen_var_989);
if (pQueueFamilyPropertyCount)
{
stream->write((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_986 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
- stream->putBe64(cgen_var_986);
+ uint64_t cgen_var_990 = (uint64_t)(uintptr_t)pQueueFamilyProperties;
+ stream->putBe64(cgen_var_990);
if (pQueueFamilyProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
@@ -14413,6 +14727,7 @@
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2KHR encode");
mImpl->log("start vkGetPhysicalDeviceMemoryProperties2KHR");
auto stream = mImpl->stream();
@@ -14424,9 +14739,9 @@
local_physicalDevice = physicalDevice;
countingStream->rewind();
{
- uint64_t cgen_var_989;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_989, 1);
- countingStream->write((uint64_t*)&cgen_var_989, 1 * 8);
+ uint64_t cgen_var_993;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_993, 1);
+ countingStream->write((uint64_t*)&cgen_var_993, 1 * 8);
marshal_VkPhysicalDeviceMemoryProperties2(countingStream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
}
uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -14434,9 +14749,9 @@
uint32_t opcode_vkGetPhysicalDeviceMemoryProperties2KHR = OP_vkGetPhysicalDeviceMemoryProperties2KHR;
stream->write(&opcode_vkGetPhysicalDeviceMemoryProperties2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceMemoryProperties2KHR, sizeof(uint32_t));
- uint64_t cgen_var_990;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_990, 1);
- stream->write((uint64_t*)&cgen_var_990, 1 * 8);
+ uint64_t cgen_var_994;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_994, 1);
+ stream->write((uint64_t*)&cgen_var_994, 1 * 8);
marshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2KHR readParams");
unmarshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
@@ -14445,7 +14760,9 @@
transform_fromhost_VkPhysicalDeviceMemoryProperties2(mImpl->resources(), (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
}
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2KHR returnUnmarshal");
+ encoderLock.unlock();
mImpl->resources()->on_vkGetPhysicalDeviceMemoryProperties2KHR(this, physicalDevice, pMemoryProperties);
+ encoderLock.lock();
mImpl->log("finish vkGetPhysicalDeviceMemoryProperties2KHR");;
}
@@ -14455,6 +14772,7 @@
uint32_t* pPropertyCount,
VkSparseImageFormatProperties2* pProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2KHR encode");
mImpl->log("start vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
auto stream = mImpl->stream();
@@ -14477,20 +14795,20 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_991;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_991, 1);
- countingStream->write((uint64_t*)&cgen_var_991, 1 * 8);
+ uint64_t cgen_var_995;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_995, 1);
+ countingStream->write((uint64_t*)&cgen_var_995, 1 * 8);
marshal_VkPhysicalDeviceSparseImageFormatInfo2(countingStream, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_992 = (uint64_t)(uintptr_t)pPropertyCount;
- countingStream->putBe64(cgen_var_992);
+ uint64_t cgen_var_996 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_996);
if (pPropertyCount)
{
countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_993 = (uint64_t)(uintptr_t)pProperties;
- countingStream->putBe64(cgen_var_993);
+ uint64_t cgen_var_997 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_997);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -14504,20 +14822,20 @@
uint32_t opcode_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = OP_vkGetPhysicalDeviceSparseImageFormatProperties2KHR;
stream->write(&opcode_vkGetPhysicalDeviceSparseImageFormatProperties2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2KHR, sizeof(uint32_t));
- uint64_t cgen_var_994;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_994, 1);
- stream->write((uint64_t*)&cgen_var_994, 1 * 8);
+ uint64_t cgen_var_998;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_998, 1);
+ stream->write((uint64_t*)&cgen_var_998, 1 * 8);
marshal_VkPhysicalDeviceSparseImageFormatInfo2(stream, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_995 = (uint64_t)(uintptr_t)pPropertyCount;
- stream->putBe64(cgen_var_995);
+ uint64_t cgen_var_999 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_999);
if (pPropertyCount)
{
stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_996 = (uint64_t)(uintptr_t)pProperties;
- stream->putBe64(cgen_var_996);
+ uint64_t cgen_var_1000 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_1000);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -14571,6 +14889,7 @@
uint32_t remoteDeviceIndex,
VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeaturesKHR encode");
mImpl->log("start vkGetDeviceGroupPeerMemoryFeaturesKHR");
auto stream = mImpl->stream();
@@ -14588,9 +14907,9 @@
local_remoteDeviceIndex = remoteDeviceIndex;
countingStream->rewind();
{
- uint64_t cgen_var_999;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_999, 1);
- countingStream->write((uint64_t*)&cgen_var_999, 1 * 8);
+ uint64_t cgen_var_1003;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1003, 1);
+ countingStream->write((uint64_t*)&cgen_var_1003, 1 * 8);
countingStream->write((uint32_t*)&local_heapIndex, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
@@ -14601,9 +14920,9 @@
uint32_t opcode_vkGetDeviceGroupPeerMemoryFeaturesKHR = OP_vkGetDeviceGroupPeerMemoryFeaturesKHR;
stream->write(&opcode_vkGetDeviceGroupPeerMemoryFeaturesKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetDeviceGroupPeerMemoryFeaturesKHR, sizeof(uint32_t));
- uint64_t cgen_var_1000;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1000, 1);
- stream->write((uint64_t*)&cgen_var_1000, 1 * 8);
+ uint64_t cgen_var_1004;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1004, 1);
+ stream->write((uint64_t*)&cgen_var_1004, 1 * 8);
stream->write((uint32_t*)&local_heapIndex, sizeof(uint32_t));
stream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t));
stream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
@@ -14618,6 +14937,7 @@
VkCommandBuffer commandBuffer,
uint32_t deviceMask)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdSetDeviceMaskKHR encode");
mImpl->log("start vkCmdSetDeviceMaskKHR");
auto stream = mImpl->stream();
@@ -14631,9 +14951,9 @@
local_deviceMask = deviceMask;
countingStream->rewind();
{
- uint64_t cgen_var_1001;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1001, 1);
- countingStream->write((uint64_t*)&cgen_var_1001, 1 * 8);
+ uint64_t cgen_var_1005;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1005, 1);
+ countingStream->write((uint64_t*)&cgen_var_1005, 1 * 8);
countingStream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
}
uint32_t packetSize_vkCmdSetDeviceMaskKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -14641,9 +14961,9 @@
uint32_t opcode_vkCmdSetDeviceMaskKHR = OP_vkCmdSetDeviceMaskKHR;
stream->write(&opcode_vkCmdSetDeviceMaskKHR, sizeof(uint32_t));
stream->write(&packetSize_vkCmdSetDeviceMaskKHR, sizeof(uint32_t));
- uint64_t cgen_var_1002;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1002, 1);
- stream->write((uint64_t*)&cgen_var_1002, 1 * 8);
+ uint64_t cgen_var_1006;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1006, 1);
+ stream->write((uint64_t*)&cgen_var_1006, 1 * 8);
stream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t));
AEMU_SCOPED_TRACE("vkCmdSetDeviceMaskKHR readParams");
AEMU_SCOPED_TRACE("vkCmdSetDeviceMaskKHR returnUnmarshal");
@@ -14659,6 +14979,7 @@
uint32_t groupCountY,
uint32_t groupCountZ)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdDispatchBaseKHR encode");
mImpl->log("start vkCmdDispatchBaseKHR");
auto stream = mImpl->stream();
@@ -14682,9 +15003,9 @@
local_groupCountZ = groupCountZ;
countingStream->rewind();
{
- uint64_t cgen_var_1003;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1003, 1);
- countingStream->write((uint64_t*)&cgen_var_1003, 1 * 8);
+ uint64_t cgen_var_1007;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1007, 1);
+ countingStream->write((uint64_t*)&cgen_var_1007, 1 * 8);
countingStream->write((uint32_t*)&local_baseGroupX, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_baseGroupY, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_baseGroupZ, sizeof(uint32_t));
@@ -14697,9 +15018,9 @@
uint32_t opcode_vkCmdDispatchBaseKHR = OP_vkCmdDispatchBaseKHR;
stream->write(&opcode_vkCmdDispatchBaseKHR, sizeof(uint32_t));
stream->write(&packetSize_vkCmdDispatchBaseKHR, sizeof(uint32_t));
- uint64_t cgen_var_1004;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1004, 1);
- stream->write((uint64_t*)&cgen_var_1004, 1 * 8);
+ uint64_t cgen_var_1008;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1008, 1);
+ stream->write((uint64_t*)&cgen_var_1008, 1 * 8);
stream->write((uint32_t*)&local_baseGroupX, sizeof(uint32_t));
stream->write((uint32_t*)&local_baseGroupY, sizeof(uint32_t));
stream->write((uint32_t*)&local_baseGroupZ, sizeof(uint32_t));
@@ -14720,6 +15041,7 @@
VkCommandPool commandPool,
VkCommandPoolTrimFlags flags)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR encode");
mImpl->log("start vkTrimCommandPoolKHR");
auto stream = mImpl->stream();
@@ -14735,12 +15057,12 @@
local_flags = flags;
countingStream->rewind();
{
- uint64_t cgen_var_1005;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1005, 1);
- countingStream->write((uint64_t*)&cgen_var_1005, 1 * 8);
- uint64_t cgen_var_1006;
- countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_1006, 1);
- countingStream->write((uint64_t*)&cgen_var_1006, 1 * 8);
+ uint64_t cgen_var_1009;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1009, 1);
+ countingStream->write((uint64_t*)&cgen_var_1009, 1 * 8);
+ uint64_t cgen_var_1010;
+ countingStream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_1010, 1);
+ countingStream->write((uint64_t*)&cgen_var_1010, 1 * 8);
countingStream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
}
uint32_t packetSize_vkTrimCommandPoolKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -14748,12 +15070,12 @@
uint32_t opcode_vkTrimCommandPoolKHR = OP_vkTrimCommandPoolKHR;
stream->write(&opcode_vkTrimCommandPoolKHR, sizeof(uint32_t));
stream->write(&packetSize_vkTrimCommandPoolKHR, sizeof(uint32_t));
- uint64_t cgen_var_1007;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1007, 1);
- stream->write((uint64_t*)&cgen_var_1007, 1 * 8);
- uint64_t cgen_var_1008;
- stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_1008, 1);
- stream->write((uint64_t*)&cgen_var_1008, 1 * 8);
+ uint64_t cgen_var_1011;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1011, 1);
+ stream->write((uint64_t*)&cgen_var_1011, 1 * 8);
+ uint64_t cgen_var_1012;
+ stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_1012, 1);
+ stream->write((uint64_t*)&cgen_var_1012, 1 * 8);
stream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR readParams");
AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR returnUnmarshal");
@@ -14767,6 +15089,7 @@
uint32_t* pPhysicalDeviceGroupCount,
VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroupsKHR encode");
mImpl->log("start vkEnumeratePhysicalDeviceGroupsKHR");
auto stream = mImpl->stream();
@@ -14778,19 +15101,19 @@
local_instance = instance;
countingStream->rewind();
{
- uint64_t cgen_var_1009;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1009, 1);
- countingStream->write((uint64_t*)&cgen_var_1009, 1 * 8);
+ uint64_t cgen_var_1013;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1013, 1);
+ countingStream->write((uint64_t*)&cgen_var_1013, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1010 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
- countingStream->putBe64(cgen_var_1010);
+ uint64_t cgen_var_1014 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
+ countingStream->putBe64(cgen_var_1014);
if (pPhysicalDeviceGroupCount)
{
countingStream->write((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1011 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
- countingStream->putBe64(cgen_var_1011);
+ uint64_t cgen_var_1015 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
+ countingStream->putBe64(cgen_var_1015);
if (pPhysicalDeviceGroupProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
@@ -14804,19 +15127,19 @@
uint32_t opcode_vkEnumeratePhysicalDeviceGroupsKHR = OP_vkEnumeratePhysicalDeviceGroupsKHR;
stream->write(&opcode_vkEnumeratePhysicalDeviceGroupsKHR, sizeof(uint32_t));
stream->write(&packetSize_vkEnumeratePhysicalDeviceGroupsKHR, sizeof(uint32_t));
- uint64_t cgen_var_1012;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1012, 1);
- stream->write((uint64_t*)&cgen_var_1012, 1 * 8);
+ uint64_t cgen_var_1016;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1016, 1);
+ stream->write((uint64_t*)&cgen_var_1016, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1013 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
- stream->putBe64(cgen_var_1013);
+ uint64_t cgen_var_1017 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupCount;
+ stream->putBe64(cgen_var_1017);
if (pPhysicalDeviceGroupCount)
{
stream->write((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1014 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
- stream->putBe64(cgen_var_1014);
+ uint64_t cgen_var_1018 = (uint64_t)(uintptr_t)pPhysicalDeviceGroupProperties;
+ stream->putBe64(cgen_var_1018);
if (pPhysicalDeviceGroupProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
@@ -14874,6 +15197,7 @@
const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
VkExternalBufferProperties* pExternalBufferProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferPropertiesKHR encode");
mImpl->log("start vkGetPhysicalDeviceExternalBufferPropertiesKHR");
auto stream = mImpl->stream();
@@ -14897,9 +15221,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1017;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1017, 1);
- countingStream->write((uint64_t*)&cgen_var_1017, 1 * 8);
+ uint64_t cgen_var_1021;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1021, 1);
+ countingStream->write((uint64_t*)&cgen_var_1021, 1 * 8);
marshal_VkPhysicalDeviceExternalBufferInfo(countingStream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
marshal_VkExternalBufferProperties(countingStream, (VkExternalBufferProperties*)(pExternalBufferProperties));
}
@@ -14908,9 +15232,9 @@
uint32_t opcode_vkGetPhysicalDeviceExternalBufferPropertiesKHR = OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR;
stream->write(&opcode_vkGetPhysicalDeviceExternalBufferPropertiesKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceExternalBufferPropertiesKHR, sizeof(uint32_t));
- uint64_t cgen_var_1018;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1018, 1);
- stream->write((uint64_t*)&cgen_var_1018, 1 * 8);
+ uint64_t cgen_var_1022;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1022, 1);
+ stream->write((uint64_t*)&cgen_var_1022, 1 * 8);
marshal_VkPhysicalDeviceExternalBufferInfo(stream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
marshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferPropertiesKHR readParams");
@@ -14933,6 +15257,7 @@
const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
HANDLE* pHandle)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleKHR encode");
mImpl->log("start vkGetMemoryWin32HandleKHR");
auto stream = mImpl->stream();
@@ -14955,9 +15280,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1019;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1019, 1);
- countingStream->write((uint64_t*)&cgen_var_1019, 1 * 8);
+ uint64_t cgen_var_1023;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1023, 1);
+ countingStream->write((uint64_t*)&cgen_var_1023, 1 * 8);
marshal_VkMemoryGetWin32HandleInfoKHR(countingStream, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
countingStream->write((HANDLE*)pHandle, sizeof(HANDLE));
}
@@ -14966,9 +15291,9 @@
uint32_t opcode_vkGetMemoryWin32HandleKHR = OP_vkGetMemoryWin32HandleKHR;
stream->write(&opcode_vkGetMemoryWin32HandleKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetMemoryWin32HandleKHR, sizeof(uint32_t));
- uint64_t cgen_var_1020;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1020, 1);
- stream->write((uint64_t*)&cgen_var_1020, 1 * 8);
+ uint64_t cgen_var_1024;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1024, 1);
+ stream->write((uint64_t*)&cgen_var_1024, 1 * 8);
marshal_VkMemoryGetWin32HandleInfoKHR(stream, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
stream->write((HANDLE*)pHandle, sizeof(HANDLE));
AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleKHR readParams");
@@ -14989,6 +15314,7 @@
HANDLE handle,
VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetMemoryWin32HandlePropertiesKHR encode");
mImpl->log("start vkGetMemoryWin32HandlePropertiesKHR");
auto stream = mImpl->stream();
@@ -15004,9 +15330,9 @@
local_handle = handle;
countingStream->rewind();
{
- uint64_t cgen_var_1021;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1021, 1);
- countingStream->write((uint64_t*)&cgen_var_1021, 1 * 8);
+ uint64_t cgen_var_1025;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1025, 1);
+ countingStream->write((uint64_t*)&cgen_var_1025, 1 * 8);
countingStream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
countingStream->write((HANDLE*)&local_handle, sizeof(HANDLE));
marshal_VkMemoryWin32HandlePropertiesKHR(countingStream, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties));
@@ -15016,9 +15342,9 @@
uint32_t opcode_vkGetMemoryWin32HandlePropertiesKHR = OP_vkGetMemoryWin32HandlePropertiesKHR;
stream->write(&opcode_vkGetMemoryWin32HandlePropertiesKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetMemoryWin32HandlePropertiesKHR, sizeof(uint32_t));
- uint64_t cgen_var_1022;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1022, 1);
- stream->write((uint64_t*)&cgen_var_1022, 1 * 8);
+ uint64_t cgen_var_1026;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1026, 1);
+ stream->write((uint64_t*)&cgen_var_1026, 1 * 8);
stream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
stream->write((HANDLE*)&local_handle, sizeof(HANDLE));
marshal_VkMemoryWin32HandlePropertiesKHR(stream, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties));
@@ -15045,6 +15371,7 @@
const VkMemoryGetFdInfoKHR* pGetFdInfo,
int* pFd)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetMemoryFdKHR encode");
mImpl->log("start vkGetMemoryFdKHR");
auto stream = mImpl->stream();
@@ -15067,9 +15394,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1023;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1023, 1);
- countingStream->write((uint64_t*)&cgen_var_1023, 1 * 8);
+ uint64_t cgen_var_1027;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1027, 1);
+ countingStream->write((uint64_t*)&cgen_var_1027, 1 * 8);
marshal_VkMemoryGetFdInfoKHR(countingStream, (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo));
countingStream->write((int*)pFd, sizeof(int));
}
@@ -15078,9 +15405,9 @@
uint32_t opcode_vkGetMemoryFdKHR = OP_vkGetMemoryFdKHR;
stream->write(&opcode_vkGetMemoryFdKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetMemoryFdKHR, sizeof(uint32_t));
- uint64_t cgen_var_1024;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1024, 1);
- stream->write((uint64_t*)&cgen_var_1024, 1 * 8);
+ uint64_t cgen_var_1028;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1028, 1);
+ stream->write((uint64_t*)&cgen_var_1028, 1 * 8);
marshal_VkMemoryGetFdInfoKHR(stream, (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo));
stream->write((int*)pFd, sizeof(int));
AEMU_SCOPED_TRACE("vkGetMemoryFdKHR readParams");
@@ -15101,6 +15428,7 @@
int fd,
VkMemoryFdPropertiesKHR* pMemoryFdProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetMemoryFdPropertiesKHR encode");
mImpl->log("start vkGetMemoryFdPropertiesKHR");
auto stream = mImpl->stream();
@@ -15116,9 +15444,9 @@
local_fd = fd;
countingStream->rewind();
{
- uint64_t cgen_var_1025;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1025, 1);
- countingStream->write((uint64_t*)&cgen_var_1025, 1 * 8);
+ uint64_t cgen_var_1029;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1029, 1);
+ countingStream->write((uint64_t*)&cgen_var_1029, 1 * 8);
countingStream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
countingStream->write((int*)&local_fd, sizeof(int));
marshal_VkMemoryFdPropertiesKHR(countingStream, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties));
@@ -15128,9 +15456,9 @@
uint32_t opcode_vkGetMemoryFdPropertiesKHR = OP_vkGetMemoryFdPropertiesKHR;
stream->write(&opcode_vkGetMemoryFdPropertiesKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetMemoryFdPropertiesKHR, sizeof(uint32_t));
- uint64_t cgen_var_1026;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1026, 1);
- stream->write((uint64_t*)&cgen_var_1026, 1 * 8);
+ uint64_t cgen_var_1030;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1030, 1);
+ stream->write((uint64_t*)&cgen_var_1030, 1 * 8);
stream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
stream->write((int*)&local_fd, sizeof(int));
marshal_VkMemoryFdPropertiesKHR(stream, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties));
@@ -15159,6 +15487,7 @@
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR encode");
mImpl->log("start vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");
auto stream = mImpl->stream();
@@ -15181,9 +15510,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1027;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1027, 1);
- countingStream->write((uint64_t*)&cgen_var_1027, 1 * 8);
+ uint64_t cgen_var_1031;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1031, 1);
+ countingStream->write((uint64_t*)&cgen_var_1031, 1 * 8);
marshal_VkPhysicalDeviceExternalSemaphoreInfo(countingStream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
marshal_VkExternalSemaphoreProperties(countingStream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
}
@@ -15192,9 +15521,9 @@
uint32_t opcode_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
stream->write(&opcode_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, sizeof(uint32_t));
- uint64_t cgen_var_1028;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1028, 1);
- stream->write((uint64_t*)&cgen_var_1028, 1 * 8);
+ uint64_t cgen_var_1032;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1032, 1);
+ stream->write((uint64_t*)&cgen_var_1032, 1 * 8);
marshal_VkPhysicalDeviceExternalSemaphoreInfo(stream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
marshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR readParams");
@@ -15215,6 +15544,7 @@
VkDevice device,
const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkImportSemaphoreWin32HandleKHR encode");
mImpl->log("start vkImportSemaphoreWin32HandleKHR");
auto stream = mImpl->stream();
@@ -15237,9 +15567,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1029;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1029, 1);
- countingStream->write((uint64_t*)&cgen_var_1029, 1 * 8);
+ uint64_t cgen_var_1033;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1033, 1);
+ countingStream->write((uint64_t*)&cgen_var_1033, 1 * 8);
marshal_VkImportSemaphoreWin32HandleInfoKHR(countingStream, (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo));
}
uint32_t packetSize_vkImportSemaphoreWin32HandleKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -15247,9 +15577,9 @@
uint32_t opcode_vkImportSemaphoreWin32HandleKHR = OP_vkImportSemaphoreWin32HandleKHR;
stream->write(&opcode_vkImportSemaphoreWin32HandleKHR, sizeof(uint32_t));
stream->write(&packetSize_vkImportSemaphoreWin32HandleKHR, sizeof(uint32_t));
- uint64_t cgen_var_1030;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1030, 1);
- stream->write((uint64_t*)&cgen_var_1030, 1 * 8);
+ uint64_t cgen_var_1034;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1034, 1);
+ stream->write((uint64_t*)&cgen_var_1034, 1 * 8);
marshal_VkImportSemaphoreWin32HandleInfoKHR(stream, (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo));
AEMU_SCOPED_TRACE("vkImportSemaphoreWin32HandleKHR readParams");
AEMU_SCOPED_TRACE("vkImportSemaphoreWin32HandleKHR returnUnmarshal");
@@ -15267,6 +15597,7 @@
const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
HANDLE* pHandle)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetSemaphoreWin32HandleKHR encode");
mImpl->log("start vkGetSemaphoreWin32HandleKHR");
auto stream = mImpl->stream();
@@ -15289,9 +15620,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1031;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1031, 1);
- countingStream->write((uint64_t*)&cgen_var_1031, 1 * 8);
+ uint64_t cgen_var_1035;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1035, 1);
+ countingStream->write((uint64_t*)&cgen_var_1035, 1 * 8);
marshal_VkSemaphoreGetWin32HandleInfoKHR(countingStream, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
countingStream->write((HANDLE*)pHandle, sizeof(HANDLE));
}
@@ -15300,9 +15631,9 @@
uint32_t opcode_vkGetSemaphoreWin32HandleKHR = OP_vkGetSemaphoreWin32HandleKHR;
stream->write(&opcode_vkGetSemaphoreWin32HandleKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetSemaphoreWin32HandleKHR, sizeof(uint32_t));
- uint64_t cgen_var_1032;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1032, 1);
- stream->write((uint64_t*)&cgen_var_1032, 1 * 8);
+ uint64_t cgen_var_1036;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1036, 1);
+ stream->write((uint64_t*)&cgen_var_1036, 1 * 8);
marshal_VkSemaphoreGetWin32HandleInfoKHR(stream, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
stream->write((HANDLE*)pHandle, sizeof(HANDLE));
AEMU_SCOPED_TRACE("vkGetSemaphoreWin32HandleKHR readParams");
@@ -15323,6 +15654,7 @@
VkDevice device,
const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR encode");
mImpl->log("start vkImportSemaphoreFdKHR");
auto stream = mImpl->stream();
@@ -15345,9 +15677,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1033;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1033, 1);
- countingStream->write((uint64_t*)&cgen_var_1033, 1 * 8);
+ uint64_t cgen_var_1037;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1037, 1);
+ countingStream->write((uint64_t*)&cgen_var_1037, 1 * 8);
marshal_VkImportSemaphoreFdInfoKHR(countingStream, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo));
}
uint32_t packetSize_vkImportSemaphoreFdKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -15355,9 +15687,9 @@
uint32_t opcode_vkImportSemaphoreFdKHR = OP_vkImportSemaphoreFdKHR;
stream->write(&opcode_vkImportSemaphoreFdKHR, sizeof(uint32_t));
stream->write(&packetSize_vkImportSemaphoreFdKHR, sizeof(uint32_t));
- uint64_t cgen_var_1034;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1034, 1);
- stream->write((uint64_t*)&cgen_var_1034, 1 * 8);
+ uint64_t cgen_var_1038;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1038, 1);
+ stream->write((uint64_t*)&cgen_var_1038, 1 * 8);
marshal_VkImportSemaphoreFdInfoKHR(stream, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo));
AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR readParams");
AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR returnUnmarshal");
@@ -15375,6 +15707,7 @@
const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
int* pFd)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR encode");
mImpl->log("start vkGetSemaphoreFdKHR");
auto stream = mImpl->stream();
@@ -15397,9 +15730,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1035;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1035, 1);
- countingStream->write((uint64_t*)&cgen_var_1035, 1 * 8);
+ uint64_t cgen_var_1039;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1039, 1);
+ countingStream->write((uint64_t*)&cgen_var_1039, 1 * 8);
marshal_VkSemaphoreGetFdInfoKHR(countingStream, (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo));
countingStream->write((int*)pFd, sizeof(int));
}
@@ -15408,9 +15741,9 @@
uint32_t opcode_vkGetSemaphoreFdKHR = OP_vkGetSemaphoreFdKHR;
stream->write(&opcode_vkGetSemaphoreFdKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetSemaphoreFdKHR, sizeof(uint32_t));
- uint64_t cgen_var_1036;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1036, 1);
- stream->write((uint64_t*)&cgen_var_1036, 1 * 8);
+ uint64_t cgen_var_1040;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1040, 1);
+ stream->write((uint64_t*)&cgen_var_1040, 1 * 8);
marshal_VkSemaphoreGetFdInfoKHR(stream, (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo));
stream->write((int*)pFd, sizeof(int));
AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR readParams");
@@ -15435,6 +15768,7 @@
uint32_t descriptorWriteCount,
const VkWriteDescriptorSet* pDescriptorWrites)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetKHR encode");
mImpl->log("start vkCmdPushDescriptorSetKHR");
auto stream = mImpl->stream();
@@ -15471,13 +15805,13 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1037;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1037, 1);
- countingStream->write((uint64_t*)&cgen_var_1037, 1 * 8);
+ uint64_t cgen_var_1041;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1041, 1);
+ countingStream->write((uint64_t*)&cgen_var_1041, 1 * 8);
countingStream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
- uint64_t cgen_var_1038;
- countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1038, 1);
- countingStream->write((uint64_t*)&cgen_var_1038, 1 * 8);
+ uint64_t cgen_var_1042;
+ countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1042, 1);
+ countingStream->write((uint64_t*)&cgen_var_1042, 1 * 8);
countingStream->write((uint32_t*)&local_set, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
@@ -15490,13 +15824,13 @@
uint32_t opcode_vkCmdPushDescriptorSetKHR = OP_vkCmdPushDescriptorSetKHR;
stream->write(&opcode_vkCmdPushDescriptorSetKHR, sizeof(uint32_t));
stream->write(&packetSize_vkCmdPushDescriptorSetKHR, sizeof(uint32_t));
- uint64_t cgen_var_1039;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1039, 1);
- stream->write((uint64_t*)&cgen_var_1039, 1 * 8);
+ uint64_t cgen_var_1043;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1043, 1);
+ stream->write((uint64_t*)&cgen_var_1043, 1 * 8);
stream->write((VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
- uint64_t cgen_var_1040;
- stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1040, 1);
- stream->write((uint64_t*)&cgen_var_1040, 1 * 8);
+ uint64_t cgen_var_1044;
+ stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1044, 1);
+ stream->write((uint64_t*)&cgen_var_1044, 1 * 8);
stream->write((uint32_t*)&local_set, sizeof(uint32_t));
stream->write((uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
@@ -15515,6 +15849,7 @@
uint32_t set,
const void* pData)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetWithTemplateKHR encode");
mImpl->log("start vkCmdPushDescriptorSetWithTemplateKHR");
auto stream = mImpl->stream();
@@ -15538,19 +15873,19 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1041;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1041, 1);
- countingStream->write((uint64_t*)&cgen_var_1041, 1 * 8);
- uint64_t cgen_var_1042;
- countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1042, 1);
- countingStream->write((uint64_t*)&cgen_var_1042, 1 * 8);
- uint64_t cgen_var_1043;
- countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1043, 1);
- countingStream->write((uint64_t*)&cgen_var_1043, 1 * 8);
+ uint64_t cgen_var_1045;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1045, 1);
+ countingStream->write((uint64_t*)&cgen_var_1045, 1 * 8);
+ uint64_t cgen_var_1046;
+ countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1046, 1);
+ countingStream->write((uint64_t*)&cgen_var_1046, 1 * 8);
+ uint64_t cgen_var_1047;
+ countingStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1047, 1);
+ countingStream->write((uint64_t*)&cgen_var_1047, 1 * 8);
countingStream->write((uint32_t*)&local_set, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_1044 = (uint64_t)(uintptr_t)local_pData;
- countingStream->putBe64(cgen_var_1044);
+ uint64_t cgen_var_1048 = (uint64_t)(uintptr_t)local_pData;
+ countingStream->putBe64(cgen_var_1048);
if (local_pData)
{
countingStream->write((void*)local_pData, sizeof(uint8_t));
@@ -15561,19 +15896,19 @@
uint32_t opcode_vkCmdPushDescriptorSetWithTemplateKHR = OP_vkCmdPushDescriptorSetWithTemplateKHR;
stream->write(&opcode_vkCmdPushDescriptorSetWithTemplateKHR, sizeof(uint32_t));
stream->write(&packetSize_vkCmdPushDescriptorSetWithTemplateKHR, sizeof(uint32_t));
- uint64_t cgen_var_1045;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1045, 1);
- stream->write((uint64_t*)&cgen_var_1045, 1 * 8);
- uint64_t cgen_var_1046;
- stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1046, 1);
- stream->write((uint64_t*)&cgen_var_1046, 1 * 8);
- uint64_t cgen_var_1047;
- stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1047, 1);
- stream->write((uint64_t*)&cgen_var_1047, 1 * 8);
+ uint64_t cgen_var_1049;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1049, 1);
+ stream->write((uint64_t*)&cgen_var_1049, 1 * 8);
+ uint64_t cgen_var_1050;
+ stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1050, 1);
+ stream->write((uint64_t*)&cgen_var_1050, 1 * 8);
+ uint64_t cgen_var_1051;
+ stream->handleMapping()->mapHandles_VkPipelineLayout_u64(&local_layout, &cgen_var_1051, 1);
+ stream->write((uint64_t*)&cgen_var_1051, 1 * 8);
stream->write((uint32_t*)&local_set, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_1048 = (uint64_t)(uintptr_t)local_pData;
- stream->putBe64(cgen_var_1048);
+ uint64_t cgen_var_1052 = (uint64_t)(uintptr_t)local_pData;
+ stream->putBe64(cgen_var_1052);
if (local_pData)
{
stream->write((void*)local_pData, sizeof(uint8_t));
@@ -15595,6 +15930,7 @@
const VkAllocationCallbacks* pAllocator,
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR encode");
mImpl->log("start vkCreateDescriptorUpdateTemplateKHR");
auto stream = mImpl->stream();
@@ -15629,47 +15965,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1049;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1049, 1);
- countingStream->write((uint64_t*)&cgen_var_1049, 1 * 8);
+ uint64_t cgen_var_1053;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1053, 1);
+ countingStream->write((uint64_t*)&cgen_var_1053, 1 * 8);
marshal_VkDescriptorUpdateTemplateCreateInfo(countingStream, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1050 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1050);
+ uint64_t cgen_var_1054 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1054);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_1051;
- countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_1051, 1);
- countingStream->write((uint64_t*)&cgen_var_1051, 8);
+ uint64_t cgen_var_1055;
+ countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_1055, 1);
+ countingStream->write((uint64_t*)&cgen_var_1055, 8);
}
uint32_t packetSize_vkCreateDescriptorUpdateTemplateKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateDescriptorUpdateTemplateKHR = OP_vkCreateDescriptorUpdateTemplateKHR;
stream->write(&opcode_vkCreateDescriptorUpdateTemplateKHR, sizeof(uint32_t));
stream->write(&packetSize_vkCreateDescriptorUpdateTemplateKHR, sizeof(uint32_t));
- uint64_t cgen_var_1052;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1052, 1);
- stream->write((uint64_t*)&cgen_var_1052, 1 * 8);
+ uint64_t cgen_var_1056;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1056, 1);
+ stream->write((uint64_t*)&cgen_var_1056, 1 * 8);
marshal_VkDescriptorUpdateTemplateCreateInfo(stream, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1053 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1053);
+ uint64_t cgen_var_1057 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1057);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_1054;
- stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_1054, 1);
- stream->write((uint64_t*)&cgen_var_1054, 8);
+ uint64_t cgen_var_1058;
+ stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_1058, 1);
+ stream->write((uint64_t*)&cgen_var_1058, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_1055;
- stream->read((uint64_t*)&cgen_var_1055, 8);
- stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(&cgen_var_1055, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
+ uint64_t cgen_var_1059;
+ stream->read((uint64_t*)&cgen_var_1059, 8);
+ stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(&cgen_var_1059, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR returnUnmarshal");
VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
@@ -15677,7 +16013,9 @@
countingStream->clearPool();
stream->clearPool();
pool->freeAll();
+ encoderLock.unlock();
mImpl->resources()->on_vkCreateDescriptorUpdateTemplateKHR(this, vkCreateDescriptorUpdateTemplateKHR_VkResult_return, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+ encoderLock.lock();
mImpl->log("finish vkCreateDescriptorUpdateTemplateKHR");;
return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
}
@@ -15687,6 +16025,7 @@
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR encode");
mImpl->log("start vkDestroyDescriptorUpdateTemplateKHR");
auto stream = mImpl->stream();
@@ -15712,15 +16051,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1056;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1056, 1);
- countingStream->write((uint64_t*)&cgen_var_1056, 1 * 8);
- uint64_t cgen_var_1057;
- countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1057, 1);
- countingStream->write((uint64_t*)&cgen_var_1057, 1 * 8);
+ uint64_t cgen_var_1060;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1060, 1);
+ countingStream->write((uint64_t*)&cgen_var_1060, 1 * 8);
+ uint64_t cgen_var_1061;
+ countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1061, 1);
+ countingStream->write((uint64_t*)&cgen_var_1061, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1058 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1058);
+ uint64_t cgen_var_1062 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1062);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -15731,15 +16070,15 @@
uint32_t opcode_vkDestroyDescriptorUpdateTemplateKHR = OP_vkDestroyDescriptorUpdateTemplateKHR;
stream->write(&opcode_vkDestroyDescriptorUpdateTemplateKHR, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyDescriptorUpdateTemplateKHR, sizeof(uint32_t));
- uint64_t cgen_var_1059;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1059, 1);
- stream->write((uint64_t*)&cgen_var_1059, 1 * 8);
- uint64_t cgen_var_1060;
- stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1060, 1);
- stream->write((uint64_t*)&cgen_var_1060, 1 * 8);
+ uint64_t cgen_var_1063;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1063, 1);
+ stream->write((uint64_t*)&cgen_var_1063, 1 * 8);
+ uint64_t cgen_var_1064;
+ stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1064, 1);
+ stream->write((uint64_t*)&cgen_var_1064, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1061 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1061);
+ uint64_t cgen_var_1065 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1065);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -15756,6 +16095,7 @@
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const void* pData)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR encode");
mImpl->log("start vkUpdateDescriptorSetWithTemplateKHR");
auto stream = mImpl->stream();
@@ -15777,18 +16117,18 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1062;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1062, 1);
- countingStream->write((uint64_t*)&cgen_var_1062, 1 * 8);
- uint64_t cgen_var_1063;
- countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_1063, 1);
- countingStream->write((uint64_t*)&cgen_var_1063, 1 * 8);
- uint64_t cgen_var_1064;
- countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1064, 1);
- countingStream->write((uint64_t*)&cgen_var_1064, 1 * 8);
+ uint64_t cgen_var_1066;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1066, 1);
+ countingStream->write((uint64_t*)&cgen_var_1066, 1 * 8);
+ uint64_t cgen_var_1067;
+ countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_1067, 1);
+ countingStream->write((uint64_t*)&cgen_var_1067, 1 * 8);
+ uint64_t cgen_var_1068;
+ countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1068, 1);
+ countingStream->write((uint64_t*)&cgen_var_1068, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1065 = (uint64_t)(uintptr_t)local_pData;
- countingStream->putBe64(cgen_var_1065);
+ uint64_t cgen_var_1069 = (uint64_t)(uintptr_t)local_pData;
+ countingStream->putBe64(cgen_var_1069);
if (local_pData)
{
countingStream->write((void*)local_pData, sizeof(uint8_t));
@@ -15799,18 +16139,18 @@
uint32_t opcode_vkUpdateDescriptorSetWithTemplateKHR = OP_vkUpdateDescriptorSetWithTemplateKHR;
stream->write(&opcode_vkUpdateDescriptorSetWithTemplateKHR, sizeof(uint32_t));
stream->write(&packetSize_vkUpdateDescriptorSetWithTemplateKHR, sizeof(uint32_t));
- uint64_t cgen_var_1066;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1066, 1);
- stream->write((uint64_t*)&cgen_var_1066, 1 * 8);
- uint64_t cgen_var_1067;
- stream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_1067, 1);
- stream->write((uint64_t*)&cgen_var_1067, 1 * 8);
- uint64_t cgen_var_1068;
- stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1068, 1);
- stream->write((uint64_t*)&cgen_var_1068, 1 * 8);
+ uint64_t cgen_var_1070;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1070, 1);
+ stream->write((uint64_t*)&cgen_var_1070, 1 * 8);
+ uint64_t cgen_var_1071;
+ stream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_1071, 1);
+ stream->write((uint64_t*)&cgen_var_1071, 1 * 8);
+ uint64_t cgen_var_1072;
+ stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1072, 1);
+ stream->write((uint64_t*)&cgen_var_1072, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1069 = (uint64_t)(uintptr_t)local_pData;
- stream->putBe64(cgen_var_1069);
+ uint64_t cgen_var_1073 = (uint64_t)(uintptr_t)local_pData;
+ stream->putBe64(cgen_var_1073);
if (local_pData)
{
stream->write((void*)local_pData, sizeof(uint8_t));
@@ -15828,6 +16168,7 @@
const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR encode");
mImpl->log("start vkCreateRenderPass2KHR");
auto stream = mImpl->stream();
@@ -15862,46 +16203,46 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1070;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1070, 1);
- countingStream->write((uint64_t*)&cgen_var_1070, 1 * 8);
+ uint64_t cgen_var_1074;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1074, 1);
+ countingStream->write((uint64_t*)&cgen_var_1074, 1 * 8);
marshal_VkRenderPassCreateInfo2KHR(countingStream, (VkRenderPassCreateInfo2KHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1071 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1071);
+ uint64_t cgen_var_1075 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1075);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_1072;
- countingStream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_1072, 1);
- countingStream->write((uint64_t*)&cgen_var_1072, 8);
+ uint64_t cgen_var_1076;
+ countingStream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_1076, 1);
+ countingStream->write((uint64_t*)&cgen_var_1076, 8);
}
uint32_t packetSize_vkCreateRenderPass2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateRenderPass2KHR = OP_vkCreateRenderPass2KHR;
stream->write(&opcode_vkCreateRenderPass2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkCreateRenderPass2KHR, sizeof(uint32_t));
- uint64_t cgen_var_1073;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1073, 1);
- stream->write((uint64_t*)&cgen_var_1073, 1 * 8);
+ uint64_t cgen_var_1077;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1077, 1);
+ stream->write((uint64_t*)&cgen_var_1077, 1 * 8);
marshal_VkRenderPassCreateInfo2KHR(stream, (VkRenderPassCreateInfo2KHR*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1074 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1074);
+ uint64_t cgen_var_1078 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1078);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_1075;
- stream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_1075, 1);
- stream->write((uint64_t*)&cgen_var_1075, 8);
+ uint64_t cgen_var_1079;
+ stream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_1079, 1);
+ stream->write((uint64_t*)&cgen_var_1079, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR readParams");
- uint64_t cgen_var_1076;
- stream->read((uint64_t*)&cgen_var_1076, 8);
- stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_1076, (VkRenderPass*)pRenderPass, 1);
+ uint64_t cgen_var_1080;
+ stream->read((uint64_t*)&cgen_var_1080, 8);
+ stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_1080, (VkRenderPass*)pRenderPass, 1);
AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR returnUnmarshal");
VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateRenderPass2KHR_VkResult_return, sizeof(VkResult));
@@ -15917,6 +16258,7 @@
const VkRenderPassBeginInfo* pRenderPassBegin,
const VkSubpassBeginInfoKHR* pSubpassBeginInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR encode");
mImpl->log("start vkCmdBeginRenderPass2KHR");
auto stream = mImpl->stream();
@@ -15950,9 +16292,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1077;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1077, 1);
- countingStream->write((uint64_t*)&cgen_var_1077, 1 * 8);
+ uint64_t cgen_var_1081;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1081, 1);
+ countingStream->write((uint64_t*)&cgen_var_1081, 1 * 8);
marshal_VkRenderPassBeginInfo(countingStream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
marshal_VkSubpassBeginInfoKHR(countingStream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
}
@@ -15961,9 +16303,9 @@
uint32_t opcode_vkCmdBeginRenderPass2KHR = OP_vkCmdBeginRenderPass2KHR;
stream->write(&opcode_vkCmdBeginRenderPass2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkCmdBeginRenderPass2KHR, sizeof(uint32_t));
- uint64_t cgen_var_1078;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1078, 1);
- stream->write((uint64_t*)&cgen_var_1078, 1 * 8);
+ uint64_t cgen_var_1082;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1082, 1);
+ stream->write((uint64_t*)&cgen_var_1082, 1 * 8);
marshal_VkRenderPassBeginInfo(stream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
marshal_VkSubpassBeginInfoKHR(stream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR readParams");
@@ -15976,6 +16318,7 @@
const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
const VkSubpassEndInfoKHR* pSubpassEndInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR encode");
mImpl->log("start vkCmdNextSubpass2KHR");
auto stream = mImpl->stream();
@@ -16009,9 +16352,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1079;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1079, 1);
- countingStream->write((uint64_t*)&cgen_var_1079, 1 * 8);
+ uint64_t cgen_var_1083;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1083, 1);
+ countingStream->write((uint64_t*)&cgen_var_1083, 1 * 8);
marshal_VkSubpassBeginInfoKHR(countingStream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
marshal_VkSubpassEndInfoKHR(countingStream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
}
@@ -16020,9 +16363,9 @@
uint32_t opcode_vkCmdNextSubpass2KHR = OP_vkCmdNextSubpass2KHR;
stream->write(&opcode_vkCmdNextSubpass2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkCmdNextSubpass2KHR, sizeof(uint32_t));
- uint64_t cgen_var_1080;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1080, 1);
- stream->write((uint64_t*)&cgen_var_1080, 1 * 8);
+ uint64_t cgen_var_1084;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1084, 1);
+ stream->write((uint64_t*)&cgen_var_1084, 1 * 8);
marshal_VkSubpassBeginInfoKHR(stream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo));
marshal_VkSubpassEndInfoKHR(stream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR readParams");
@@ -16034,6 +16377,7 @@
VkCommandBuffer commandBuffer,
const VkSubpassEndInfoKHR* pSubpassEndInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR encode");
mImpl->log("start vkCmdEndRenderPass2KHR");
auto stream = mImpl->stream();
@@ -16056,9 +16400,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1081;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1081, 1);
- countingStream->write((uint64_t*)&cgen_var_1081, 1 * 8);
+ uint64_t cgen_var_1085;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1085, 1);
+ countingStream->write((uint64_t*)&cgen_var_1085, 1 * 8);
marshal_VkSubpassEndInfoKHR(countingStream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
}
uint32_t packetSize_vkCmdEndRenderPass2KHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -16066,9 +16410,9 @@
uint32_t opcode_vkCmdEndRenderPass2KHR = OP_vkCmdEndRenderPass2KHR;
stream->write(&opcode_vkCmdEndRenderPass2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkCmdEndRenderPass2KHR, sizeof(uint32_t));
- uint64_t cgen_var_1082;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1082, 1);
- stream->write((uint64_t*)&cgen_var_1082, 1 * 8);
+ uint64_t cgen_var_1086;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1086, 1);
+ stream->write((uint64_t*)&cgen_var_1086, 1 * 8);
marshal_VkSubpassEndInfoKHR(stream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo));
AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR readParams");
AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR returnUnmarshal");
@@ -16081,6 +16425,7 @@
VkDevice device,
VkSwapchainKHR swapchain)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetSwapchainStatusKHR encode");
mImpl->log("start vkGetSwapchainStatusKHR");
auto stream = mImpl->stream();
@@ -16094,24 +16439,24 @@
local_swapchain = swapchain;
countingStream->rewind();
{
- uint64_t cgen_var_1083;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1083, 1);
- countingStream->write((uint64_t*)&cgen_var_1083, 1 * 8);
- uint64_t cgen_var_1084;
- countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1084, 1);
- countingStream->write((uint64_t*)&cgen_var_1084, 1 * 8);
+ uint64_t cgen_var_1087;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1087, 1);
+ countingStream->write((uint64_t*)&cgen_var_1087, 1 * 8);
+ uint64_t cgen_var_1088;
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1088, 1);
+ countingStream->write((uint64_t*)&cgen_var_1088, 1 * 8);
}
uint32_t packetSize_vkGetSwapchainStatusKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkGetSwapchainStatusKHR = OP_vkGetSwapchainStatusKHR;
stream->write(&opcode_vkGetSwapchainStatusKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetSwapchainStatusKHR, sizeof(uint32_t));
- uint64_t cgen_var_1085;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1085, 1);
- stream->write((uint64_t*)&cgen_var_1085, 1 * 8);
- uint64_t cgen_var_1086;
- stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1086, 1);
- stream->write((uint64_t*)&cgen_var_1086, 1 * 8);
+ uint64_t cgen_var_1089;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1089, 1);
+ stream->write((uint64_t*)&cgen_var_1089, 1 * 8);
+ uint64_t cgen_var_1090;
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1090, 1);
+ stream->write((uint64_t*)&cgen_var_1090, 1 * 8);
AEMU_SCOPED_TRACE("vkGetSwapchainStatusKHR readParams");
AEMU_SCOPED_TRACE("vkGetSwapchainStatusKHR returnUnmarshal");
VkResult vkGetSwapchainStatusKHR_VkResult_return = (VkResult)0;
@@ -16130,6 +16475,7 @@
const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
VkExternalFenceProperties* pExternalFenceProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFencePropertiesKHR encode");
mImpl->log("start vkGetPhysicalDeviceExternalFencePropertiesKHR");
auto stream = mImpl->stream();
@@ -16152,9 +16498,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1087;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1087, 1);
- countingStream->write((uint64_t*)&cgen_var_1087, 1 * 8);
+ uint64_t cgen_var_1091;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1091, 1);
+ countingStream->write((uint64_t*)&cgen_var_1091, 1 * 8);
marshal_VkPhysicalDeviceExternalFenceInfo(countingStream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
marshal_VkExternalFenceProperties(countingStream, (VkExternalFenceProperties*)(pExternalFenceProperties));
}
@@ -16163,9 +16509,9 @@
uint32_t opcode_vkGetPhysicalDeviceExternalFencePropertiesKHR = OP_vkGetPhysicalDeviceExternalFencePropertiesKHR;
stream->write(&opcode_vkGetPhysicalDeviceExternalFencePropertiesKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceExternalFencePropertiesKHR, sizeof(uint32_t));
- uint64_t cgen_var_1088;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1088, 1);
- stream->write((uint64_t*)&cgen_var_1088, 1 * 8);
+ uint64_t cgen_var_1092;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1092, 1);
+ stream->write((uint64_t*)&cgen_var_1092, 1 * 8);
marshal_VkPhysicalDeviceExternalFenceInfo(stream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
marshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFencePropertiesKHR readParams");
@@ -16186,6 +16532,7 @@
VkDevice device,
const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkImportFenceWin32HandleKHR encode");
mImpl->log("start vkImportFenceWin32HandleKHR");
auto stream = mImpl->stream();
@@ -16208,9 +16555,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1089;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1089, 1);
- countingStream->write((uint64_t*)&cgen_var_1089, 1 * 8);
+ uint64_t cgen_var_1093;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1093, 1);
+ countingStream->write((uint64_t*)&cgen_var_1093, 1 * 8);
marshal_VkImportFenceWin32HandleInfoKHR(countingStream, (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo));
}
uint32_t packetSize_vkImportFenceWin32HandleKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -16218,9 +16565,9 @@
uint32_t opcode_vkImportFenceWin32HandleKHR = OP_vkImportFenceWin32HandleKHR;
stream->write(&opcode_vkImportFenceWin32HandleKHR, sizeof(uint32_t));
stream->write(&packetSize_vkImportFenceWin32HandleKHR, sizeof(uint32_t));
- uint64_t cgen_var_1090;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1090, 1);
- stream->write((uint64_t*)&cgen_var_1090, 1 * 8);
+ uint64_t cgen_var_1094;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1094, 1);
+ stream->write((uint64_t*)&cgen_var_1094, 1 * 8);
marshal_VkImportFenceWin32HandleInfoKHR(stream, (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo));
AEMU_SCOPED_TRACE("vkImportFenceWin32HandleKHR readParams");
AEMU_SCOPED_TRACE("vkImportFenceWin32HandleKHR returnUnmarshal");
@@ -16238,6 +16585,7 @@
const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
HANDLE* pHandle)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetFenceWin32HandleKHR encode");
mImpl->log("start vkGetFenceWin32HandleKHR");
auto stream = mImpl->stream();
@@ -16260,9 +16608,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1091;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1091, 1);
- countingStream->write((uint64_t*)&cgen_var_1091, 1 * 8);
+ uint64_t cgen_var_1095;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1095, 1);
+ countingStream->write((uint64_t*)&cgen_var_1095, 1 * 8);
marshal_VkFenceGetWin32HandleInfoKHR(countingStream, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
countingStream->write((HANDLE*)pHandle, sizeof(HANDLE));
}
@@ -16271,9 +16619,9 @@
uint32_t opcode_vkGetFenceWin32HandleKHR = OP_vkGetFenceWin32HandleKHR;
stream->write(&opcode_vkGetFenceWin32HandleKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetFenceWin32HandleKHR, sizeof(uint32_t));
- uint64_t cgen_var_1092;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1092, 1);
- stream->write((uint64_t*)&cgen_var_1092, 1 * 8);
+ uint64_t cgen_var_1096;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1096, 1);
+ stream->write((uint64_t*)&cgen_var_1096, 1 * 8);
marshal_VkFenceGetWin32HandleInfoKHR(stream, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
stream->write((HANDLE*)pHandle, sizeof(HANDLE));
AEMU_SCOPED_TRACE("vkGetFenceWin32HandleKHR readParams");
@@ -16294,6 +16642,7 @@
VkDevice device,
const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkImportFenceFdKHR encode");
mImpl->log("start vkImportFenceFdKHR");
auto stream = mImpl->stream();
@@ -16316,9 +16665,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1093;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1093, 1);
- countingStream->write((uint64_t*)&cgen_var_1093, 1 * 8);
+ uint64_t cgen_var_1097;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1097, 1);
+ countingStream->write((uint64_t*)&cgen_var_1097, 1 * 8);
marshal_VkImportFenceFdInfoKHR(countingStream, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo));
}
uint32_t packetSize_vkImportFenceFdKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -16326,9 +16675,9 @@
uint32_t opcode_vkImportFenceFdKHR = OP_vkImportFenceFdKHR;
stream->write(&opcode_vkImportFenceFdKHR, sizeof(uint32_t));
stream->write(&packetSize_vkImportFenceFdKHR, sizeof(uint32_t));
- uint64_t cgen_var_1094;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1094, 1);
- stream->write((uint64_t*)&cgen_var_1094, 1 * 8);
+ uint64_t cgen_var_1098;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1098, 1);
+ stream->write((uint64_t*)&cgen_var_1098, 1 * 8);
marshal_VkImportFenceFdInfoKHR(stream, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo));
AEMU_SCOPED_TRACE("vkImportFenceFdKHR readParams");
AEMU_SCOPED_TRACE("vkImportFenceFdKHR returnUnmarshal");
@@ -16346,6 +16695,7 @@
const VkFenceGetFdInfoKHR* pGetFdInfo,
int* pFd)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetFenceFdKHR encode");
mImpl->log("start vkGetFenceFdKHR");
auto stream = mImpl->stream();
@@ -16368,9 +16718,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1095;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1095, 1);
- countingStream->write((uint64_t*)&cgen_var_1095, 1 * 8);
+ uint64_t cgen_var_1099;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1099, 1);
+ countingStream->write((uint64_t*)&cgen_var_1099, 1 * 8);
marshal_VkFenceGetFdInfoKHR(countingStream, (VkFenceGetFdInfoKHR*)(local_pGetFdInfo));
countingStream->write((int*)pFd, sizeof(int));
}
@@ -16379,9 +16729,9 @@
uint32_t opcode_vkGetFenceFdKHR = OP_vkGetFenceFdKHR;
stream->write(&opcode_vkGetFenceFdKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetFenceFdKHR, sizeof(uint32_t));
- uint64_t cgen_var_1096;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1096, 1);
- stream->write((uint64_t*)&cgen_var_1096, 1 * 8);
+ uint64_t cgen_var_1100;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1100, 1);
+ stream->write((uint64_t*)&cgen_var_1100, 1 * 8);
marshal_VkFenceGetFdInfoKHR(stream, (VkFenceGetFdInfoKHR*)(local_pGetFdInfo));
stream->write((int*)pFd, sizeof(int));
AEMU_SCOPED_TRACE("vkGetFenceFdKHR readParams");
@@ -16405,6 +16755,7 @@
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2KHR encode");
mImpl->log("start vkGetPhysicalDeviceSurfaceCapabilities2KHR");
auto stream = mImpl->stream();
@@ -16427,9 +16778,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1097;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1097, 1);
- countingStream->write((uint64_t*)&cgen_var_1097, 1 * 8);
+ uint64_t cgen_var_1101;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1101, 1);
+ countingStream->write((uint64_t*)&cgen_var_1101, 1 * 8);
marshal_VkPhysicalDeviceSurfaceInfo2KHR(countingStream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
marshal_VkSurfaceCapabilities2KHR(countingStream, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities));
}
@@ -16438,9 +16789,9 @@
uint32_t opcode_vkGetPhysicalDeviceSurfaceCapabilities2KHR = OP_vkGetPhysicalDeviceSurfaceCapabilities2KHR;
stream->write(&opcode_vkGetPhysicalDeviceSurfaceCapabilities2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceSurfaceCapabilities2KHR, sizeof(uint32_t));
- uint64_t cgen_var_1098;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1098, 1);
- stream->write((uint64_t*)&cgen_var_1098, 1 * 8);
+ uint64_t cgen_var_1102;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1102, 1);
+ stream->write((uint64_t*)&cgen_var_1102, 1 * 8);
marshal_VkPhysicalDeviceSurfaceInfo2KHR(stream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
marshal_VkSurfaceCapabilities2KHR(stream, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2KHR readParams");
@@ -16465,6 +16816,7 @@
uint32_t* pSurfaceFormatCount,
VkSurfaceFormat2KHR* pSurfaceFormats)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormats2KHR encode");
mImpl->log("start vkGetPhysicalDeviceSurfaceFormats2KHR");
auto stream = mImpl->stream();
@@ -16487,20 +16839,20 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1099;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1099, 1);
- countingStream->write((uint64_t*)&cgen_var_1099, 1 * 8);
+ uint64_t cgen_var_1103;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1103, 1);
+ countingStream->write((uint64_t*)&cgen_var_1103, 1 * 8);
marshal_VkPhysicalDeviceSurfaceInfo2KHR(countingStream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1100 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
- countingStream->putBe64(cgen_var_1100);
+ uint64_t cgen_var_1104 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
+ countingStream->putBe64(cgen_var_1104);
if (pSurfaceFormatCount)
{
countingStream->write((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1101 = (uint64_t)(uintptr_t)pSurfaceFormats;
- countingStream->putBe64(cgen_var_1101);
+ uint64_t cgen_var_1105 = (uint64_t)(uintptr_t)pSurfaceFormats;
+ countingStream->putBe64(cgen_var_1105);
if (pSurfaceFormats)
{
for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
@@ -16514,20 +16866,20 @@
uint32_t opcode_vkGetPhysicalDeviceSurfaceFormats2KHR = OP_vkGetPhysicalDeviceSurfaceFormats2KHR;
stream->write(&opcode_vkGetPhysicalDeviceSurfaceFormats2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceSurfaceFormats2KHR, sizeof(uint32_t));
- uint64_t cgen_var_1102;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1102, 1);
- stream->write((uint64_t*)&cgen_var_1102, 1 * 8);
+ uint64_t cgen_var_1106;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1106, 1);
+ stream->write((uint64_t*)&cgen_var_1106, 1 * 8);
marshal_VkPhysicalDeviceSurfaceInfo2KHR(stream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1103 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
- stream->putBe64(cgen_var_1103);
+ uint64_t cgen_var_1107 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
+ stream->putBe64(cgen_var_1107);
if (pSurfaceFormatCount)
{
stream->write((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1104 = (uint64_t)(uintptr_t)pSurfaceFormats;
- stream->putBe64(cgen_var_1104);
+ uint64_t cgen_var_1108 = (uint64_t)(uintptr_t)pSurfaceFormats;
+ stream->putBe64(cgen_var_1108);
if (pSurfaceFormats)
{
for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
@@ -16587,6 +16939,7 @@
uint32_t* pPropertyCount,
VkDisplayProperties2KHR* pProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayProperties2KHR encode");
mImpl->log("start vkGetPhysicalDeviceDisplayProperties2KHR");
auto stream = mImpl->stream();
@@ -16598,19 +16951,19 @@
local_physicalDevice = physicalDevice;
countingStream->rewind();
{
- uint64_t cgen_var_1107;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1107, 1);
- countingStream->write((uint64_t*)&cgen_var_1107, 1 * 8);
+ uint64_t cgen_var_1111;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1111, 1);
+ countingStream->write((uint64_t*)&cgen_var_1111, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1108 = (uint64_t)(uintptr_t)pPropertyCount;
- countingStream->putBe64(cgen_var_1108);
+ uint64_t cgen_var_1112 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_1112);
if (pPropertyCount)
{
countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1109 = (uint64_t)(uintptr_t)pProperties;
- countingStream->putBe64(cgen_var_1109);
+ uint64_t cgen_var_1113 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_1113);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -16624,19 +16977,19 @@
uint32_t opcode_vkGetPhysicalDeviceDisplayProperties2KHR = OP_vkGetPhysicalDeviceDisplayProperties2KHR;
stream->write(&opcode_vkGetPhysicalDeviceDisplayProperties2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceDisplayProperties2KHR, sizeof(uint32_t));
- uint64_t cgen_var_1110;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1110, 1);
- stream->write((uint64_t*)&cgen_var_1110, 1 * 8);
+ uint64_t cgen_var_1114;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1114, 1);
+ stream->write((uint64_t*)&cgen_var_1114, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1111 = (uint64_t)(uintptr_t)pPropertyCount;
- stream->putBe64(cgen_var_1111);
+ uint64_t cgen_var_1115 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_1115);
if (pPropertyCount)
{
stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1112 = (uint64_t)(uintptr_t)pProperties;
- stream->putBe64(cgen_var_1112);
+ uint64_t cgen_var_1116 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_1116);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -16692,6 +17045,7 @@
uint32_t* pPropertyCount,
VkDisplayPlaneProperties2KHR* pProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlaneProperties2KHR encode");
mImpl->log("start vkGetPhysicalDeviceDisplayPlaneProperties2KHR");
auto stream = mImpl->stream();
@@ -16703,19 +17057,19 @@
local_physicalDevice = physicalDevice;
countingStream->rewind();
{
- uint64_t cgen_var_1115;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1115, 1);
- countingStream->write((uint64_t*)&cgen_var_1115, 1 * 8);
+ uint64_t cgen_var_1119;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1119, 1);
+ countingStream->write((uint64_t*)&cgen_var_1119, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1116 = (uint64_t)(uintptr_t)pPropertyCount;
- countingStream->putBe64(cgen_var_1116);
+ uint64_t cgen_var_1120 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_1120);
if (pPropertyCount)
{
countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1117 = (uint64_t)(uintptr_t)pProperties;
- countingStream->putBe64(cgen_var_1117);
+ uint64_t cgen_var_1121 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_1121);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -16729,19 +17083,19 @@
uint32_t opcode_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = OP_vkGetPhysicalDeviceDisplayPlaneProperties2KHR;
stream->write(&opcode_vkGetPhysicalDeviceDisplayPlaneProperties2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceDisplayPlaneProperties2KHR, sizeof(uint32_t));
- uint64_t cgen_var_1118;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1118, 1);
- stream->write((uint64_t*)&cgen_var_1118, 1 * 8);
+ uint64_t cgen_var_1122;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1122, 1);
+ stream->write((uint64_t*)&cgen_var_1122, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1119 = (uint64_t)(uintptr_t)pPropertyCount;
- stream->putBe64(cgen_var_1119);
+ uint64_t cgen_var_1123 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_1123);
if (pPropertyCount)
{
stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1120 = (uint64_t)(uintptr_t)pProperties;
- stream->putBe64(cgen_var_1120);
+ uint64_t cgen_var_1124 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_1124);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -16798,6 +17152,7 @@
uint32_t* pPropertyCount,
VkDisplayModeProperties2KHR* pProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetDisplayModeProperties2KHR encode");
mImpl->log("start vkGetDisplayModeProperties2KHR");
auto stream = mImpl->stream();
@@ -16811,22 +17166,22 @@
local_display = display;
countingStream->rewind();
{
- uint64_t cgen_var_1123;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1123, 1);
- countingStream->write((uint64_t*)&cgen_var_1123, 1 * 8);
- uint64_t cgen_var_1124;
- countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1124, 1);
- countingStream->write((uint64_t*)&cgen_var_1124, 1 * 8);
+ uint64_t cgen_var_1127;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1127, 1);
+ countingStream->write((uint64_t*)&cgen_var_1127, 1 * 8);
+ uint64_t cgen_var_1128;
+ countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1128, 1);
+ countingStream->write((uint64_t*)&cgen_var_1128, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1125 = (uint64_t)(uintptr_t)pPropertyCount;
- countingStream->putBe64(cgen_var_1125);
+ uint64_t cgen_var_1129 = (uint64_t)(uintptr_t)pPropertyCount;
+ countingStream->putBe64(cgen_var_1129);
if (pPropertyCount)
{
countingStream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1126 = (uint64_t)(uintptr_t)pProperties;
- countingStream->putBe64(cgen_var_1126);
+ uint64_t cgen_var_1130 = (uint64_t)(uintptr_t)pProperties;
+ countingStream->putBe64(cgen_var_1130);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -16840,22 +17195,22 @@
uint32_t opcode_vkGetDisplayModeProperties2KHR = OP_vkGetDisplayModeProperties2KHR;
stream->write(&opcode_vkGetDisplayModeProperties2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetDisplayModeProperties2KHR, sizeof(uint32_t));
- uint64_t cgen_var_1127;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1127, 1);
- stream->write((uint64_t*)&cgen_var_1127, 1 * 8);
- uint64_t cgen_var_1128;
- stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1128, 1);
- stream->write((uint64_t*)&cgen_var_1128, 1 * 8);
+ uint64_t cgen_var_1131;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1131, 1);
+ stream->write((uint64_t*)&cgen_var_1131, 1 * 8);
+ uint64_t cgen_var_1132;
+ stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1132, 1);
+ stream->write((uint64_t*)&cgen_var_1132, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1129 = (uint64_t)(uintptr_t)pPropertyCount;
- stream->putBe64(cgen_var_1129);
+ uint64_t cgen_var_1133 = (uint64_t)(uintptr_t)pPropertyCount;
+ stream->putBe64(cgen_var_1133);
if (pPropertyCount)
{
stream->write((uint32_t*)pPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1130 = (uint64_t)(uintptr_t)pProperties;
- stream->putBe64(cgen_var_1130);
+ uint64_t cgen_var_1134 = (uint64_t)(uintptr_t)pProperties;
+ stream->putBe64(cgen_var_1134);
if (pProperties)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
@@ -16911,6 +17266,7 @@
const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
VkDisplayPlaneCapabilities2KHR* pCapabilities)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilities2KHR encode");
mImpl->log("start vkGetDisplayPlaneCapabilities2KHR");
auto stream = mImpl->stream();
@@ -16933,9 +17289,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1133;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1133, 1);
- countingStream->write((uint64_t*)&cgen_var_1133, 1 * 8);
+ uint64_t cgen_var_1137;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1137, 1);
+ countingStream->write((uint64_t*)&cgen_var_1137, 1 * 8);
marshal_VkDisplayPlaneInfo2KHR(countingStream, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo));
marshal_VkDisplayPlaneCapabilities2KHR(countingStream, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities));
}
@@ -16944,9 +17300,9 @@
uint32_t opcode_vkGetDisplayPlaneCapabilities2KHR = OP_vkGetDisplayPlaneCapabilities2KHR;
stream->write(&opcode_vkGetDisplayPlaneCapabilities2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetDisplayPlaneCapabilities2KHR, sizeof(uint32_t));
- uint64_t cgen_var_1134;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1134, 1);
- stream->write((uint64_t*)&cgen_var_1134, 1 * 8);
+ uint64_t cgen_var_1138;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1138, 1);
+ stream->write((uint64_t*)&cgen_var_1138, 1 * 8);
marshal_VkDisplayPlaneInfo2KHR(stream, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo));
marshal_VkDisplayPlaneCapabilities2KHR(stream, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities));
AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilities2KHR readParams");
@@ -16978,6 +17334,7 @@
const VkImageMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR encode");
mImpl->log("start vkGetImageMemoryRequirements2KHR");
auto stream = mImpl->stream();
@@ -17000,9 +17357,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1135;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1135, 1);
- countingStream->write((uint64_t*)&cgen_var_1135, 1 * 8);
+ uint64_t cgen_var_1139;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1139, 1);
+ countingStream->write((uint64_t*)&cgen_var_1139, 1 * 8);
marshal_VkImageMemoryRequirementsInfo2(countingStream, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
marshal_VkMemoryRequirements2(countingStream, (VkMemoryRequirements2*)(pMemoryRequirements));
}
@@ -17011,9 +17368,9 @@
uint32_t opcode_vkGetImageMemoryRequirements2KHR = OP_vkGetImageMemoryRequirements2KHR;
stream->write(&opcode_vkGetImageMemoryRequirements2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetImageMemoryRequirements2KHR, sizeof(uint32_t));
- uint64_t cgen_var_1136;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1136, 1);
- stream->write((uint64_t*)&cgen_var_1136, 1 * 8);
+ uint64_t cgen_var_1140;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1140, 1);
+ stream->write((uint64_t*)&cgen_var_1140, 1 * 8);
marshal_VkImageMemoryRequirementsInfo2(stream, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR readParams");
@@ -17031,6 +17388,7 @@
const VkBufferMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR encode");
mImpl->log("start vkGetBufferMemoryRequirements2KHR");
auto stream = mImpl->stream();
@@ -17053,9 +17411,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1137;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1137, 1);
- countingStream->write((uint64_t*)&cgen_var_1137, 1 * 8);
+ uint64_t cgen_var_1141;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1141, 1);
+ countingStream->write((uint64_t*)&cgen_var_1141, 1 * 8);
marshal_VkBufferMemoryRequirementsInfo2(countingStream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
marshal_VkMemoryRequirements2(countingStream, (VkMemoryRequirements2*)(pMemoryRequirements));
}
@@ -17064,9 +17422,9 @@
uint32_t opcode_vkGetBufferMemoryRequirements2KHR = OP_vkGetBufferMemoryRequirements2KHR;
stream->write(&opcode_vkGetBufferMemoryRequirements2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetBufferMemoryRequirements2KHR, sizeof(uint32_t));
- uint64_t cgen_var_1138;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1138, 1);
- stream->write((uint64_t*)&cgen_var_1138, 1 * 8);
+ uint64_t cgen_var_1142;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1142, 1);
+ stream->write((uint64_t*)&cgen_var_1142, 1 * 8);
marshal_VkBufferMemoryRequirementsInfo2(stream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements));
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR readParams");
@@ -17085,6 +17443,7 @@
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR encode");
mImpl->log("start vkGetImageSparseMemoryRequirements2KHR");
auto stream = mImpl->stream();
@@ -17107,20 +17466,20 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1139;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1139, 1);
- countingStream->write((uint64_t*)&cgen_var_1139, 1 * 8);
+ uint64_t cgen_var_1143;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1143, 1);
+ countingStream->write((uint64_t*)&cgen_var_1143, 1 * 8);
marshal_VkImageSparseMemoryRequirementsInfo2(countingStream, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1140 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
- countingStream->putBe64(cgen_var_1140);
+ uint64_t cgen_var_1144 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+ countingStream->putBe64(cgen_var_1144);
if (pSparseMemoryRequirementCount)
{
countingStream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1141 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
- countingStream->putBe64(cgen_var_1141);
+ uint64_t cgen_var_1145 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+ countingStream->putBe64(cgen_var_1145);
if (pSparseMemoryRequirements)
{
for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
@@ -17134,20 +17493,20 @@
uint32_t opcode_vkGetImageSparseMemoryRequirements2KHR = OP_vkGetImageSparseMemoryRequirements2KHR;
stream->write(&opcode_vkGetImageSparseMemoryRequirements2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetImageSparseMemoryRequirements2KHR, sizeof(uint32_t));
- uint64_t cgen_var_1142;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1142, 1);
- stream->write((uint64_t*)&cgen_var_1142, 1 * 8);
+ uint64_t cgen_var_1146;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1146, 1);
+ stream->write((uint64_t*)&cgen_var_1146, 1 * 8);
marshal_VkImageSparseMemoryRequirementsInfo2(stream, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1143 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
- stream->putBe64(cgen_var_1143);
+ uint64_t cgen_var_1147 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+ stream->putBe64(cgen_var_1147);
if (pSparseMemoryRequirementCount)
{
stream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1144 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
- stream->putBe64(cgen_var_1144);
+ uint64_t cgen_var_1148 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+ stream->putBe64(cgen_var_1148);
if (pSparseMemoryRequirements)
{
for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
@@ -17202,6 +17561,7 @@
const VkAllocationCallbacks* pAllocator,
VkSamplerYcbcrConversion* pYcbcrConversion)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR encode");
mImpl->log("start vkCreateSamplerYcbcrConversionKHR");
auto stream = mImpl->stream();
@@ -17236,47 +17596,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1147;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1147, 1);
- countingStream->write((uint64_t*)&cgen_var_1147, 1 * 8);
+ uint64_t cgen_var_1151;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1151, 1);
+ countingStream->write((uint64_t*)&cgen_var_1151, 1 * 8);
marshal_VkSamplerYcbcrConversionCreateInfo(countingStream, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1148 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1148);
+ uint64_t cgen_var_1152 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1152);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_1149;
- countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_1149, 1);
- countingStream->write((uint64_t*)&cgen_var_1149, 8);
+ uint64_t cgen_var_1153;
+ countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_1153, 1);
+ countingStream->write((uint64_t*)&cgen_var_1153, 8);
}
uint32_t packetSize_vkCreateSamplerYcbcrConversionKHR = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateSamplerYcbcrConversionKHR = OP_vkCreateSamplerYcbcrConversionKHR;
stream->write(&opcode_vkCreateSamplerYcbcrConversionKHR, sizeof(uint32_t));
stream->write(&packetSize_vkCreateSamplerYcbcrConversionKHR, sizeof(uint32_t));
- uint64_t cgen_var_1150;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1150, 1);
- stream->write((uint64_t*)&cgen_var_1150, 1 * 8);
+ uint64_t cgen_var_1154;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1154, 1);
+ stream->write((uint64_t*)&cgen_var_1154, 1 * 8);
marshal_VkSamplerYcbcrConversionCreateInfo(stream, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1151 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1151);
+ uint64_t cgen_var_1155 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1155);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_1152;
- stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_1152, 1);
- stream->write((uint64_t*)&cgen_var_1152, 8);
+ uint64_t cgen_var_1156;
+ stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_1156, 1);
+ stream->write((uint64_t*)&cgen_var_1156, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_1153;
- stream->read((uint64_t*)&cgen_var_1153, 8);
- stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_1153, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
+ uint64_t cgen_var_1157;
+ stream->read((uint64_t*)&cgen_var_1157, 8);
+ stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_1157, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR returnUnmarshal");
VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
@@ -17293,6 +17653,7 @@
VkSamplerYcbcrConversion ycbcrConversion,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR encode");
mImpl->log("start vkDestroySamplerYcbcrConversionKHR");
auto stream = mImpl->stream();
@@ -17318,15 +17679,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1154;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1154, 1);
- countingStream->write((uint64_t*)&cgen_var_1154, 1 * 8);
- uint64_t cgen_var_1155;
- countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_1155, 1);
- countingStream->write((uint64_t*)&cgen_var_1155, 1 * 8);
+ uint64_t cgen_var_1158;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1158, 1);
+ countingStream->write((uint64_t*)&cgen_var_1158, 1 * 8);
+ uint64_t cgen_var_1159;
+ countingStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_1159, 1);
+ countingStream->write((uint64_t*)&cgen_var_1159, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1156 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1156);
+ uint64_t cgen_var_1160 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1160);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -17337,15 +17698,15 @@
uint32_t opcode_vkDestroySamplerYcbcrConversionKHR = OP_vkDestroySamplerYcbcrConversionKHR;
stream->write(&opcode_vkDestroySamplerYcbcrConversionKHR, sizeof(uint32_t));
stream->write(&packetSize_vkDestroySamplerYcbcrConversionKHR, sizeof(uint32_t));
- uint64_t cgen_var_1157;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1157, 1);
- stream->write((uint64_t*)&cgen_var_1157, 1 * 8);
- uint64_t cgen_var_1158;
- stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_1158, 1);
- stream->write((uint64_t*)&cgen_var_1158, 1 * 8);
+ uint64_t cgen_var_1161;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1161, 1);
+ stream->write((uint64_t*)&cgen_var_1161, 1 * 8);
+ uint64_t cgen_var_1162;
+ stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&local_ycbcrConversion, &cgen_var_1162, 1);
+ stream->write((uint64_t*)&cgen_var_1162, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1159 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1159);
+ uint64_t cgen_var_1163 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1163);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -17363,6 +17724,7 @@
uint32_t bindInfoCount,
const VkBindBufferMemoryInfo* pBindInfos)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR encode");
mImpl->log("start vkBindBufferMemory2KHR");
auto stream = mImpl->stream();
@@ -17393,9 +17755,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1160;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1160, 1);
- countingStream->write((uint64_t*)&cgen_var_1160, 1 * 8);
+ uint64_t cgen_var_1164;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1164, 1);
+ countingStream->write((uint64_t*)&cgen_var_1164, 1 * 8);
countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
@@ -17407,9 +17769,9 @@
uint32_t opcode_vkBindBufferMemory2KHR = OP_vkBindBufferMemory2KHR;
stream->write(&opcode_vkBindBufferMemory2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkBindBufferMemory2KHR, sizeof(uint32_t));
- uint64_t cgen_var_1161;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1161, 1);
- stream->write((uint64_t*)&cgen_var_1161, 1 * 8);
+ uint64_t cgen_var_1165;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1165, 1);
+ stream->write((uint64_t*)&cgen_var_1165, 1 * 8);
stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
@@ -17431,6 +17793,7 @@
uint32_t bindInfoCount,
const VkBindImageMemoryInfo* pBindInfos)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkBindImageMemory2KHR encode");
mImpl->log("start vkBindImageMemory2KHR");
auto stream = mImpl->stream();
@@ -17461,9 +17824,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1162;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1162, 1);
- countingStream->write((uint64_t*)&cgen_var_1162, 1 * 8);
+ uint64_t cgen_var_1166;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1166, 1);
+ countingStream->write((uint64_t*)&cgen_var_1166, 1 * 8);
countingStream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
@@ -17475,9 +17838,9 @@
uint32_t opcode_vkBindImageMemory2KHR = OP_vkBindImageMemory2KHR;
stream->write(&opcode_vkBindImageMemory2KHR, sizeof(uint32_t));
stream->write(&packetSize_vkBindImageMemory2KHR, sizeof(uint32_t));
- uint64_t cgen_var_1163;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1163, 1);
- stream->write((uint64_t*)&cgen_var_1163, 1 * 8);
+ uint64_t cgen_var_1167;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1167, 1);
+ stream->write((uint64_t*)&cgen_var_1167, 1 * 8);
stream->write((uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
{
@@ -17501,6 +17864,7 @@
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
VkDescriptorSetLayoutSupport* pSupport)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR encode");
mImpl->log("start vkGetDescriptorSetLayoutSupportKHR");
auto stream = mImpl->stream();
@@ -17523,9 +17887,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1164;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1164, 1);
- countingStream->write((uint64_t*)&cgen_var_1164, 1 * 8);
+ uint64_t cgen_var_1168;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1168, 1);
+ countingStream->write((uint64_t*)&cgen_var_1168, 1 * 8);
marshal_VkDescriptorSetLayoutCreateInfo(countingStream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
marshal_VkDescriptorSetLayoutSupport(countingStream, (VkDescriptorSetLayoutSupport*)(pSupport));
}
@@ -17534,9 +17898,9 @@
uint32_t opcode_vkGetDescriptorSetLayoutSupportKHR = OP_vkGetDescriptorSetLayoutSupportKHR;
stream->write(&opcode_vkGetDescriptorSetLayoutSupportKHR, sizeof(uint32_t));
stream->write(&packetSize_vkGetDescriptorSetLayoutSupportKHR, sizeof(uint32_t));
- uint64_t cgen_var_1165;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1165, 1);
- stream->write((uint64_t*)&cgen_var_1165, 1 * 8);
+ uint64_t cgen_var_1169;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1169, 1);
+ stream->write((uint64_t*)&cgen_var_1169, 1 * 8);
marshal_VkDescriptorSetLayoutCreateInfo(stream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
marshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport));
AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR readParams");
@@ -17560,6 +17924,7 @@
uint32_t maxDrawCount,
uint32_t stride)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountKHR encode");
mImpl->log("start vkCmdDrawIndirectCountKHR");
auto stream = mImpl->stream();
@@ -17583,16 +17948,16 @@
local_stride = stride;
countingStream->rewind();
{
- uint64_t cgen_var_1166;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1166, 1);
- countingStream->write((uint64_t*)&cgen_var_1166, 1 * 8);
- uint64_t cgen_var_1167;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1167, 1);
- countingStream->write((uint64_t*)&cgen_var_1167, 1 * 8);
+ uint64_t cgen_var_1170;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1170, 1);
+ countingStream->write((uint64_t*)&cgen_var_1170, 1 * 8);
+ uint64_t cgen_var_1171;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1171, 1);
+ countingStream->write((uint64_t*)&cgen_var_1171, 1 * 8);
countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
- uint64_t cgen_var_1168;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1168, 1);
- countingStream->write((uint64_t*)&cgen_var_1168, 1 * 8);
+ uint64_t cgen_var_1172;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1172, 1);
+ countingStream->write((uint64_t*)&cgen_var_1172, 1 * 8);
countingStream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
countingStream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -17602,16 +17967,16 @@
uint32_t opcode_vkCmdDrawIndirectCountKHR = OP_vkCmdDrawIndirectCountKHR;
stream->write(&opcode_vkCmdDrawIndirectCountKHR, sizeof(uint32_t));
stream->write(&packetSize_vkCmdDrawIndirectCountKHR, sizeof(uint32_t));
- uint64_t cgen_var_1169;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1169, 1);
- stream->write((uint64_t*)&cgen_var_1169, 1 * 8);
- uint64_t cgen_var_1170;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1170, 1);
- stream->write((uint64_t*)&cgen_var_1170, 1 * 8);
+ uint64_t cgen_var_1173;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1173, 1);
+ stream->write((uint64_t*)&cgen_var_1173, 1 * 8);
+ uint64_t cgen_var_1174;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1174, 1);
+ stream->write((uint64_t*)&cgen_var_1174, 1 * 8);
stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
- uint64_t cgen_var_1171;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1171, 1);
- stream->write((uint64_t*)&cgen_var_1171, 1 * 8);
+ uint64_t cgen_var_1175;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1175, 1);
+ stream->write((uint64_t*)&cgen_var_1175, 1 * 8);
stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -17629,6 +17994,7 @@
uint32_t maxDrawCount,
uint32_t stride)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountKHR encode");
mImpl->log("start vkCmdDrawIndexedIndirectCountKHR");
auto stream = mImpl->stream();
@@ -17652,16 +18018,16 @@
local_stride = stride;
countingStream->rewind();
{
- uint64_t cgen_var_1172;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1172, 1);
- countingStream->write((uint64_t*)&cgen_var_1172, 1 * 8);
- uint64_t cgen_var_1173;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1173, 1);
- countingStream->write((uint64_t*)&cgen_var_1173, 1 * 8);
+ uint64_t cgen_var_1176;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1176, 1);
+ countingStream->write((uint64_t*)&cgen_var_1176, 1 * 8);
+ uint64_t cgen_var_1177;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1177, 1);
+ countingStream->write((uint64_t*)&cgen_var_1177, 1 * 8);
countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
- uint64_t cgen_var_1174;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1174, 1);
- countingStream->write((uint64_t*)&cgen_var_1174, 1 * 8);
+ uint64_t cgen_var_1178;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1178, 1);
+ countingStream->write((uint64_t*)&cgen_var_1178, 1 * 8);
countingStream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
countingStream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -17671,16 +18037,16 @@
uint32_t opcode_vkCmdDrawIndexedIndirectCountKHR = OP_vkCmdDrawIndexedIndirectCountKHR;
stream->write(&opcode_vkCmdDrawIndexedIndirectCountKHR, sizeof(uint32_t));
stream->write(&packetSize_vkCmdDrawIndexedIndirectCountKHR, sizeof(uint32_t));
- uint64_t cgen_var_1175;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1175, 1);
- stream->write((uint64_t*)&cgen_var_1175, 1 * 8);
- uint64_t cgen_var_1176;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1176, 1);
- stream->write((uint64_t*)&cgen_var_1176, 1 * 8);
+ uint64_t cgen_var_1179;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1179, 1);
+ stream->write((uint64_t*)&cgen_var_1179, 1 * 8);
+ uint64_t cgen_var_1180;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1180, 1);
+ stream->write((uint64_t*)&cgen_var_1180, 1 * 8);
stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
- uint64_t cgen_var_1177;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1177, 1);
- stream->write((uint64_t*)&cgen_var_1177, 1 * 8);
+ uint64_t cgen_var_1181;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1181, 1);
+ stream->write((uint64_t*)&cgen_var_1181, 1 * 8);
stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -17699,6 +18065,7 @@
VkImageUsageFlags imageUsage,
int* grallocUsage)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID encode");
mImpl->log("start vkGetSwapchainGrallocUsageANDROID");
auto stream = mImpl->stream();
@@ -17714,9 +18081,9 @@
local_imageUsage = imageUsage;
countingStream->rewind();
{
- uint64_t cgen_var_1178;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1178, 1);
- countingStream->write((uint64_t*)&cgen_var_1178, 1 * 8);
+ uint64_t cgen_var_1182;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1182, 1);
+ countingStream->write((uint64_t*)&cgen_var_1182, 1 * 8);
countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
countingStream->write((VkImageUsageFlags*)&local_imageUsage, sizeof(VkImageUsageFlags));
countingStream->write((int*)grallocUsage, sizeof(int));
@@ -17726,9 +18093,9 @@
uint32_t opcode_vkGetSwapchainGrallocUsageANDROID = OP_vkGetSwapchainGrallocUsageANDROID;
stream->write(&opcode_vkGetSwapchainGrallocUsageANDROID, sizeof(uint32_t));
stream->write(&packetSize_vkGetSwapchainGrallocUsageANDROID, sizeof(uint32_t));
- uint64_t cgen_var_1179;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1179, 1);
- stream->write((uint64_t*)&cgen_var_1179, 1 * 8);
+ uint64_t cgen_var_1183;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1183, 1);
+ stream->write((uint64_t*)&cgen_var_1183, 1 * 8);
stream->write((VkFormat*)&local_format, sizeof(VkFormat));
stream->write((VkImageUsageFlags*)&local_imageUsage, sizeof(VkImageUsageFlags));
stream->write((int*)grallocUsage, sizeof(int));
@@ -17751,6 +18118,7 @@
VkSemaphore semaphore,
VkFence fence)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkAcquireImageANDROID encode");
mImpl->log("start vkAcquireImageANDROID");
auto stream = mImpl->stream();
@@ -17771,38 +18139,38 @@
mImpl->resources()->unwrap_vkAcquireImageANDROID_nativeFenceFd(nativeFenceFd, &local_nativeFenceFd);
countingStream->rewind();
{
- uint64_t cgen_var_1180;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1180, 1);
- countingStream->write((uint64_t*)&cgen_var_1180, 1 * 8);
- uint64_t cgen_var_1181;
- countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1181, 1);
- countingStream->write((uint64_t*)&cgen_var_1181, 1 * 8);
+ uint64_t cgen_var_1184;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1184, 1);
+ countingStream->write((uint64_t*)&cgen_var_1184, 1 * 8);
+ uint64_t cgen_var_1185;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1185, 1);
+ countingStream->write((uint64_t*)&cgen_var_1185, 1 * 8);
countingStream->write((int*)&local_nativeFenceFd, sizeof(int));
- uint64_t cgen_var_1182;
- countingStream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_1182, 1);
- countingStream->write((uint64_t*)&cgen_var_1182, 1 * 8);
- uint64_t cgen_var_1183;
- countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1183, 1);
- countingStream->write((uint64_t*)&cgen_var_1183, 1 * 8);
+ uint64_t cgen_var_1186;
+ countingStream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_1186, 1);
+ countingStream->write((uint64_t*)&cgen_var_1186, 1 * 8);
+ uint64_t cgen_var_1187;
+ countingStream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1187, 1);
+ countingStream->write((uint64_t*)&cgen_var_1187, 1 * 8);
}
uint32_t packetSize_vkAcquireImageANDROID = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkAcquireImageANDROID = OP_vkAcquireImageANDROID;
stream->write(&opcode_vkAcquireImageANDROID, sizeof(uint32_t));
stream->write(&packetSize_vkAcquireImageANDROID, sizeof(uint32_t));
- uint64_t cgen_var_1184;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1184, 1);
- stream->write((uint64_t*)&cgen_var_1184, 1 * 8);
- uint64_t cgen_var_1185;
- stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1185, 1);
- stream->write((uint64_t*)&cgen_var_1185, 1 * 8);
+ uint64_t cgen_var_1188;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1188, 1);
+ stream->write((uint64_t*)&cgen_var_1188, 1 * 8);
+ uint64_t cgen_var_1189;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1189, 1);
+ stream->write((uint64_t*)&cgen_var_1189, 1 * 8);
stream->write((int*)&local_nativeFenceFd, sizeof(int));
- uint64_t cgen_var_1186;
- stream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_1186, 1);
- stream->write((uint64_t*)&cgen_var_1186, 1 * 8);
- uint64_t cgen_var_1187;
- stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1187, 1);
- stream->write((uint64_t*)&cgen_var_1187, 1 * 8);
+ uint64_t cgen_var_1190;
+ stream->handleMapping()->mapHandles_VkSemaphore_u64(&local_semaphore, &cgen_var_1190, 1);
+ stream->write((uint64_t*)&cgen_var_1190, 1 * 8);
+ uint64_t cgen_var_1191;
+ stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1191, 1);
+ stream->write((uint64_t*)&cgen_var_1191, 1 * 8);
AEMU_SCOPED_TRACE("vkAcquireImageANDROID readParams");
AEMU_SCOPED_TRACE("vkAcquireImageANDROID returnUnmarshal");
VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
@@ -17821,6 +18189,7 @@
VkImage image,
int* pNativeFenceFd)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROID encode");
mImpl->log("start vkQueueSignalReleaseImageANDROID");
auto stream = mImpl->stream();
@@ -17842,26 +18211,26 @@
local_image = image;
countingStream->rewind();
{
- uint64_t cgen_var_1188;
- countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1188, 1);
- countingStream->write((uint64_t*)&cgen_var_1188, 1 * 8);
+ uint64_t cgen_var_1192;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1192, 1);
+ countingStream->write((uint64_t*)&cgen_var_1192, 1 * 8);
countingStream->write((uint32_t*)&local_waitSemaphoreCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_1189 = (uint64_t)(uintptr_t)local_pWaitSemaphores;
- countingStream->putBe64(cgen_var_1189);
+ uint64_t cgen_var_1193 = (uint64_t)(uintptr_t)local_pWaitSemaphores;
+ countingStream->putBe64(cgen_var_1193);
if (local_pWaitSemaphores)
{
if (((waitSemaphoreCount)))
{
- uint64_t* cgen_var_1190;
- countingStream->alloc((void**)&cgen_var_1190, ((waitSemaphoreCount)) * 8);
- countingStream->handleMapping()->mapHandles_VkSemaphore_u64(local_pWaitSemaphores, cgen_var_1190, ((waitSemaphoreCount)));
- countingStream->write((uint64_t*)cgen_var_1190, ((waitSemaphoreCount)) * 8);
+ uint64_t* cgen_var_1194;
+ countingStream->alloc((void**)&cgen_var_1194, ((waitSemaphoreCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkSemaphore_u64(local_pWaitSemaphores, cgen_var_1194, ((waitSemaphoreCount)));
+ countingStream->write((uint64_t*)cgen_var_1194, ((waitSemaphoreCount)) * 8);
}
}
- uint64_t cgen_var_1191;
- countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1191, 1);
- countingStream->write((uint64_t*)&cgen_var_1191, 1 * 8);
+ uint64_t cgen_var_1195;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1195, 1);
+ countingStream->write((uint64_t*)&cgen_var_1195, 1 * 8);
countingStream->write((int*)pNativeFenceFd, sizeof(int));
}
uint32_t packetSize_vkQueueSignalReleaseImageANDROID = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -17869,26 +18238,26 @@
uint32_t opcode_vkQueueSignalReleaseImageANDROID = OP_vkQueueSignalReleaseImageANDROID;
stream->write(&opcode_vkQueueSignalReleaseImageANDROID, sizeof(uint32_t));
stream->write(&packetSize_vkQueueSignalReleaseImageANDROID, sizeof(uint32_t));
- uint64_t cgen_var_1192;
- stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1192, 1);
- stream->write((uint64_t*)&cgen_var_1192, 1 * 8);
+ uint64_t cgen_var_1196;
+ stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1196, 1);
+ stream->write((uint64_t*)&cgen_var_1196, 1 * 8);
stream->write((uint32_t*)&local_waitSemaphoreCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_1193 = (uint64_t)(uintptr_t)local_pWaitSemaphores;
- stream->putBe64(cgen_var_1193);
+ uint64_t cgen_var_1197 = (uint64_t)(uintptr_t)local_pWaitSemaphores;
+ stream->putBe64(cgen_var_1197);
if (local_pWaitSemaphores)
{
if (((waitSemaphoreCount)))
{
- uint64_t* cgen_var_1194;
- stream->alloc((void**)&cgen_var_1194, ((waitSemaphoreCount)) * 8);
- stream->handleMapping()->mapHandles_VkSemaphore_u64(local_pWaitSemaphores, cgen_var_1194, ((waitSemaphoreCount)));
- stream->write((uint64_t*)cgen_var_1194, ((waitSemaphoreCount)) * 8);
+ uint64_t* cgen_var_1198;
+ stream->alloc((void**)&cgen_var_1198, ((waitSemaphoreCount)) * 8);
+ stream->handleMapping()->mapHandles_VkSemaphore_u64(local_pWaitSemaphores, cgen_var_1198, ((waitSemaphoreCount)));
+ stream->write((uint64_t*)cgen_var_1198, ((waitSemaphoreCount)) * 8);
}
}
- uint64_t cgen_var_1195;
- stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1195, 1);
- stream->write((uint64_t*)&cgen_var_1195, 1 * 8);
+ uint64_t cgen_var_1199;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1199, 1);
+ stream->write((uint64_t*)&cgen_var_1199, 1 * 8);
stream->write((int*)pNativeFenceFd, sizeof(int));
AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROID readParams");
stream->read((int*)pNativeFenceFd, sizeof(int));
@@ -17910,6 +18279,7 @@
const VkAllocationCallbacks* pAllocator,
VkDebugReportCallbackEXT* pCallback)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateDebugReportCallbackEXT encode");
mImpl->log("start vkCreateDebugReportCallbackEXT");
auto stream = mImpl->stream();
@@ -17944,47 +18314,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1196;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1196, 1);
- countingStream->write((uint64_t*)&cgen_var_1196, 1 * 8);
+ uint64_t cgen_var_1200;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1200, 1);
+ countingStream->write((uint64_t*)&cgen_var_1200, 1 * 8);
marshal_VkDebugReportCallbackCreateInfoEXT(countingStream, (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1197 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1197);
+ uint64_t cgen_var_1201 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1201);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_1198;
- countingStream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(pCallback, &cgen_var_1198, 1);
- countingStream->write((uint64_t*)&cgen_var_1198, 8);
+ uint64_t cgen_var_1202;
+ countingStream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(pCallback, &cgen_var_1202, 1);
+ countingStream->write((uint64_t*)&cgen_var_1202, 8);
}
uint32_t packetSize_vkCreateDebugReportCallbackEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateDebugReportCallbackEXT = OP_vkCreateDebugReportCallbackEXT;
stream->write(&opcode_vkCreateDebugReportCallbackEXT, sizeof(uint32_t));
stream->write(&packetSize_vkCreateDebugReportCallbackEXT, sizeof(uint32_t));
- uint64_t cgen_var_1199;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1199, 1);
- stream->write((uint64_t*)&cgen_var_1199, 1 * 8);
+ uint64_t cgen_var_1203;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1203, 1);
+ stream->write((uint64_t*)&cgen_var_1203, 1 * 8);
marshal_VkDebugReportCallbackCreateInfoEXT(stream, (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1200 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1200);
+ uint64_t cgen_var_1204 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1204);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_1201;
- stream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(pCallback, &cgen_var_1201, 1);
- stream->write((uint64_t*)&cgen_var_1201, 8);
+ uint64_t cgen_var_1205;
+ stream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(pCallback, &cgen_var_1205, 1);
+ stream->write((uint64_t*)&cgen_var_1205, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateDebugReportCallbackEXT readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_1202;
- stream->read((uint64_t*)&cgen_var_1202, 8);
- stream->handleMapping()->mapHandles_u64_VkDebugReportCallbackEXT(&cgen_var_1202, (VkDebugReportCallbackEXT*)pCallback, 1);
+ uint64_t cgen_var_1206;
+ stream->read((uint64_t*)&cgen_var_1206, 8);
+ stream->handleMapping()->mapHandles_u64_VkDebugReportCallbackEXT(&cgen_var_1206, (VkDebugReportCallbackEXT*)pCallback, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateDebugReportCallbackEXT returnUnmarshal");
VkResult vkCreateDebugReportCallbackEXT_VkResult_return = (VkResult)0;
@@ -18001,6 +18371,7 @@
VkDebugReportCallbackEXT callback,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyDebugReportCallbackEXT encode");
mImpl->log("start vkDestroyDebugReportCallbackEXT");
auto stream = mImpl->stream();
@@ -18026,15 +18397,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1203;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1203, 1);
- countingStream->write((uint64_t*)&cgen_var_1203, 1 * 8);
- uint64_t cgen_var_1204;
- countingStream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(&local_callback, &cgen_var_1204, 1);
- countingStream->write((uint64_t*)&cgen_var_1204, 1 * 8);
+ uint64_t cgen_var_1207;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1207, 1);
+ countingStream->write((uint64_t*)&cgen_var_1207, 1 * 8);
+ uint64_t cgen_var_1208;
+ countingStream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(&local_callback, &cgen_var_1208, 1);
+ countingStream->write((uint64_t*)&cgen_var_1208, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1205 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1205);
+ uint64_t cgen_var_1209 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1209);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -18045,15 +18416,15 @@
uint32_t opcode_vkDestroyDebugReportCallbackEXT = OP_vkDestroyDebugReportCallbackEXT;
stream->write(&opcode_vkDestroyDebugReportCallbackEXT, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyDebugReportCallbackEXT, sizeof(uint32_t));
- uint64_t cgen_var_1206;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1206, 1);
- stream->write((uint64_t*)&cgen_var_1206, 1 * 8);
- uint64_t cgen_var_1207;
- stream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(&local_callback, &cgen_var_1207, 1);
- stream->write((uint64_t*)&cgen_var_1207, 1 * 8);
+ uint64_t cgen_var_1210;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1210, 1);
+ stream->write((uint64_t*)&cgen_var_1210, 1 * 8);
+ uint64_t cgen_var_1211;
+ stream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(&local_callback, &cgen_var_1211, 1);
+ stream->write((uint64_t*)&cgen_var_1211, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1208 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1208);
+ uint64_t cgen_var_1212 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1212);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -18074,6 +18445,7 @@
const char* pLayerPrefix,
const char* pMessage)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDebugReportMessageEXT encode");
mImpl->log("start vkDebugReportMessageEXT");
auto stream = mImpl->stream();
@@ -18107,14 +18479,14 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1209;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1209, 1);
- countingStream->write((uint64_t*)&cgen_var_1209, 1 * 8);
+ uint64_t cgen_var_1213;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1213, 1);
+ countingStream->write((uint64_t*)&cgen_var_1213, 1 * 8);
countingStream->write((VkDebugReportFlagsEXT*)&local_flags, sizeof(VkDebugReportFlagsEXT));
countingStream->write((VkDebugReportObjectTypeEXT*)&local_objectType, sizeof(VkDebugReportObjectTypeEXT));
countingStream->write((uint64_t*)&local_object, sizeof(uint64_t));
- uint64_t cgen_var_1210 = (uint64_t)local_location;
- countingStream->putBe64(cgen_var_1210);
+ uint64_t cgen_var_1214 = (uint64_t)local_location;
+ countingStream->putBe64(cgen_var_1214);
countingStream->write((int32_t*)&local_messageCode, sizeof(int32_t));
countingStream->putString(local_pLayerPrefix);
countingStream->putString(local_pMessage);
@@ -18124,14 +18496,14 @@
uint32_t opcode_vkDebugReportMessageEXT = OP_vkDebugReportMessageEXT;
stream->write(&opcode_vkDebugReportMessageEXT, sizeof(uint32_t));
stream->write(&packetSize_vkDebugReportMessageEXT, sizeof(uint32_t));
- uint64_t cgen_var_1211;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1211, 1);
- stream->write((uint64_t*)&cgen_var_1211, 1 * 8);
+ uint64_t cgen_var_1215;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1215, 1);
+ stream->write((uint64_t*)&cgen_var_1215, 1 * 8);
stream->write((VkDebugReportFlagsEXT*)&local_flags, sizeof(VkDebugReportFlagsEXT));
stream->write((VkDebugReportObjectTypeEXT*)&local_objectType, sizeof(VkDebugReportObjectTypeEXT));
stream->write((uint64_t*)&local_object, sizeof(uint64_t));
- uint64_t cgen_var_1212 = (uint64_t)local_location;
- stream->putBe64(cgen_var_1212);
+ uint64_t cgen_var_1216 = (uint64_t)local_location;
+ stream->putBe64(cgen_var_1216);
stream->write((int32_t*)&local_messageCode, sizeof(int32_t));
stream->putString(local_pLayerPrefix);
stream->putString(local_pMessage);
@@ -18158,6 +18530,7 @@
VkDevice device,
const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectTagEXT encode");
mImpl->log("start vkDebugMarkerSetObjectTagEXT");
auto stream = mImpl->stream();
@@ -18180,9 +18553,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1213;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1213, 1);
- countingStream->write((uint64_t*)&cgen_var_1213, 1 * 8);
+ uint64_t cgen_var_1217;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1217, 1);
+ countingStream->write((uint64_t*)&cgen_var_1217, 1 * 8);
marshal_VkDebugMarkerObjectTagInfoEXT(countingStream, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo));
}
uint32_t packetSize_vkDebugMarkerSetObjectTagEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -18190,9 +18563,9 @@
uint32_t opcode_vkDebugMarkerSetObjectTagEXT = OP_vkDebugMarkerSetObjectTagEXT;
stream->write(&opcode_vkDebugMarkerSetObjectTagEXT, sizeof(uint32_t));
stream->write(&packetSize_vkDebugMarkerSetObjectTagEXT, sizeof(uint32_t));
- uint64_t cgen_var_1214;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1214, 1);
- stream->write((uint64_t*)&cgen_var_1214, 1 * 8);
+ uint64_t cgen_var_1218;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1218, 1);
+ stream->write((uint64_t*)&cgen_var_1218, 1 * 8);
marshal_VkDebugMarkerObjectTagInfoEXT(stream, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo));
AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectTagEXT readParams");
AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectTagEXT returnUnmarshal");
@@ -18209,6 +18582,7 @@
VkDevice device,
const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectNameEXT encode");
mImpl->log("start vkDebugMarkerSetObjectNameEXT");
auto stream = mImpl->stream();
@@ -18231,9 +18605,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1215;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1215, 1);
- countingStream->write((uint64_t*)&cgen_var_1215, 1 * 8);
+ uint64_t cgen_var_1219;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1219, 1);
+ countingStream->write((uint64_t*)&cgen_var_1219, 1 * 8);
marshal_VkDebugMarkerObjectNameInfoEXT(countingStream, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo));
}
uint32_t packetSize_vkDebugMarkerSetObjectNameEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -18241,9 +18615,9 @@
uint32_t opcode_vkDebugMarkerSetObjectNameEXT = OP_vkDebugMarkerSetObjectNameEXT;
stream->write(&opcode_vkDebugMarkerSetObjectNameEXT, sizeof(uint32_t));
stream->write(&packetSize_vkDebugMarkerSetObjectNameEXT, sizeof(uint32_t));
- uint64_t cgen_var_1216;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1216, 1);
- stream->write((uint64_t*)&cgen_var_1216, 1 * 8);
+ uint64_t cgen_var_1220;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1220, 1);
+ stream->write((uint64_t*)&cgen_var_1220, 1 * 8);
marshal_VkDebugMarkerObjectNameInfoEXT(stream, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo));
AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectNameEXT readParams");
AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectNameEXT returnUnmarshal");
@@ -18260,6 +18634,7 @@
VkCommandBuffer commandBuffer,
const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdDebugMarkerBeginEXT encode");
mImpl->log("start vkCmdDebugMarkerBeginEXT");
auto stream = mImpl->stream();
@@ -18282,95 +18657,97 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1217;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1217, 1);
- countingStream->write((uint64_t*)&cgen_var_1217, 1 * 8);
- marshal_VkDebugMarkerMarkerInfoEXT(countingStream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
- }
- uint32_t packetSize_vkCmdDebugMarkerBeginEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
- countingStream->rewind();
- uint32_t opcode_vkCmdDebugMarkerBeginEXT = OP_vkCmdDebugMarkerBeginEXT;
- stream->write(&opcode_vkCmdDebugMarkerBeginEXT, sizeof(uint32_t));
- stream->write(&packetSize_vkCmdDebugMarkerBeginEXT, sizeof(uint32_t));
- uint64_t cgen_var_1218;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1218, 1);
- stream->write((uint64_t*)&cgen_var_1218, 1 * 8);
- marshal_VkDebugMarkerMarkerInfoEXT(stream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
- AEMU_SCOPED_TRACE("vkCmdDebugMarkerBeginEXT readParams");
- AEMU_SCOPED_TRACE("vkCmdDebugMarkerBeginEXT returnUnmarshal");
- mImpl->log("finish vkCmdDebugMarkerBeginEXT");;
-}
-
-void VkEncoder::vkCmdDebugMarkerEndEXT(
- VkCommandBuffer commandBuffer)
-{
- AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT encode");
- mImpl->log("start vkCmdDebugMarkerEndEXT");
- auto stream = mImpl->stream();
- auto countingStream = mImpl->countingStream();
- auto resources = mImpl->resources();
- auto pool = mImpl->pool();
- stream->setHandleMapping(resources->unwrapMapping());
- VkCommandBuffer local_commandBuffer;
- local_commandBuffer = commandBuffer;
- countingStream->rewind();
- {
- uint64_t cgen_var_1219;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1219, 1);
- countingStream->write((uint64_t*)&cgen_var_1219, 1 * 8);
- }
- uint32_t packetSize_vkCmdDebugMarkerEndEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
- countingStream->rewind();
- uint32_t opcode_vkCmdDebugMarkerEndEXT = OP_vkCmdDebugMarkerEndEXT;
- stream->write(&opcode_vkCmdDebugMarkerEndEXT, sizeof(uint32_t));
- stream->write(&packetSize_vkCmdDebugMarkerEndEXT, sizeof(uint32_t));
- uint64_t cgen_var_1220;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1220, 1);
- stream->write((uint64_t*)&cgen_var_1220, 1 * 8);
- AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT readParams");
- AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT returnUnmarshal");
- mImpl->log("finish vkCmdDebugMarkerEndEXT");;
-}
-
-void VkEncoder::vkCmdDebugMarkerInsertEXT(
- VkCommandBuffer commandBuffer,
- const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
-{
- AEMU_SCOPED_TRACE("vkCmdDebugMarkerInsertEXT encode");
- mImpl->log("start vkCmdDebugMarkerInsertEXT");
- auto stream = mImpl->stream();
- auto countingStream = mImpl->countingStream();
- auto resources = mImpl->resources();
- auto pool = mImpl->pool();
- stream->setHandleMapping(resources->unwrapMapping());
- VkCommandBuffer local_commandBuffer;
- VkDebugMarkerMarkerInfoEXT* local_pMarkerInfo;
- local_commandBuffer = commandBuffer;
- local_pMarkerInfo = nullptr;
- if (pMarkerInfo)
- {
- local_pMarkerInfo = (VkDebugMarkerMarkerInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerMarkerInfoEXT));
- deepcopy_VkDebugMarkerMarkerInfoEXT(pool, pMarkerInfo, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
- }
- if (local_pMarkerInfo)
- {
- transform_tohost_VkDebugMarkerMarkerInfoEXT(mImpl->resources(), (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
- }
- countingStream->rewind();
- {
uint64_t cgen_var_1221;
countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1221, 1);
countingStream->write((uint64_t*)&cgen_var_1221, 1 * 8);
marshal_VkDebugMarkerMarkerInfoEXT(countingStream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
}
+ uint32_t packetSize_vkCmdDebugMarkerBeginEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdDebugMarkerBeginEXT = OP_vkCmdDebugMarkerBeginEXT;
+ stream->write(&opcode_vkCmdDebugMarkerBeginEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDebugMarkerBeginEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1222;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1222, 1);
+ stream->write((uint64_t*)&cgen_var_1222, 1 * 8);
+ marshal_VkDebugMarkerMarkerInfoEXT(stream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+ AEMU_SCOPED_TRACE("vkCmdDebugMarkerBeginEXT readParams");
+ AEMU_SCOPED_TRACE("vkCmdDebugMarkerBeginEXT returnUnmarshal");
+ mImpl->log("finish vkCmdDebugMarkerBeginEXT");;
+}
+
+void VkEncoder::vkCmdDebugMarkerEndEXT(
+ VkCommandBuffer commandBuffer)
+{
+ AutoLock encoderLock(mImpl->lock);
+ AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT encode");
+ mImpl->log("start vkCmdDebugMarkerEndEXT");
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ local_commandBuffer = commandBuffer;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1223;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1223, 1);
+ countingStream->write((uint64_t*)&cgen_var_1223, 1 * 8);
+ }
+ uint32_t packetSize_vkCmdDebugMarkerEndEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdDebugMarkerEndEXT = OP_vkCmdDebugMarkerEndEXT;
+ stream->write(&opcode_vkCmdDebugMarkerEndEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdDebugMarkerEndEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1224;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1224, 1);
+ stream->write((uint64_t*)&cgen_var_1224, 1 * 8);
+ AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT readParams");
+ AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT returnUnmarshal");
+ mImpl->log("finish vkCmdDebugMarkerEndEXT");;
+}
+
+void VkEncoder::vkCmdDebugMarkerInsertEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
+{
+ AutoLock encoderLock(mImpl->lock);
+ AEMU_SCOPED_TRACE("vkCmdDebugMarkerInsertEXT encode");
+ mImpl->log("start vkCmdDebugMarkerInsertEXT");
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkDebugMarkerMarkerInfoEXT* local_pMarkerInfo;
+ local_commandBuffer = commandBuffer;
+ local_pMarkerInfo = nullptr;
+ if (pMarkerInfo)
+ {
+ local_pMarkerInfo = (VkDebugMarkerMarkerInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerMarkerInfoEXT));
+ deepcopy_VkDebugMarkerMarkerInfoEXT(pool, pMarkerInfo, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+ }
+ if (local_pMarkerInfo)
+ {
+ transform_tohost_VkDebugMarkerMarkerInfoEXT(mImpl->resources(), (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1225;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1225, 1);
+ countingStream->write((uint64_t*)&cgen_var_1225, 1 * 8);
+ marshal_VkDebugMarkerMarkerInfoEXT(countingStream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+ }
uint32_t packetSize_vkCmdDebugMarkerInsertEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCmdDebugMarkerInsertEXT = OP_vkCmdDebugMarkerInsertEXT;
stream->write(&opcode_vkCmdDebugMarkerInsertEXT, sizeof(uint32_t));
stream->write(&packetSize_vkCmdDebugMarkerInsertEXT, sizeof(uint32_t));
- uint64_t cgen_var_1222;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1222, 1);
- stream->write((uint64_t*)&cgen_var_1222, 1 * 8);
+ uint64_t cgen_var_1226;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1226, 1);
+ stream->write((uint64_t*)&cgen_var_1226, 1 * 8);
marshal_VkDebugMarkerMarkerInfoEXT(stream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
AEMU_SCOPED_TRACE("vkCmdDebugMarkerInsertEXT readParams");
AEMU_SCOPED_TRACE("vkCmdDebugMarkerInsertEXT returnUnmarshal");
@@ -18392,6 +18769,7 @@
uint32_t maxDrawCount,
uint32_t stride)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountAMD encode");
mImpl->log("start vkCmdDrawIndirectCountAMD");
auto stream = mImpl->stream();
@@ -18415,16 +18793,16 @@
local_stride = stride;
countingStream->rewind();
{
- uint64_t cgen_var_1223;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1223, 1);
- countingStream->write((uint64_t*)&cgen_var_1223, 1 * 8);
- uint64_t cgen_var_1224;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1224, 1);
- countingStream->write((uint64_t*)&cgen_var_1224, 1 * 8);
+ uint64_t cgen_var_1227;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1227, 1);
+ countingStream->write((uint64_t*)&cgen_var_1227, 1 * 8);
+ uint64_t cgen_var_1228;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1228, 1);
+ countingStream->write((uint64_t*)&cgen_var_1228, 1 * 8);
countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
- uint64_t cgen_var_1225;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1225, 1);
- countingStream->write((uint64_t*)&cgen_var_1225, 1 * 8);
+ uint64_t cgen_var_1229;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1229, 1);
+ countingStream->write((uint64_t*)&cgen_var_1229, 1 * 8);
countingStream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
countingStream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -18434,16 +18812,16 @@
uint32_t opcode_vkCmdDrawIndirectCountAMD = OP_vkCmdDrawIndirectCountAMD;
stream->write(&opcode_vkCmdDrawIndirectCountAMD, sizeof(uint32_t));
stream->write(&packetSize_vkCmdDrawIndirectCountAMD, sizeof(uint32_t));
- uint64_t cgen_var_1226;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1226, 1);
- stream->write((uint64_t*)&cgen_var_1226, 1 * 8);
- uint64_t cgen_var_1227;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1227, 1);
- stream->write((uint64_t*)&cgen_var_1227, 1 * 8);
+ uint64_t cgen_var_1230;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1230, 1);
+ stream->write((uint64_t*)&cgen_var_1230, 1 * 8);
+ uint64_t cgen_var_1231;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1231, 1);
+ stream->write((uint64_t*)&cgen_var_1231, 1 * 8);
stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
- uint64_t cgen_var_1228;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1228, 1);
- stream->write((uint64_t*)&cgen_var_1228, 1 * 8);
+ uint64_t cgen_var_1232;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1232, 1);
+ stream->write((uint64_t*)&cgen_var_1232, 1 * 8);
stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -18461,6 +18839,7 @@
uint32_t maxDrawCount,
uint32_t stride)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountAMD encode");
mImpl->log("start vkCmdDrawIndexedIndirectCountAMD");
auto stream = mImpl->stream();
@@ -18484,16 +18863,16 @@
local_stride = stride;
countingStream->rewind();
{
- uint64_t cgen_var_1229;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1229, 1);
- countingStream->write((uint64_t*)&cgen_var_1229, 1 * 8);
- uint64_t cgen_var_1230;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1230, 1);
- countingStream->write((uint64_t*)&cgen_var_1230, 1 * 8);
+ uint64_t cgen_var_1233;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1233, 1);
+ countingStream->write((uint64_t*)&cgen_var_1233, 1 * 8);
+ uint64_t cgen_var_1234;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1234, 1);
+ countingStream->write((uint64_t*)&cgen_var_1234, 1 * 8);
countingStream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
- uint64_t cgen_var_1231;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1231, 1);
- countingStream->write((uint64_t*)&cgen_var_1231, 1 * 8);
+ uint64_t cgen_var_1235;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1235, 1);
+ countingStream->write((uint64_t*)&cgen_var_1235, 1 * 8);
countingStream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
countingStream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -18503,16 +18882,16 @@
uint32_t opcode_vkCmdDrawIndexedIndirectCountAMD = OP_vkCmdDrawIndexedIndirectCountAMD;
stream->write(&opcode_vkCmdDrawIndexedIndirectCountAMD, sizeof(uint32_t));
stream->write(&packetSize_vkCmdDrawIndexedIndirectCountAMD, sizeof(uint32_t));
- uint64_t cgen_var_1232;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1232, 1);
- stream->write((uint64_t*)&cgen_var_1232, 1 * 8);
- uint64_t cgen_var_1233;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1233, 1);
- stream->write((uint64_t*)&cgen_var_1233, 1 * 8);
+ uint64_t cgen_var_1236;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1236, 1);
+ stream->write((uint64_t*)&cgen_var_1236, 1 * 8);
+ uint64_t cgen_var_1237;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1237, 1);
+ stream->write((uint64_t*)&cgen_var_1237, 1 * 8);
stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
- uint64_t cgen_var_1234;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1234, 1);
- stream->write((uint64_t*)&cgen_var_1234, 1 * 8);
+ uint64_t cgen_var_1238;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_countBuffer, &cgen_var_1238, 1);
+ stream->write((uint64_t*)&cgen_var_1238, 1 * 8);
stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize));
stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t));
stream->write((uint32_t*)&local_stride, sizeof(uint32_t));
@@ -18539,6 +18918,7 @@
size_t* pInfoSize,
void* pInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetShaderInfoAMD encode");
mImpl->log("start vkGetShaderInfoAMD");
auto stream = mImpl->stream();
@@ -18556,25 +18936,25 @@
local_infoType = infoType;
countingStream->rewind();
{
- uint64_t cgen_var_1235;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1235, 1);
- countingStream->write((uint64_t*)&cgen_var_1235, 1 * 8);
- uint64_t cgen_var_1236;
- countingStream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_1236, 1);
- countingStream->write((uint64_t*)&cgen_var_1236, 1 * 8);
+ uint64_t cgen_var_1239;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1239, 1);
+ countingStream->write((uint64_t*)&cgen_var_1239, 1 * 8);
+ uint64_t cgen_var_1240;
+ countingStream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_1240, 1);
+ countingStream->write((uint64_t*)&cgen_var_1240, 1 * 8);
countingStream->write((VkShaderStageFlagBits*)&local_shaderStage, sizeof(VkShaderStageFlagBits));
countingStream->write((VkShaderInfoTypeAMD*)&local_infoType, sizeof(VkShaderInfoTypeAMD));
// WARNING PTR CHECK
- uint64_t cgen_var_1237 = (uint64_t)(uintptr_t)pInfoSize;
- countingStream->putBe64(cgen_var_1237);
+ uint64_t cgen_var_1241 = (uint64_t)(uintptr_t)pInfoSize;
+ countingStream->putBe64(cgen_var_1241);
if (pInfoSize)
{
- uint64_t cgen_var_1238 = (uint64_t)(*pInfoSize);
- countingStream->putBe64(cgen_var_1238);
+ uint64_t cgen_var_1242 = (uint64_t)(*pInfoSize);
+ countingStream->putBe64(cgen_var_1242);
}
// WARNING PTR CHECK
- uint64_t cgen_var_1239 = (uint64_t)(uintptr_t)pInfo;
- countingStream->putBe64(cgen_var_1239);
+ uint64_t cgen_var_1243 = (uint64_t)(uintptr_t)pInfo;
+ countingStream->putBe64(cgen_var_1243);
if (pInfo)
{
countingStream->write((void*)pInfo, (*(pInfoSize)) * sizeof(uint8_t));
@@ -18585,25 +18965,25 @@
uint32_t opcode_vkGetShaderInfoAMD = OP_vkGetShaderInfoAMD;
stream->write(&opcode_vkGetShaderInfoAMD, sizeof(uint32_t));
stream->write(&packetSize_vkGetShaderInfoAMD, sizeof(uint32_t));
- uint64_t cgen_var_1240;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1240, 1);
- stream->write((uint64_t*)&cgen_var_1240, 1 * 8);
- uint64_t cgen_var_1241;
- stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_1241, 1);
- stream->write((uint64_t*)&cgen_var_1241, 1 * 8);
+ uint64_t cgen_var_1244;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1244, 1);
+ stream->write((uint64_t*)&cgen_var_1244, 1 * 8);
+ uint64_t cgen_var_1245;
+ stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_1245, 1);
+ stream->write((uint64_t*)&cgen_var_1245, 1 * 8);
stream->write((VkShaderStageFlagBits*)&local_shaderStage, sizeof(VkShaderStageFlagBits));
stream->write((VkShaderInfoTypeAMD*)&local_infoType, sizeof(VkShaderInfoTypeAMD));
// WARNING PTR CHECK
- uint64_t cgen_var_1242 = (uint64_t)(uintptr_t)pInfoSize;
- stream->putBe64(cgen_var_1242);
+ uint64_t cgen_var_1246 = (uint64_t)(uintptr_t)pInfoSize;
+ stream->putBe64(cgen_var_1246);
if (pInfoSize)
{
- uint64_t cgen_var_1243 = (uint64_t)(*pInfoSize);
- stream->putBe64(cgen_var_1243);
+ uint64_t cgen_var_1247 = (uint64_t)(*pInfoSize);
+ stream->putBe64(cgen_var_1247);
}
// WARNING PTR CHECK
- uint64_t cgen_var_1244 = (uint64_t)(uintptr_t)pInfo;
- stream->putBe64(cgen_var_1244);
+ uint64_t cgen_var_1248 = (uint64_t)(uintptr_t)pInfo;
+ stream->putBe64(cgen_var_1248);
if (pInfo)
{
stream->write((void*)pInfo, (*(pInfoSize)) * sizeof(uint8_t));
@@ -18657,6 +19037,7 @@
VkExternalMemoryHandleTypeFlagsNV externalHandleType,
VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalImageFormatPropertiesNV encode");
mImpl->log("start vkGetPhysicalDeviceExternalImageFormatPropertiesNV");
auto stream = mImpl->stream();
@@ -18680,9 +19061,9 @@
local_externalHandleType = externalHandleType;
countingStream->rewind();
{
- uint64_t cgen_var_1248;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1248, 1);
- countingStream->write((uint64_t*)&cgen_var_1248, 1 * 8);
+ uint64_t cgen_var_1252;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1252, 1);
+ countingStream->write((uint64_t*)&cgen_var_1252, 1 * 8);
countingStream->write((VkFormat*)&local_format, sizeof(VkFormat));
countingStream->write((VkImageType*)&local_type, sizeof(VkImageType));
countingStream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
@@ -18696,9 +19077,9 @@
uint32_t opcode_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = OP_vkGetPhysicalDeviceExternalImageFormatPropertiesNV;
stream->write(&opcode_vkGetPhysicalDeviceExternalImageFormatPropertiesNV, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceExternalImageFormatPropertiesNV, sizeof(uint32_t));
- uint64_t cgen_var_1249;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1249, 1);
- stream->write((uint64_t*)&cgen_var_1249, 1 * 8);
+ uint64_t cgen_var_1253;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1253, 1);
+ stream->write((uint64_t*)&cgen_var_1253, 1 * 8);
stream->write((VkFormat*)&local_format, sizeof(VkFormat));
stream->write((VkImageType*)&local_type, sizeof(VkImageType));
stream->write((VkImageTiling*)&local_tiling, sizeof(VkImageTiling));
@@ -18732,6 +19113,7 @@
VkExternalMemoryHandleTypeFlagsNV handleType,
HANDLE* pHandle)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleNV encode");
mImpl->log("start vkGetMemoryWin32HandleNV");
auto stream = mImpl->stream();
@@ -18748,12 +19130,12 @@
mImpl->resources()->deviceMemoryTransform_tohost((VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
countingStream->rewind();
{
- uint64_t cgen_var_1250;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1250, 1);
- countingStream->write((uint64_t*)&cgen_var_1250, 1 * 8);
- uint64_t cgen_var_1251;
- countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1251, 1);
- countingStream->write((uint64_t*)&cgen_var_1251, 1 * 8);
+ uint64_t cgen_var_1254;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1254, 1);
+ countingStream->write((uint64_t*)&cgen_var_1254, 1 * 8);
+ uint64_t cgen_var_1255;
+ countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1255, 1);
+ countingStream->write((uint64_t*)&cgen_var_1255, 1 * 8);
countingStream->write((VkExternalMemoryHandleTypeFlagsNV*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
countingStream->write((HANDLE*)pHandle, sizeof(HANDLE));
}
@@ -18762,12 +19144,12 @@
uint32_t opcode_vkGetMemoryWin32HandleNV = OP_vkGetMemoryWin32HandleNV;
stream->write(&opcode_vkGetMemoryWin32HandleNV, sizeof(uint32_t));
stream->write(&packetSize_vkGetMemoryWin32HandleNV, sizeof(uint32_t));
- uint64_t cgen_var_1252;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1252, 1);
- stream->write((uint64_t*)&cgen_var_1252, 1 * 8);
- uint64_t cgen_var_1253;
- stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1253, 1);
- stream->write((uint64_t*)&cgen_var_1253, 1 * 8);
+ uint64_t cgen_var_1256;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1256, 1);
+ stream->write((uint64_t*)&cgen_var_1256, 1 * 8);
+ uint64_t cgen_var_1257;
+ stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1257, 1);
+ stream->write((uint64_t*)&cgen_var_1257, 1 * 8);
stream->write((VkExternalMemoryHandleTypeFlagsNV*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
stream->write((HANDLE*)pHandle, sizeof(HANDLE));
AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleNV readParams");
@@ -18794,6 +19176,7 @@
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateViSurfaceNN encode");
mImpl->log("start vkCreateViSurfaceNN");
auto stream = mImpl->stream();
@@ -18828,46 +19211,46 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1254;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1254, 1);
- countingStream->write((uint64_t*)&cgen_var_1254, 1 * 8);
+ uint64_t cgen_var_1258;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1258, 1);
+ countingStream->write((uint64_t*)&cgen_var_1258, 1 * 8);
marshal_VkViSurfaceCreateInfoNN(countingStream, (VkViSurfaceCreateInfoNN*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1255 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1255);
+ uint64_t cgen_var_1259 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1259);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_1256;
- countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1256, 1);
- countingStream->write((uint64_t*)&cgen_var_1256, 8);
+ uint64_t cgen_var_1260;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1260, 1);
+ countingStream->write((uint64_t*)&cgen_var_1260, 8);
}
uint32_t packetSize_vkCreateViSurfaceNN = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateViSurfaceNN = OP_vkCreateViSurfaceNN;
stream->write(&opcode_vkCreateViSurfaceNN, sizeof(uint32_t));
stream->write(&packetSize_vkCreateViSurfaceNN, sizeof(uint32_t));
- uint64_t cgen_var_1257;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1257, 1);
- stream->write((uint64_t*)&cgen_var_1257, 1 * 8);
+ uint64_t cgen_var_1261;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1261, 1);
+ stream->write((uint64_t*)&cgen_var_1261, 1 * 8);
marshal_VkViSurfaceCreateInfoNN(stream, (VkViSurfaceCreateInfoNN*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1258 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1258);
+ uint64_t cgen_var_1262 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1262);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_1259;
- stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1259, 1);
- stream->write((uint64_t*)&cgen_var_1259, 8);
+ uint64_t cgen_var_1263;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1263, 1);
+ stream->write((uint64_t*)&cgen_var_1263, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateViSurfaceNN readParams");
- uint64_t cgen_var_1260;
- stream->read((uint64_t*)&cgen_var_1260, 8);
- stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1260, (VkSurfaceKHR*)pSurface, 1);
+ uint64_t cgen_var_1264;
+ stream->read((uint64_t*)&cgen_var_1264, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1264, (VkSurfaceKHR*)pSurface, 1);
AEMU_SCOPED_TRACE("vkCreateViSurfaceNN returnUnmarshal");
VkResult vkCreateViSurfaceNN_VkResult_return = (VkResult)0;
stream->read(&vkCreateViSurfaceNN_VkResult_return, sizeof(VkResult));
@@ -18888,6 +19271,7 @@
VkCommandBuffer commandBuffer,
const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdBeginConditionalRenderingEXT encode");
mImpl->log("start vkCmdBeginConditionalRenderingEXT");
auto stream = mImpl->stream();
@@ -18910,9 +19294,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1261;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1261, 1);
- countingStream->write((uint64_t*)&cgen_var_1261, 1 * 8);
+ uint64_t cgen_var_1265;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1265, 1);
+ countingStream->write((uint64_t*)&cgen_var_1265, 1 * 8);
marshal_VkConditionalRenderingBeginInfoEXT(countingStream, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin));
}
uint32_t packetSize_vkCmdBeginConditionalRenderingEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -18920,9 +19304,9 @@
uint32_t opcode_vkCmdBeginConditionalRenderingEXT = OP_vkCmdBeginConditionalRenderingEXT;
stream->write(&opcode_vkCmdBeginConditionalRenderingEXT, sizeof(uint32_t));
stream->write(&packetSize_vkCmdBeginConditionalRenderingEXT, sizeof(uint32_t));
- uint64_t cgen_var_1262;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1262, 1);
- stream->write((uint64_t*)&cgen_var_1262, 1 * 8);
+ uint64_t cgen_var_1266;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1266, 1);
+ stream->write((uint64_t*)&cgen_var_1266, 1 * 8);
marshal_VkConditionalRenderingBeginInfoEXT(stream, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin));
AEMU_SCOPED_TRACE("vkCmdBeginConditionalRenderingEXT readParams");
AEMU_SCOPED_TRACE("vkCmdBeginConditionalRenderingEXT returnUnmarshal");
@@ -18932,6 +19316,7 @@
void VkEncoder::vkCmdEndConditionalRenderingEXT(
VkCommandBuffer commandBuffer)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdEndConditionalRenderingEXT encode");
mImpl->log("start vkCmdEndConditionalRenderingEXT");
auto stream = mImpl->stream();
@@ -18943,18 +19328,18 @@
local_commandBuffer = commandBuffer;
countingStream->rewind();
{
- uint64_t cgen_var_1263;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1263, 1);
- countingStream->write((uint64_t*)&cgen_var_1263, 1 * 8);
+ uint64_t cgen_var_1267;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1267, 1);
+ countingStream->write((uint64_t*)&cgen_var_1267, 1 * 8);
}
uint32_t packetSize_vkCmdEndConditionalRenderingEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCmdEndConditionalRenderingEXT = OP_vkCmdEndConditionalRenderingEXT;
stream->write(&opcode_vkCmdEndConditionalRenderingEXT, sizeof(uint32_t));
stream->write(&packetSize_vkCmdEndConditionalRenderingEXT, sizeof(uint32_t));
- uint64_t cgen_var_1264;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1264, 1);
- stream->write((uint64_t*)&cgen_var_1264, 1 * 8);
+ uint64_t cgen_var_1268;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1268, 1);
+ stream->write((uint64_t*)&cgen_var_1268, 1 * 8);
AEMU_SCOPED_TRACE("vkCmdEndConditionalRenderingEXT readParams");
AEMU_SCOPED_TRACE("vkCmdEndConditionalRenderingEXT returnUnmarshal");
mImpl->log("finish vkCmdEndConditionalRenderingEXT");;
@@ -18966,6 +19351,7 @@
VkCommandBuffer commandBuffer,
const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdProcessCommandsNVX encode");
mImpl->log("start vkCmdProcessCommandsNVX");
auto stream = mImpl->stream();
@@ -18988,9 +19374,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1265;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1265, 1);
- countingStream->write((uint64_t*)&cgen_var_1265, 1 * 8);
+ uint64_t cgen_var_1269;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1269, 1);
+ countingStream->write((uint64_t*)&cgen_var_1269, 1 * 8);
marshal_VkCmdProcessCommandsInfoNVX(countingStream, (VkCmdProcessCommandsInfoNVX*)(local_pProcessCommandsInfo));
}
uint32_t packetSize_vkCmdProcessCommandsNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -18998,9 +19384,9 @@
uint32_t opcode_vkCmdProcessCommandsNVX = OP_vkCmdProcessCommandsNVX;
stream->write(&opcode_vkCmdProcessCommandsNVX, sizeof(uint32_t));
stream->write(&packetSize_vkCmdProcessCommandsNVX, sizeof(uint32_t));
- uint64_t cgen_var_1266;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1266, 1);
- stream->write((uint64_t*)&cgen_var_1266, 1 * 8);
+ uint64_t cgen_var_1270;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1270, 1);
+ stream->write((uint64_t*)&cgen_var_1270, 1 * 8);
marshal_VkCmdProcessCommandsInfoNVX(stream, (VkCmdProcessCommandsInfoNVX*)(local_pProcessCommandsInfo));
AEMU_SCOPED_TRACE("vkCmdProcessCommandsNVX readParams");
AEMU_SCOPED_TRACE("vkCmdProcessCommandsNVX returnUnmarshal");
@@ -19011,6 +19397,7 @@
VkCommandBuffer commandBuffer,
const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdReserveSpaceForCommandsNVX encode");
mImpl->log("start vkCmdReserveSpaceForCommandsNVX");
auto stream = mImpl->stream();
@@ -19033,9 +19420,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1267;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1267, 1);
- countingStream->write((uint64_t*)&cgen_var_1267, 1 * 8);
+ uint64_t cgen_var_1271;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1271, 1);
+ countingStream->write((uint64_t*)&cgen_var_1271, 1 * 8);
marshal_VkCmdReserveSpaceForCommandsInfoNVX(countingStream, (VkCmdReserveSpaceForCommandsInfoNVX*)(local_pReserveSpaceInfo));
}
uint32_t packetSize_vkCmdReserveSpaceForCommandsNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -19043,9 +19430,9 @@
uint32_t opcode_vkCmdReserveSpaceForCommandsNVX = OP_vkCmdReserveSpaceForCommandsNVX;
stream->write(&opcode_vkCmdReserveSpaceForCommandsNVX, sizeof(uint32_t));
stream->write(&packetSize_vkCmdReserveSpaceForCommandsNVX, sizeof(uint32_t));
- uint64_t cgen_var_1268;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1268, 1);
- stream->write((uint64_t*)&cgen_var_1268, 1 * 8);
+ uint64_t cgen_var_1272;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1272, 1);
+ stream->write((uint64_t*)&cgen_var_1272, 1 * 8);
marshal_VkCmdReserveSpaceForCommandsInfoNVX(stream, (VkCmdReserveSpaceForCommandsInfoNVX*)(local_pReserveSpaceInfo));
AEMU_SCOPED_TRACE("vkCmdReserveSpaceForCommandsNVX readParams");
AEMU_SCOPED_TRACE("vkCmdReserveSpaceForCommandsNVX returnUnmarshal");
@@ -19058,6 +19445,7 @@
const VkAllocationCallbacks* pAllocator,
VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateIndirectCommandsLayoutNVX encode");
mImpl->log("start vkCreateIndirectCommandsLayoutNVX");
auto stream = mImpl->stream();
@@ -19092,47 +19480,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1269;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1269, 1);
- countingStream->write((uint64_t*)&cgen_var_1269, 1 * 8);
+ uint64_t cgen_var_1273;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1273, 1);
+ countingStream->write((uint64_t*)&cgen_var_1273, 1 * 8);
marshal_VkIndirectCommandsLayoutCreateInfoNVX(countingStream, (VkIndirectCommandsLayoutCreateInfoNVX*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1270 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1270);
+ uint64_t cgen_var_1274 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1274);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_1271;
- countingStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(pIndirectCommandsLayout, &cgen_var_1271, 1);
- countingStream->write((uint64_t*)&cgen_var_1271, 8);
+ uint64_t cgen_var_1275;
+ countingStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(pIndirectCommandsLayout, &cgen_var_1275, 1);
+ countingStream->write((uint64_t*)&cgen_var_1275, 8);
}
uint32_t packetSize_vkCreateIndirectCommandsLayoutNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateIndirectCommandsLayoutNVX = OP_vkCreateIndirectCommandsLayoutNVX;
stream->write(&opcode_vkCreateIndirectCommandsLayoutNVX, sizeof(uint32_t));
stream->write(&packetSize_vkCreateIndirectCommandsLayoutNVX, sizeof(uint32_t));
- uint64_t cgen_var_1272;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1272, 1);
- stream->write((uint64_t*)&cgen_var_1272, 1 * 8);
+ uint64_t cgen_var_1276;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1276, 1);
+ stream->write((uint64_t*)&cgen_var_1276, 1 * 8);
marshal_VkIndirectCommandsLayoutCreateInfoNVX(stream, (VkIndirectCommandsLayoutCreateInfoNVX*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1273 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1273);
+ uint64_t cgen_var_1277 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1277);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_1274;
- stream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(pIndirectCommandsLayout, &cgen_var_1274, 1);
- stream->write((uint64_t*)&cgen_var_1274, 8);
+ uint64_t cgen_var_1278;
+ stream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(pIndirectCommandsLayout, &cgen_var_1278, 1);
+ stream->write((uint64_t*)&cgen_var_1278, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateIndirectCommandsLayoutNVX readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_1275;
- stream->read((uint64_t*)&cgen_var_1275, 8);
- stream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_1275, (VkIndirectCommandsLayoutNVX*)pIndirectCommandsLayout, 1);
+ uint64_t cgen_var_1279;
+ stream->read((uint64_t*)&cgen_var_1279, 8);
+ stream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_1279, (VkIndirectCommandsLayoutNVX*)pIndirectCommandsLayout, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateIndirectCommandsLayoutNVX returnUnmarshal");
VkResult vkCreateIndirectCommandsLayoutNVX_VkResult_return = (VkResult)0;
@@ -19149,6 +19537,7 @@
VkIndirectCommandsLayoutNVX indirectCommandsLayout,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyIndirectCommandsLayoutNVX encode");
mImpl->log("start vkDestroyIndirectCommandsLayoutNVX");
auto stream = mImpl->stream();
@@ -19174,15 +19563,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1276;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1276, 1);
- countingStream->write((uint64_t*)&cgen_var_1276, 1 * 8);
- uint64_t cgen_var_1277;
- countingStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&local_indirectCommandsLayout, &cgen_var_1277, 1);
- countingStream->write((uint64_t*)&cgen_var_1277, 1 * 8);
+ uint64_t cgen_var_1280;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1280, 1);
+ countingStream->write((uint64_t*)&cgen_var_1280, 1 * 8);
+ uint64_t cgen_var_1281;
+ countingStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&local_indirectCommandsLayout, &cgen_var_1281, 1);
+ countingStream->write((uint64_t*)&cgen_var_1281, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1278 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1278);
+ uint64_t cgen_var_1282 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1282);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -19193,15 +19582,15 @@
uint32_t opcode_vkDestroyIndirectCommandsLayoutNVX = OP_vkDestroyIndirectCommandsLayoutNVX;
stream->write(&opcode_vkDestroyIndirectCommandsLayoutNVX, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyIndirectCommandsLayoutNVX, sizeof(uint32_t));
- uint64_t cgen_var_1279;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1279, 1);
- stream->write((uint64_t*)&cgen_var_1279, 1 * 8);
- uint64_t cgen_var_1280;
- stream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&local_indirectCommandsLayout, &cgen_var_1280, 1);
- stream->write((uint64_t*)&cgen_var_1280, 1 * 8);
+ uint64_t cgen_var_1283;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1283, 1);
+ stream->write((uint64_t*)&cgen_var_1283, 1 * 8);
+ uint64_t cgen_var_1284;
+ stream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&local_indirectCommandsLayout, &cgen_var_1284, 1);
+ stream->write((uint64_t*)&cgen_var_1284, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1281 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1281);
+ uint64_t cgen_var_1285 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1285);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -19218,6 +19607,7 @@
const VkAllocationCallbacks* pAllocator,
VkObjectTableNVX* pObjectTable)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateObjectTableNVX encode");
mImpl->log("start vkCreateObjectTableNVX");
auto stream = mImpl->stream();
@@ -19252,47 +19642,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1282;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1282, 1);
- countingStream->write((uint64_t*)&cgen_var_1282, 1 * 8);
+ uint64_t cgen_var_1286;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1286, 1);
+ countingStream->write((uint64_t*)&cgen_var_1286, 1 * 8);
marshal_VkObjectTableCreateInfoNVX(countingStream, (VkObjectTableCreateInfoNVX*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1283 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1283);
+ uint64_t cgen_var_1287 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1287);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_1284;
- countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(pObjectTable, &cgen_var_1284, 1);
- countingStream->write((uint64_t*)&cgen_var_1284, 8);
+ uint64_t cgen_var_1288;
+ countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(pObjectTable, &cgen_var_1288, 1);
+ countingStream->write((uint64_t*)&cgen_var_1288, 8);
}
uint32_t packetSize_vkCreateObjectTableNVX = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateObjectTableNVX = OP_vkCreateObjectTableNVX;
stream->write(&opcode_vkCreateObjectTableNVX, sizeof(uint32_t));
stream->write(&packetSize_vkCreateObjectTableNVX, sizeof(uint32_t));
- uint64_t cgen_var_1285;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1285, 1);
- stream->write((uint64_t*)&cgen_var_1285, 1 * 8);
+ uint64_t cgen_var_1289;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1289, 1);
+ stream->write((uint64_t*)&cgen_var_1289, 1 * 8);
marshal_VkObjectTableCreateInfoNVX(stream, (VkObjectTableCreateInfoNVX*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1286 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1286);
+ uint64_t cgen_var_1290 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1290);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_1287;
- stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(pObjectTable, &cgen_var_1287, 1);
- stream->write((uint64_t*)&cgen_var_1287, 8);
+ uint64_t cgen_var_1291;
+ stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(pObjectTable, &cgen_var_1291, 1);
+ stream->write((uint64_t*)&cgen_var_1291, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateObjectTableNVX readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_1288;
- stream->read((uint64_t*)&cgen_var_1288, 8);
- stream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_1288, (VkObjectTableNVX*)pObjectTable, 1);
+ uint64_t cgen_var_1292;
+ stream->read((uint64_t*)&cgen_var_1292, 8);
+ stream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_1292, (VkObjectTableNVX*)pObjectTable, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateObjectTableNVX returnUnmarshal");
VkResult vkCreateObjectTableNVX_VkResult_return = (VkResult)0;
@@ -19309,6 +19699,7 @@
VkObjectTableNVX objectTable,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyObjectTableNVX encode");
mImpl->log("start vkDestroyObjectTableNVX");
auto stream = mImpl->stream();
@@ -19334,15 +19725,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1289;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1289, 1);
- countingStream->write((uint64_t*)&cgen_var_1289, 1 * 8);
- uint64_t cgen_var_1290;
- countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1290, 1);
- countingStream->write((uint64_t*)&cgen_var_1290, 1 * 8);
+ uint64_t cgen_var_1293;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1293, 1);
+ countingStream->write((uint64_t*)&cgen_var_1293, 1 * 8);
+ uint64_t cgen_var_1294;
+ countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1294, 1);
+ countingStream->write((uint64_t*)&cgen_var_1294, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1291 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1291);
+ uint64_t cgen_var_1295 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1295);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -19353,15 +19744,15 @@
uint32_t opcode_vkDestroyObjectTableNVX = OP_vkDestroyObjectTableNVX;
stream->write(&opcode_vkDestroyObjectTableNVX, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyObjectTableNVX, sizeof(uint32_t));
- uint64_t cgen_var_1292;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1292, 1);
- stream->write((uint64_t*)&cgen_var_1292, 1 * 8);
- uint64_t cgen_var_1293;
- stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1293, 1);
- stream->write((uint64_t*)&cgen_var_1293, 1 * 8);
+ uint64_t cgen_var_1296;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1296, 1);
+ stream->write((uint64_t*)&cgen_var_1296, 1 * 8);
+ uint64_t cgen_var_1297;
+ stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1297, 1);
+ stream->write((uint64_t*)&cgen_var_1297, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1294 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1294);
+ uint64_t cgen_var_1298 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1298);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -19379,6 +19770,7 @@
const VkObjectTableEntryNVX* const* ppObjectTableEntries,
const uint32_t* pObjectIndices)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkRegisterObjectsNVX encode");
mImpl->log("start vkRegisterObjectsNVX");
auto stream = mImpl->stream();
@@ -19403,12 +19795,12 @@
(void)local_ppObjectTableEntries;
countingStream->rewind();
{
- uint64_t cgen_var_1295;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1295, 1);
- countingStream->write((uint64_t*)&cgen_var_1295, 1 * 8);
- uint64_t cgen_var_1296;
- countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1296, 1);
- countingStream->write((uint64_t*)&cgen_var_1296, 1 * 8);
+ uint64_t cgen_var_1299;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1299, 1);
+ countingStream->write((uint64_t*)&cgen_var_1299, 1 * 8);
+ uint64_t cgen_var_1300;
+ countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1300, 1);
+ countingStream->write((uint64_t*)&cgen_var_1300, 1 * 8);
countingStream->write((uint32_t*)&local_objectCount, sizeof(uint32_t));
(void)local_ppObjectTableEntries;
countingStream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t));
@@ -19418,12 +19810,12 @@
uint32_t opcode_vkRegisterObjectsNVX = OP_vkRegisterObjectsNVX;
stream->write(&opcode_vkRegisterObjectsNVX, sizeof(uint32_t));
stream->write(&packetSize_vkRegisterObjectsNVX, sizeof(uint32_t));
- uint64_t cgen_var_1297;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1297, 1);
- stream->write((uint64_t*)&cgen_var_1297, 1 * 8);
- uint64_t cgen_var_1298;
- stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1298, 1);
- stream->write((uint64_t*)&cgen_var_1298, 1 * 8);
+ uint64_t cgen_var_1301;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1301, 1);
+ stream->write((uint64_t*)&cgen_var_1301, 1 * 8);
+ uint64_t cgen_var_1302;
+ stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1302, 1);
+ stream->write((uint64_t*)&cgen_var_1302, 1 * 8);
stream->write((uint32_t*)&local_objectCount, sizeof(uint32_t));
(void)local_ppObjectTableEntries;
stream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t));
@@ -19445,6 +19837,7 @@
const VkObjectEntryTypeNVX* pObjectEntryTypes,
const uint32_t* pObjectIndices)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkUnregisterObjectsNVX encode");
mImpl->log("start vkUnregisterObjectsNVX");
auto stream = mImpl->stream();
@@ -19472,12 +19865,12 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1299;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1299, 1);
- countingStream->write((uint64_t*)&cgen_var_1299, 1 * 8);
- uint64_t cgen_var_1300;
- countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1300, 1);
- countingStream->write((uint64_t*)&cgen_var_1300, 1 * 8);
+ uint64_t cgen_var_1303;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1303, 1);
+ countingStream->write((uint64_t*)&cgen_var_1303, 1 * 8);
+ uint64_t cgen_var_1304;
+ countingStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1304, 1);
+ countingStream->write((uint64_t*)&cgen_var_1304, 1 * 8);
countingStream->write((uint32_t*)&local_objectCount, sizeof(uint32_t));
countingStream->write((VkObjectEntryTypeNVX*)local_pObjectEntryTypes, ((objectCount)) * sizeof(VkObjectEntryTypeNVX));
countingStream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t));
@@ -19487,12 +19880,12 @@
uint32_t opcode_vkUnregisterObjectsNVX = OP_vkUnregisterObjectsNVX;
stream->write(&opcode_vkUnregisterObjectsNVX, sizeof(uint32_t));
stream->write(&packetSize_vkUnregisterObjectsNVX, sizeof(uint32_t));
- uint64_t cgen_var_1301;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1301, 1);
- stream->write((uint64_t*)&cgen_var_1301, 1 * 8);
- uint64_t cgen_var_1302;
- stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1302, 1);
- stream->write((uint64_t*)&cgen_var_1302, 1 * 8);
+ uint64_t cgen_var_1305;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1305, 1);
+ stream->write((uint64_t*)&cgen_var_1305, 1 * 8);
+ uint64_t cgen_var_1306;
+ stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&local_objectTable, &cgen_var_1306, 1);
+ stream->write((uint64_t*)&cgen_var_1306, 1 * 8);
stream->write((uint32_t*)&local_objectCount, sizeof(uint32_t));
stream->write((VkObjectEntryTypeNVX*)local_pObjectEntryTypes, ((objectCount)) * sizeof(VkObjectEntryTypeNVX));
stream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t));
@@ -19512,6 +19905,7 @@
VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
VkDeviceGeneratedCommandsLimitsNVX* pLimits)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX encode");
mImpl->log("start vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX");
auto stream = mImpl->stream();
@@ -19523,9 +19917,9 @@
local_physicalDevice = physicalDevice;
countingStream->rewind();
{
- uint64_t cgen_var_1303;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1303, 1);
- countingStream->write((uint64_t*)&cgen_var_1303, 1 * 8);
+ uint64_t cgen_var_1307;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1307, 1);
+ countingStream->write((uint64_t*)&cgen_var_1307, 1 * 8);
marshal_VkDeviceGeneratedCommandsFeaturesNVX(countingStream, (VkDeviceGeneratedCommandsFeaturesNVX*)(pFeatures));
marshal_VkDeviceGeneratedCommandsLimitsNVX(countingStream, (VkDeviceGeneratedCommandsLimitsNVX*)(pLimits));
}
@@ -19534,9 +19928,9 @@
uint32_t opcode_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX = OP_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX;
stream->write(&opcode_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX, sizeof(uint32_t));
- uint64_t cgen_var_1304;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1304, 1);
- stream->write((uint64_t*)&cgen_var_1304, 1 * 8);
+ uint64_t cgen_var_1308;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1308, 1);
+ stream->write((uint64_t*)&cgen_var_1308, 1 * 8);
marshal_VkDeviceGeneratedCommandsFeaturesNVX(stream, (VkDeviceGeneratedCommandsFeaturesNVX*)(pFeatures));
marshal_VkDeviceGeneratedCommandsLimitsNVX(stream, (VkDeviceGeneratedCommandsLimitsNVX*)(pLimits));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX readParams");
@@ -19562,6 +19956,7 @@
uint32_t viewportCount,
const VkViewportWScalingNV* pViewportWScalings)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdSetViewportWScalingNV encode");
mImpl->log("start vkCmdSetViewportWScalingNV");
auto stream = mImpl->stream();
@@ -19594,9 +19989,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1305;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1305, 1);
- countingStream->write((uint64_t*)&cgen_var_1305, 1 * 8);
+ uint64_t cgen_var_1309;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1309, 1);
+ countingStream->write((uint64_t*)&cgen_var_1309, 1 * 8);
countingStream->write((uint32_t*)&local_firstViewport, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_viewportCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
@@ -19609,9 +20004,9 @@
uint32_t opcode_vkCmdSetViewportWScalingNV = OP_vkCmdSetViewportWScalingNV;
stream->write(&opcode_vkCmdSetViewportWScalingNV, sizeof(uint32_t));
stream->write(&packetSize_vkCmdSetViewportWScalingNV, sizeof(uint32_t));
- uint64_t cgen_var_1306;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1306, 1);
- stream->write((uint64_t*)&cgen_var_1306, 1 * 8);
+ uint64_t cgen_var_1310;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1310, 1);
+ stream->write((uint64_t*)&cgen_var_1310, 1 * 8);
stream->write((uint32_t*)&local_firstViewport, sizeof(uint32_t));
stream->write((uint32_t*)&local_viewportCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
@@ -19629,6 +20024,7 @@
VkPhysicalDevice physicalDevice,
VkDisplayKHR display)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkReleaseDisplayEXT encode");
mImpl->log("start vkReleaseDisplayEXT");
auto stream = mImpl->stream();
@@ -19642,24 +20038,24 @@
local_display = display;
countingStream->rewind();
{
- uint64_t cgen_var_1307;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1307, 1);
- countingStream->write((uint64_t*)&cgen_var_1307, 1 * 8);
- uint64_t cgen_var_1308;
- countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1308, 1);
- countingStream->write((uint64_t*)&cgen_var_1308, 1 * 8);
+ uint64_t cgen_var_1311;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1311, 1);
+ countingStream->write((uint64_t*)&cgen_var_1311, 1 * 8);
+ uint64_t cgen_var_1312;
+ countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1312, 1);
+ countingStream->write((uint64_t*)&cgen_var_1312, 1 * 8);
}
uint32_t packetSize_vkReleaseDisplayEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkReleaseDisplayEXT = OP_vkReleaseDisplayEXT;
stream->write(&opcode_vkReleaseDisplayEXT, sizeof(uint32_t));
stream->write(&packetSize_vkReleaseDisplayEXT, sizeof(uint32_t));
- uint64_t cgen_var_1309;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1309, 1);
- stream->write((uint64_t*)&cgen_var_1309, 1 * 8);
- uint64_t cgen_var_1310;
- stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1310, 1);
- stream->write((uint64_t*)&cgen_var_1310, 1 * 8);
+ uint64_t cgen_var_1313;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1313, 1);
+ stream->write((uint64_t*)&cgen_var_1313, 1 * 8);
+ uint64_t cgen_var_1314;
+ stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1314, 1);
+ stream->write((uint64_t*)&cgen_var_1314, 1 * 8);
AEMU_SCOPED_TRACE("vkReleaseDisplayEXT readParams");
AEMU_SCOPED_TRACE("vkReleaseDisplayEXT returnUnmarshal");
VkResult vkReleaseDisplayEXT_VkResult_return = (VkResult)0;
@@ -19678,6 +20074,7 @@
Display* dpy,
VkDisplayKHR display)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkAcquireXlibDisplayEXT encode");
mImpl->log("start vkAcquireXlibDisplayEXT");
auto stream = mImpl->stream();
@@ -19691,26 +20088,26 @@
local_display = display;
countingStream->rewind();
{
- uint64_t cgen_var_1311;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1311, 1);
- countingStream->write((uint64_t*)&cgen_var_1311, 1 * 8);
+ uint64_t cgen_var_1315;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1315, 1);
+ countingStream->write((uint64_t*)&cgen_var_1315, 1 * 8);
countingStream->write((Display*)dpy, sizeof(Display));
- uint64_t cgen_var_1312;
- countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1312, 1);
- countingStream->write((uint64_t*)&cgen_var_1312, 1 * 8);
+ uint64_t cgen_var_1316;
+ countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1316, 1);
+ countingStream->write((uint64_t*)&cgen_var_1316, 1 * 8);
}
uint32_t packetSize_vkAcquireXlibDisplayEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkAcquireXlibDisplayEXT = OP_vkAcquireXlibDisplayEXT;
stream->write(&opcode_vkAcquireXlibDisplayEXT, sizeof(uint32_t));
stream->write(&packetSize_vkAcquireXlibDisplayEXT, sizeof(uint32_t));
- uint64_t cgen_var_1313;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1313, 1);
- stream->write((uint64_t*)&cgen_var_1313, 1 * 8);
+ uint64_t cgen_var_1317;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1317, 1);
+ stream->write((uint64_t*)&cgen_var_1317, 1 * 8);
stream->write((Display*)dpy, sizeof(Display));
- uint64_t cgen_var_1314;
- stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1314, 1);
- stream->write((uint64_t*)&cgen_var_1314, 1 * 8);
+ uint64_t cgen_var_1318;
+ stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1318, 1);
+ stream->write((uint64_t*)&cgen_var_1318, 1 * 8);
AEMU_SCOPED_TRACE("vkAcquireXlibDisplayEXT readParams");
stream->read((Display*)dpy, sizeof(Display));
AEMU_SCOPED_TRACE("vkAcquireXlibDisplayEXT returnUnmarshal");
@@ -19729,6 +20126,7 @@
RROutput rrOutput,
VkDisplayKHR* pDisplay)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetRandROutputDisplayEXT encode");
mImpl->log("start vkGetRandROutputDisplayEXT");
auto stream = mImpl->stream();
@@ -19742,35 +20140,35 @@
local_rrOutput = rrOutput;
countingStream->rewind();
{
- uint64_t cgen_var_1315;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1315, 1);
- countingStream->write((uint64_t*)&cgen_var_1315, 1 * 8);
+ uint64_t cgen_var_1319;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1319, 1);
+ countingStream->write((uint64_t*)&cgen_var_1319, 1 * 8);
countingStream->write((Display*)dpy, sizeof(Display));
countingStream->write((RROutput*)&local_rrOutput, sizeof(RROutput));
- uint64_t cgen_var_1316;
- countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplay, &cgen_var_1316, 1);
- countingStream->write((uint64_t*)&cgen_var_1316, 8);
+ uint64_t cgen_var_1320;
+ countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplay, &cgen_var_1320, 1);
+ countingStream->write((uint64_t*)&cgen_var_1320, 8);
}
uint32_t packetSize_vkGetRandROutputDisplayEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkGetRandROutputDisplayEXT = OP_vkGetRandROutputDisplayEXT;
stream->write(&opcode_vkGetRandROutputDisplayEXT, sizeof(uint32_t));
stream->write(&packetSize_vkGetRandROutputDisplayEXT, sizeof(uint32_t));
- uint64_t cgen_var_1317;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1317, 1);
- stream->write((uint64_t*)&cgen_var_1317, 1 * 8);
+ uint64_t cgen_var_1321;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1321, 1);
+ stream->write((uint64_t*)&cgen_var_1321, 1 * 8);
stream->write((Display*)dpy, sizeof(Display));
stream->write((RROutput*)&local_rrOutput, sizeof(RROutput));
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_1318;
- stream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplay, &cgen_var_1318, 1);
- stream->write((uint64_t*)&cgen_var_1318, 8);
+ uint64_t cgen_var_1322;
+ stream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplay, &cgen_var_1322, 1);
+ stream->write((uint64_t*)&cgen_var_1322, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkGetRandROutputDisplayEXT readParams");
stream->read((Display*)dpy, sizeof(Display));
- uint64_t cgen_var_1319;
- stream->read((uint64_t*)&cgen_var_1319, 8);
- stream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_1319, (VkDisplayKHR*)pDisplay, 1);
+ uint64_t cgen_var_1323;
+ stream->read((uint64_t*)&cgen_var_1323, 8);
+ stream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_1323, (VkDisplayKHR*)pDisplay, 1);
AEMU_SCOPED_TRACE("vkGetRandROutputDisplayEXT returnUnmarshal");
VkResult vkGetRandROutputDisplayEXT_VkResult_return = (VkResult)0;
stream->read(&vkGetRandROutputDisplayEXT_VkResult_return, sizeof(VkResult));
@@ -19788,6 +20186,7 @@
VkSurfaceKHR surface,
VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2EXT encode");
mImpl->log("start vkGetPhysicalDeviceSurfaceCapabilities2EXT");
auto stream = mImpl->stream();
@@ -19801,12 +20200,12 @@
local_surface = surface;
countingStream->rewind();
{
- uint64_t cgen_var_1320;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1320, 1);
- countingStream->write((uint64_t*)&cgen_var_1320, 1 * 8);
- uint64_t cgen_var_1321;
- countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_1321, 1);
- countingStream->write((uint64_t*)&cgen_var_1321, 1 * 8);
+ uint64_t cgen_var_1324;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1324, 1);
+ countingStream->write((uint64_t*)&cgen_var_1324, 1 * 8);
+ uint64_t cgen_var_1325;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_1325, 1);
+ countingStream->write((uint64_t*)&cgen_var_1325, 1 * 8);
marshal_VkSurfaceCapabilities2EXT(countingStream, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
}
uint32_t packetSize_vkGetPhysicalDeviceSurfaceCapabilities2EXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -19814,12 +20213,12 @@
uint32_t opcode_vkGetPhysicalDeviceSurfaceCapabilities2EXT = OP_vkGetPhysicalDeviceSurfaceCapabilities2EXT;
stream->write(&opcode_vkGetPhysicalDeviceSurfaceCapabilities2EXT, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceSurfaceCapabilities2EXT, sizeof(uint32_t));
- uint64_t cgen_var_1322;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1322, 1);
- stream->write((uint64_t*)&cgen_var_1322, 1 * 8);
- uint64_t cgen_var_1323;
- stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_1323, 1);
- stream->write((uint64_t*)&cgen_var_1323, 1 * 8);
+ uint64_t cgen_var_1326;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1326, 1);
+ stream->write((uint64_t*)&cgen_var_1326, 1 * 8);
+ uint64_t cgen_var_1327;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_1327, 1);
+ stream->write((uint64_t*)&cgen_var_1327, 1 * 8);
marshal_VkSurfaceCapabilities2EXT(stream, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2EXT readParams");
unmarshal_VkSurfaceCapabilities2EXT(stream, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
@@ -19844,6 +20243,7 @@
VkDisplayKHR display,
const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDisplayPowerControlEXT encode");
mImpl->log("start vkDisplayPowerControlEXT");
auto stream = mImpl->stream();
@@ -19868,12 +20268,12 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1324;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1324, 1);
- countingStream->write((uint64_t*)&cgen_var_1324, 1 * 8);
- uint64_t cgen_var_1325;
- countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1325, 1);
- countingStream->write((uint64_t*)&cgen_var_1325, 1 * 8);
+ uint64_t cgen_var_1328;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1328, 1);
+ countingStream->write((uint64_t*)&cgen_var_1328, 1 * 8);
+ uint64_t cgen_var_1329;
+ countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1329, 1);
+ countingStream->write((uint64_t*)&cgen_var_1329, 1 * 8);
marshal_VkDisplayPowerInfoEXT(countingStream, (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo));
}
uint32_t packetSize_vkDisplayPowerControlEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -19881,12 +20281,12 @@
uint32_t opcode_vkDisplayPowerControlEXT = OP_vkDisplayPowerControlEXT;
stream->write(&opcode_vkDisplayPowerControlEXT, sizeof(uint32_t));
stream->write(&packetSize_vkDisplayPowerControlEXT, sizeof(uint32_t));
- uint64_t cgen_var_1326;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1326, 1);
- stream->write((uint64_t*)&cgen_var_1326, 1 * 8);
- uint64_t cgen_var_1327;
- stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1327, 1);
- stream->write((uint64_t*)&cgen_var_1327, 1 * 8);
+ uint64_t cgen_var_1330;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1330, 1);
+ stream->write((uint64_t*)&cgen_var_1330, 1 * 8);
+ uint64_t cgen_var_1331;
+ stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1331, 1);
+ stream->write((uint64_t*)&cgen_var_1331, 1 * 8);
marshal_VkDisplayPowerInfoEXT(stream, (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo));
AEMU_SCOPED_TRACE("vkDisplayPowerControlEXT readParams");
AEMU_SCOPED_TRACE("vkDisplayPowerControlEXT returnUnmarshal");
@@ -19905,6 +20305,7 @@
const VkAllocationCallbacks* pAllocator,
VkFence* pFence)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkRegisterDeviceEventEXT encode");
mImpl->log("start vkRegisterDeviceEventEXT");
auto stream = mImpl->stream();
@@ -19939,46 +20340,46 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1328;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1328, 1);
- countingStream->write((uint64_t*)&cgen_var_1328, 1 * 8);
+ uint64_t cgen_var_1332;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1332, 1);
+ countingStream->write((uint64_t*)&cgen_var_1332, 1 * 8);
marshal_VkDeviceEventInfoEXT(countingStream, (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1329 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1329);
+ uint64_t cgen_var_1333 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1333);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_1330;
- countingStream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1330, 1);
- countingStream->write((uint64_t*)&cgen_var_1330, 8);
+ uint64_t cgen_var_1334;
+ countingStream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1334, 1);
+ countingStream->write((uint64_t*)&cgen_var_1334, 8);
}
uint32_t packetSize_vkRegisterDeviceEventEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkRegisterDeviceEventEXT = OP_vkRegisterDeviceEventEXT;
stream->write(&opcode_vkRegisterDeviceEventEXT, sizeof(uint32_t));
stream->write(&packetSize_vkRegisterDeviceEventEXT, sizeof(uint32_t));
- uint64_t cgen_var_1331;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1331, 1);
- stream->write((uint64_t*)&cgen_var_1331, 1 * 8);
+ uint64_t cgen_var_1335;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1335, 1);
+ stream->write((uint64_t*)&cgen_var_1335, 1 * 8);
marshal_VkDeviceEventInfoEXT(stream, (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1332 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1332);
+ uint64_t cgen_var_1336 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1336);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_1333;
- stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1333, 1);
- stream->write((uint64_t*)&cgen_var_1333, 8);
+ uint64_t cgen_var_1337;
+ stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1337, 1);
+ stream->write((uint64_t*)&cgen_var_1337, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkRegisterDeviceEventEXT readParams");
- uint64_t cgen_var_1334;
- stream->read((uint64_t*)&cgen_var_1334, 8);
- stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_1334, (VkFence*)pFence, 1);
+ uint64_t cgen_var_1338;
+ stream->read((uint64_t*)&cgen_var_1338, 8);
+ stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_1338, (VkFence*)pFence, 1);
AEMU_SCOPED_TRACE("vkRegisterDeviceEventEXT returnUnmarshal");
VkResult vkRegisterDeviceEventEXT_VkResult_return = (VkResult)0;
stream->read(&vkRegisterDeviceEventEXT_VkResult_return, sizeof(VkResult));
@@ -19996,6 +20397,7 @@
const VkAllocationCallbacks* pAllocator,
VkFence* pFence)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkRegisterDisplayEventEXT encode");
mImpl->log("start vkRegisterDisplayEventEXT");
auto stream = mImpl->stream();
@@ -20032,52 +20434,52 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1335;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1335, 1);
- countingStream->write((uint64_t*)&cgen_var_1335, 1 * 8);
- uint64_t cgen_var_1336;
- countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1336, 1);
- countingStream->write((uint64_t*)&cgen_var_1336, 1 * 8);
+ uint64_t cgen_var_1339;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1339, 1);
+ countingStream->write((uint64_t*)&cgen_var_1339, 1 * 8);
+ uint64_t cgen_var_1340;
+ countingStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1340, 1);
+ countingStream->write((uint64_t*)&cgen_var_1340, 1 * 8);
marshal_VkDisplayEventInfoEXT(countingStream, (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1337 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1337);
+ uint64_t cgen_var_1341 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1341);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_1338;
- countingStream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1338, 1);
- countingStream->write((uint64_t*)&cgen_var_1338, 8);
+ uint64_t cgen_var_1342;
+ countingStream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1342, 1);
+ countingStream->write((uint64_t*)&cgen_var_1342, 8);
}
uint32_t packetSize_vkRegisterDisplayEventEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkRegisterDisplayEventEXT = OP_vkRegisterDisplayEventEXT;
stream->write(&opcode_vkRegisterDisplayEventEXT, sizeof(uint32_t));
stream->write(&packetSize_vkRegisterDisplayEventEXT, sizeof(uint32_t));
- uint64_t cgen_var_1339;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1339, 1);
- stream->write((uint64_t*)&cgen_var_1339, 1 * 8);
- uint64_t cgen_var_1340;
- stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1340, 1);
- stream->write((uint64_t*)&cgen_var_1340, 1 * 8);
+ uint64_t cgen_var_1343;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1343, 1);
+ stream->write((uint64_t*)&cgen_var_1343, 1 * 8);
+ uint64_t cgen_var_1344;
+ stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1344, 1);
+ stream->write((uint64_t*)&cgen_var_1344, 1 * 8);
marshal_VkDisplayEventInfoEXT(stream, (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1341 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1341);
+ uint64_t cgen_var_1345 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1345);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_1342;
- stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1342, 1);
- stream->write((uint64_t*)&cgen_var_1342, 8);
+ uint64_t cgen_var_1346;
+ stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1346, 1);
+ stream->write((uint64_t*)&cgen_var_1346, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkRegisterDisplayEventEXT readParams");
- uint64_t cgen_var_1343;
- stream->read((uint64_t*)&cgen_var_1343, 8);
- stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_1343, (VkFence*)pFence, 1);
+ uint64_t cgen_var_1347;
+ stream->read((uint64_t*)&cgen_var_1347, 8);
+ stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_1347, (VkFence*)pFence, 1);
AEMU_SCOPED_TRACE("vkRegisterDisplayEventEXT returnUnmarshal");
VkResult vkRegisterDisplayEventEXT_VkResult_return = (VkResult)0;
stream->read(&vkRegisterDisplayEventEXT_VkResult_return, sizeof(VkResult));
@@ -20094,6 +20496,7 @@
VkSurfaceCounterFlagBitsEXT counter,
uint64_t* pCounterValue)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetSwapchainCounterEXT encode");
mImpl->log("start vkGetSwapchainCounterEXT");
auto stream = mImpl->stream();
@@ -20109,12 +20512,12 @@
local_counter = counter;
countingStream->rewind();
{
- uint64_t cgen_var_1344;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1344, 1);
- countingStream->write((uint64_t*)&cgen_var_1344, 1 * 8);
- uint64_t cgen_var_1345;
- countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1345, 1);
- countingStream->write((uint64_t*)&cgen_var_1345, 1 * 8);
+ uint64_t cgen_var_1348;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1348, 1);
+ countingStream->write((uint64_t*)&cgen_var_1348, 1 * 8);
+ uint64_t cgen_var_1349;
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1349, 1);
+ countingStream->write((uint64_t*)&cgen_var_1349, 1 * 8);
countingStream->write((VkSurfaceCounterFlagBitsEXT*)&local_counter, sizeof(VkSurfaceCounterFlagBitsEXT));
countingStream->write((uint64_t*)pCounterValue, sizeof(uint64_t));
}
@@ -20123,12 +20526,12 @@
uint32_t opcode_vkGetSwapchainCounterEXT = OP_vkGetSwapchainCounterEXT;
stream->write(&opcode_vkGetSwapchainCounterEXT, sizeof(uint32_t));
stream->write(&packetSize_vkGetSwapchainCounterEXT, sizeof(uint32_t));
- uint64_t cgen_var_1346;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1346, 1);
- stream->write((uint64_t*)&cgen_var_1346, 1 * 8);
- uint64_t cgen_var_1347;
- stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1347, 1);
- stream->write((uint64_t*)&cgen_var_1347, 1 * 8);
+ uint64_t cgen_var_1350;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1350, 1);
+ stream->write((uint64_t*)&cgen_var_1350, 1 * 8);
+ uint64_t cgen_var_1351;
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1351, 1);
+ stream->write((uint64_t*)&cgen_var_1351, 1 * 8);
stream->write((VkSurfaceCounterFlagBitsEXT*)&local_counter, sizeof(VkSurfaceCounterFlagBitsEXT));
stream->write((uint64_t*)pCounterValue, sizeof(uint64_t));
AEMU_SCOPED_TRACE("vkGetSwapchainCounterEXT readParams");
@@ -20150,6 +20553,7 @@
VkSwapchainKHR swapchain,
VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetRefreshCycleDurationGOOGLE encode");
mImpl->log("start vkGetRefreshCycleDurationGOOGLE");
auto stream = mImpl->stream();
@@ -20163,12 +20567,12 @@
local_swapchain = swapchain;
countingStream->rewind();
{
- uint64_t cgen_var_1348;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1348, 1);
- countingStream->write((uint64_t*)&cgen_var_1348, 1 * 8);
- uint64_t cgen_var_1349;
- countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1349, 1);
- countingStream->write((uint64_t*)&cgen_var_1349, 1 * 8);
+ uint64_t cgen_var_1352;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1352, 1);
+ countingStream->write((uint64_t*)&cgen_var_1352, 1 * 8);
+ uint64_t cgen_var_1353;
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1353, 1);
+ countingStream->write((uint64_t*)&cgen_var_1353, 1 * 8);
marshal_VkRefreshCycleDurationGOOGLE(countingStream, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
}
uint32_t packetSize_vkGetRefreshCycleDurationGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -20176,12 +20580,12 @@
uint32_t opcode_vkGetRefreshCycleDurationGOOGLE = OP_vkGetRefreshCycleDurationGOOGLE;
stream->write(&opcode_vkGetRefreshCycleDurationGOOGLE, sizeof(uint32_t));
stream->write(&packetSize_vkGetRefreshCycleDurationGOOGLE, sizeof(uint32_t));
- uint64_t cgen_var_1350;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1350, 1);
- stream->write((uint64_t*)&cgen_var_1350, 1 * 8);
- uint64_t cgen_var_1351;
- stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1351, 1);
- stream->write((uint64_t*)&cgen_var_1351, 1 * 8);
+ uint64_t cgen_var_1354;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1354, 1);
+ stream->write((uint64_t*)&cgen_var_1354, 1 * 8);
+ uint64_t cgen_var_1355;
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1355, 1);
+ stream->write((uint64_t*)&cgen_var_1355, 1 * 8);
marshal_VkRefreshCycleDurationGOOGLE(stream, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
AEMU_SCOPED_TRACE("vkGetRefreshCycleDurationGOOGLE readParams");
unmarshal_VkRefreshCycleDurationGOOGLE(stream, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
@@ -20205,6 +20609,7 @@
uint32_t* pPresentationTimingCount,
VkPastPresentationTimingGOOGLE* pPresentationTimings)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPastPresentationTimingGOOGLE encode");
mImpl->log("start vkGetPastPresentationTimingGOOGLE");
auto stream = mImpl->stream();
@@ -20218,22 +20623,22 @@
local_swapchain = swapchain;
countingStream->rewind();
{
- uint64_t cgen_var_1352;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1352, 1);
- countingStream->write((uint64_t*)&cgen_var_1352, 1 * 8);
- uint64_t cgen_var_1353;
- countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1353, 1);
- countingStream->write((uint64_t*)&cgen_var_1353, 1 * 8);
+ uint64_t cgen_var_1356;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1356, 1);
+ countingStream->write((uint64_t*)&cgen_var_1356, 1 * 8);
+ uint64_t cgen_var_1357;
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1357, 1);
+ countingStream->write((uint64_t*)&cgen_var_1357, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1354 = (uint64_t)(uintptr_t)pPresentationTimingCount;
- countingStream->putBe64(cgen_var_1354);
+ uint64_t cgen_var_1358 = (uint64_t)(uintptr_t)pPresentationTimingCount;
+ countingStream->putBe64(cgen_var_1358);
if (pPresentationTimingCount)
{
countingStream->write((uint32_t*)pPresentationTimingCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1355 = (uint64_t)(uintptr_t)pPresentationTimings;
- countingStream->putBe64(cgen_var_1355);
+ uint64_t cgen_var_1359 = (uint64_t)(uintptr_t)pPresentationTimings;
+ countingStream->putBe64(cgen_var_1359);
if (pPresentationTimings)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i)
@@ -20247,22 +20652,22 @@
uint32_t opcode_vkGetPastPresentationTimingGOOGLE = OP_vkGetPastPresentationTimingGOOGLE;
stream->write(&opcode_vkGetPastPresentationTimingGOOGLE, sizeof(uint32_t));
stream->write(&packetSize_vkGetPastPresentationTimingGOOGLE, sizeof(uint32_t));
- uint64_t cgen_var_1356;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1356, 1);
- stream->write((uint64_t*)&cgen_var_1356, 1 * 8);
- uint64_t cgen_var_1357;
- stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1357, 1);
- stream->write((uint64_t*)&cgen_var_1357, 1 * 8);
+ uint64_t cgen_var_1360;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1360, 1);
+ stream->write((uint64_t*)&cgen_var_1360, 1 * 8);
+ uint64_t cgen_var_1361;
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1361, 1);
+ stream->write((uint64_t*)&cgen_var_1361, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1358 = (uint64_t)(uintptr_t)pPresentationTimingCount;
- stream->putBe64(cgen_var_1358);
+ uint64_t cgen_var_1362 = (uint64_t)(uintptr_t)pPresentationTimingCount;
+ stream->putBe64(cgen_var_1362);
if (pPresentationTimingCount)
{
stream->write((uint32_t*)pPresentationTimingCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1359 = (uint64_t)(uintptr_t)pPresentationTimings;
- stream->putBe64(cgen_var_1359);
+ uint64_t cgen_var_1363 = (uint64_t)(uintptr_t)pPresentationTimings;
+ stream->putBe64(cgen_var_1363);
if (pPresentationTimings)
{
for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i)
@@ -20331,6 +20736,7 @@
uint32_t discardRectangleCount,
const VkRect2D* pDiscardRectangles)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdSetDiscardRectangleEXT encode");
mImpl->log("start vkCmdSetDiscardRectangleEXT");
auto stream = mImpl->stream();
@@ -20363,9 +20769,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1362;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1362, 1);
- countingStream->write((uint64_t*)&cgen_var_1362, 1 * 8);
+ uint64_t cgen_var_1366;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1366, 1);
+ countingStream->write((uint64_t*)&cgen_var_1366, 1 * 8);
countingStream->write((uint32_t*)&local_firstDiscardRectangle, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_discardRectangleCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
@@ -20378,9 +20784,9 @@
uint32_t opcode_vkCmdSetDiscardRectangleEXT = OP_vkCmdSetDiscardRectangleEXT;
stream->write(&opcode_vkCmdSetDiscardRectangleEXT, sizeof(uint32_t));
stream->write(&packetSize_vkCmdSetDiscardRectangleEXT, sizeof(uint32_t));
- uint64_t cgen_var_1363;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1363, 1);
- stream->write((uint64_t*)&cgen_var_1363, 1 * 8);
+ uint64_t cgen_var_1367;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1367, 1);
+ stream->write((uint64_t*)&cgen_var_1367, 1 * 8);
stream->write((uint32_t*)&local_firstDiscardRectangle, sizeof(uint32_t));
stream->write((uint32_t*)&local_discardRectangleCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
@@ -20404,6 +20810,7 @@
const VkSwapchainKHR* pSwapchains,
const VkHdrMetadataEXT* pMetadata)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkSetHdrMetadataEXT encode");
mImpl->log("start vkSetHdrMetadataEXT");
auto stream = mImpl->stream();
@@ -20440,16 +20847,16 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1364;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1364, 1);
- countingStream->write((uint64_t*)&cgen_var_1364, 1 * 8);
+ uint64_t cgen_var_1368;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1368, 1);
+ countingStream->write((uint64_t*)&cgen_var_1368, 1 * 8);
countingStream->write((uint32_t*)&local_swapchainCount, sizeof(uint32_t));
if (((swapchainCount)))
{
- uint64_t* cgen_var_1365;
- countingStream->alloc((void**)&cgen_var_1365, ((swapchainCount)) * 8);
- countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(local_pSwapchains, cgen_var_1365, ((swapchainCount)));
- countingStream->write((uint64_t*)cgen_var_1365, ((swapchainCount)) * 8);
+ uint64_t* cgen_var_1369;
+ countingStream->alloc((void**)&cgen_var_1369, ((swapchainCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(local_pSwapchains, cgen_var_1369, ((swapchainCount)));
+ countingStream->write((uint64_t*)cgen_var_1369, ((swapchainCount)) * 8);
}
for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
{
@@ -20461,16 +20868,16 @@
uint32_t opcode_vkSetHdrMetadataEXT = OP_vkSetHdrMetadataEXT;
stream->write(&opcode_vkSetHdrMetadataEXT, sizeof(uint32_t));
stream->write(&packetSize_vkSetHdrMetadataEXT, sizeof(uint32_t));
- uint64_t cgen_var_1366;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1366, 1);
- stream->write((uint64_t*)&cgen_var_1366, 1 * 8);
+ uint64_t cgen_var_1370;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1370, 1);
+ stream->write((uint64_t*)&cgen_var_1370, 1 * 8);
stream->write((uint32_t*)&local_swapchainCount, sizeof(uint32_t));
if (((swapchainCount)))
{
- uint64_t* cgen_var_1367;
- stream->alloc((void**)&cgen_var_1367, ((swapchainCount)) * 8);
- stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(local_pSwapchains, cgen_var_1367, ((swapchainCount)));
- stream->write((uint64_t*)cgen_var_1367, ((swapchainCount)) * 8);
+ uint64_t* cgen_var_1371;
+ stream->alloc((void**)&cgen_var_1371, ((swapchainCount)) * 8);
+ stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(local_pSwapchains, cgen_var_1371, ((swapchainCount)));
+ stream->write((uint64_t*)cgen_var_1371, ((swapchainCount)) * 8);
}
for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
{
@@ -20489,6 +20896,7 @@
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateIOSSurfaceMVK encode");
mImpl->log("start vkCreateIOSSurfaceMVK");
auto stream = mImpl->stream();
@@ -20523,46 +20931,46 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1368;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1368, 1);
- countingStream->write((uint64_t*)&cgen_var_1368, 1 * 8);
+ uint64_t cgen_var_1372;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1372, 1);
+ countingStream->write((uint64_t*)&cgen_var_1372, 1 * 8);
marshal_VkIOSSurfaceCreateInfoMVK(countingStream, (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1369 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1369);
+ uint64_t cgen_var_1373 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1373);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_1370;
- countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1370, 1);
- countingStream->write((uint64_t*)&cgen_var_1370, 8);
+ uint64_t cgen_var_1374;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1374, 1);
+ countingStream->write((uint64_t*)&cgen_var_1374, 8);
}
uint32_t packetSize_vkCreateIOSSurfaceMVK = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateIOSSurfaceMVK = OP_vkCreateIOSSurfaceMVK;
stream->write(&opcode_vkCreateIOSSurfaceMVK, sizeof(uint32_t));
stream->write(&packetSize_vkCreateIOSSurfaceMVK, sizeof(uint32_t));
- uint64_t cgen_var_1371;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1371, 1);
- stream->write((uint64_t*)&cgen_var_1371, 1 * 8);
+ uint64_t cgen_var_1375;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1375, 1);
+ stream->write((uint64_t*)&cgen_var_1375, 1 * 8);
marshal_VkIOSSurfaceCreateInfoMVK(stream, (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1372 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1372);
+ uint64_t cgen_var_1376 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1376);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_1373;
- stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1373, 1);
- stream->write((uint64_t*)&cgen_var_1373, 8);
+ uint64_t cgen_var_1377;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1377, 1);
+ stream->write((uint64_t*)&cgen_var_1377, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateIOSSurfaceMVK readParams");
- uint64_t cgen_var_1374;
- stream->read((uint64_t*)&cgen_var_1374, 8);
- stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1374, (VkSurfaceKHR*)pSurface, 1);
+ uint64_t cgen_var_1378;
+ stream->read((uint64_t*)&cgen_var_1378, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1378, (VkSurfaceKHR*)pSurface, 1);
AEMU_SCOPED_TRACE("vkCreateIOSSurfaceMVK returnUnmarshal");
VkResult vkCreateIOSSurfaceMVK_VkResult_return = (VkResult)0;
stream->read(&vkCreateIOSSurfaceMVK_VkResult_return, sizeof(VkResult));
@@ -20581,6 +20989,7 @@
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateMacOSSurfaceMVK encode");
mImpl->log("start vkCreateMacOSSurfaceMVK");
auto stream = mImpl->stream();
@@ -20615,46 +21024,46 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1375;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1375, 1);
- countingStream->write((uint64_t*)&cgen_var_1375, 1 * 8);
+ uint64_t cgen_var_1379;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1379, 1);
+ countingStream->write((uint64_t*)&cgen_var_1379, 1 * 8);
marshal_VkMacOSSurfaceCreateInfoMVK(countingStream, (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1376 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1376);
+ uint64_t cgen_var_1380 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1380);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_1377;
- countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1377, 1);
- countingStream->write((uint64_t*)&cgen_var_1377, 8);
+ uint64_t cgen_var_1381;
+ countingStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1381, 1);
+ countingStream->write((uint64_t*)&cgen_var_1381, 8);
}
uint32_t packetSize_vkCreateMacOSSurfaceMVK = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateMacOSSurfaceMVK = OP_vkCreateMacOSSurfaceMVK;
stream->write(&opcode_vkCreateMacOSSurfaceMVK, sizeof(uint32_t));
stream->write(&packetSize_vkCreateMacOSSurfaceMVK, sizeof(uint32_t));
- uint64_t cgen_var_1378;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1378, 1);
- stream->write((uint64_t*)&cgen_var_1378, 1 * 8);
+ uint64_t cgen_var_1382;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1382, 1);
+ stream->write((uint64_t*)&cgen_var_1382, 1 * 8);
marshal_VkMacOSSurfaceCreateInfoMVK(stream, (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1379 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1379);
+ uint64_t cgen_var_1383 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1383);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_1380;
- stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1380, 1);
- stream->write((uint64_t*)&cgen_var_1380, 8);
+ uint64_t cgen_var_1384;
+ stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1384, 1);
+ stream->write((uint64_t*)&cgen_var_1384, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateMacOSSurfaceMVK readParams");
- uint64_t cgen_var_1381;
- stream->read((uint64_t*)&cgen_var_1381, 8);
- stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1381, (VkSurfaceKHR*)pSurface, 1);
+ uint64_t cgen_var_1385;
+ stream->read((uint64_t*)&cgen_var_1385, 8);
+ stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1385, (VkSurfaceKHR*)pSurface, 1);
AEMU_SCOPED_TRACE("vkCreateMacOSSurfaceMVK returnUnmarshal");
VkResult vkCreateMacOSSurfaceMVK_VkResult_return = (VkResult)0;
stream->read(&vkCreateMacOSSurfaceMVK_VkResult_return, sizeof(VkResult));
@@ -20675,6 +21084,7 @@
VkDevice device,
const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectNameEXT encode");
mImpl->log("start vkSetDebugUtilsObjectNameEXT");
auto stream = mImpl->stream();
@@ -20697,9 +21107,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1382;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1382, 1);
- countingStream->write((uint64_t*)&cgen_var_1382, 1 * 8);
+ uint64_t cgen_var_1386;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1386, 1);
+ countingStream->write((uint64_t*)&cgen_var_1386, 1 * 8);
marshal_VkDebugUtilsObjectNameInfoEXT(countingStream, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo));
}
uint32_t packetSize_vkSetDebugUtilsObjectNameEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -20707,9 +21117,9 @@
uint32_t opcode_vkSetDebugUtilsObjectNameEXT = OP_vkSetDebugUtilsObjectNameEXT;
stream->write(&opcode_vkSetDebugUtilsObjectNameEXT, sizeof(uint32_t));
stream->write(&packetSize_vkSetDebugUtilsObjectNameEXT, sizeof(uint32_t));
- uint64_t cgen_var_1383;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1383, 1);
- stream->write((uint64_t*)&cgen_var_1383, 1 * 8);
+ uint64_t cgen_var_1387;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1387, 1);
+ stream->write((uint64_t*)&cgen_var_1387, 1 * 8);
marshal_VkDebugUtilsObjectNameInfoEXT(stream, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo));
AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectNameEXT readParams");
AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectNameEXT returnUnmarshal");
@@ -20726,6 +21136,7 @@
VkDevice device,
const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectTagEXT encode");
mImpl->log("start vkSetDebugUtilsObjectTagEXT");
auto stream = mImpl->stream();
@@ -20748,9 +21159,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1384;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1384, 1);
- countingStream->write((uint64_t*)&cgen_var_1384, 1 * 8);
+ uint64_t cgen_var_1388;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1388, 1);
+ countingStream->write((uint64_t*)&cgen_var_1388, 1 * 8);
marshal_VkDebugUtilsObjectTagInfoEXT(countingStream, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo));
}
uint32_t packetSize_vkSetDebugUtilsObjectTagEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -20758,9 +21169,9 @@
uint32_t opcode_vkSetDebugUtilsObjectTagEXT = OP_vkSetDebugUtilsObjectTagEXT;
stream->write(&opcode_vkSetDebugUtilsObjectTagEXT, sizeof(uint32_t));
stream->write(&packetSize_vkSetDebugUtilsObjectTagEXT, sizeof(uint32_t));
- uint64_t cgen_var_1385;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1385, 1);
- stream->write((uint64_t*)&cgen_var_1385, 1 * 8);
+ uint64_t cgen_var_1389;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1389, 1);
+ stream->write((uint64_t*)&cgen_var_1389, 1 * 8);
marshal_VkDebugUtilsObjectTagInfoEXT(stream, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo));
AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectTagEXT readParams");
AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectTagEXT returnUnmarshal");
@@ -20777,6 +21188,7 @@
VkQueue queue,
const VkDebugUtilsLabelEXT* pLabelInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkQueueBeginDebugUtilsLabelEXT encode");
mImpl->log("start vkQueueBeginDebugUtilsLabelEXT");
auto stream = mImpl->stream();
@@ -20799,115 +21211,72 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1386;
- countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1386, 1);
- countingStream->write((uint64_t*)&cgen_var_1386, 1 * 8);
- marshal_VkDebugUtilsLabelEXT(countingStream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
- }
- uint32_t packetSize_vkQueueBeginDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
- countingStream->rewind();
- uint32_t opcode_vkQueueBeginDebugUtilsLabelEXT = OP_vkQueueBeginDebugUtilsLabelEXT;
- stream->write(&opcode_vkQueueBeginDebugUtilsLabelEXT, sizeof(uint32_t));
- stream->write(&packetSize_vkQueueBeginDebugUtilsLabelEXT, sizeof(uint32_t));
- uint64_t cgen_var_1387;
- stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1387, 1);
- stream->write((uint64_t*)&cgen_var_1387, 1 * 8);
- marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
- AEMU_SCOPED_TRACE("vkQueueBeginDebugUtilsLabelEXT readParams");
- AEMU_SCOPED_TRACE("vkQueueBeginDebugUtilsLabelEXT returnUnmarshal");
- mImpl->log("finish vkQueueBeginDebugUtilsLabelEXT");;
-}
-
-void VkEncoder::vkQueueEndDebugUtilsLabelEXT(
- VkQueue queue)
-{
- AEMU_SCOPED_TRACE("vkQueueEndDebugUtilsLabelEXT encode");
- mImpl->log("start vkQueueEndDebugUtilsLabelEXT");
- auto stream = mImpl->stream();
- auto countingStream = mImpl->countingStream();
- auto resources = mImpl->resources();
- auto pool = mImpl->pool();
- stream->setHandleMapping(resources->unwrapMapping());
- VkQueue local_queue;
- local_queue = queue;
- countingStream->rewind();
- {
- uint64_t cgen_var_1388;
- countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1388, 1);
- countingStream->write((uint64_t*)&cgen_var_1388, 1 * 8);
- }
- uint32_t packetSize_vkQueueEndDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
- countingStream->rewind();
- uint32_t opcode_vkQueueEndDebugUtilsLabelEXT = OP_vkQueueEndDebugUtilsLabelEXT;
- stream->write(&opcode_vkQueueEndDebugUtilsLabelEXT, sizeof(uint32_t));
- stream->write(&packetSize_vkQueueEndDebugUtilsLabelEXT, sizeof(uint32_t));
- uint64_t cgen_var_1389;
- stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1389, 1);
- stream->write((uint64_t*)&cgen_var_1389, 1 * 8);
- AEMU_SCOPED_TRACE("vkQueueEndDebugUtilsLabelEXT readParams");
- AEMU_SCOPED_TRACE("vkQueueEndDebugUtilsLabelEXT returnUnmarshal");
- mImpl->log("finish vkQueueEndDebugUtilsLabelEXT");;
-}
-
-void VkEncoder::vkQueueInsertDebugUtilsLabelEXT(
- VkQueue queue,
- const VkDebugUtilsLabelEXT* pLabelInfo)
-{
- AEMU_SCOPED_TRACE("vkQueueInsertDebugUtilsLabelEXT encode");
- mImpl->log("start vkQueueInsertDebugUtilsLabelEXT");
- auto stream = mImpl->stream();
- auto countingStream = mImpl->countingStream();
- auto resources = mImpl->resources();
- auto pool = mImpl->pool();
- stream->setHandleMapping(resources->unwrapMapping());
- VkQueue local_queue;
- VkDebugUtilsLabelEXT* local_pLabelInfo;
- local_queue = queue;
- local_pLabelInfo = nullptr;
- if (pLabelInfo)
- {
- local_pLabelInfo = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
- deepcopy_VkDebugUtilsLabelEXT(pool, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
- }
- if (local_pLabelInfo)
- {
- transform_tohost_VkDebugUtilsLabelEXT(mImpl->resources(), (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
- }
- countingStream->rewind();
- {
uint64_t cgen_var_1390;
countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1390, 1);
countingStream->write((uint64_t*)&cgen_var_1390, 1 * 8);
marshal_VkDebugUtilsLabelEXT(countingStream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
}
- uint32_t packetSize_vkQueueInsertDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ uint32_t packetSize_vkQueueBeginDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
- uint32_t opcode_vkQueueInsertDebugUtilsLabelEXT = OP_vkQueueInsertDebugUtilsLabelEXT;
- stream->write(&opcode_vkQueueInsertDebugUtilsLabelEXT, sizeof(uint32_t));
- stream->write(&packetSize_vkQueueInsertDebugUtilsLabelEXT, sizeof(uint32_t));
+ uint32_t opcode_vkQueueBeginDebugUtilsLabelEXT = OP_vkQueueBeginDebugUtilsLabelEXT;
+ stream->write(&opcode_vkQueueBeginDebugUtilsLabelEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkQueueBeginDebugUtilsLabelEXT, sizeof(uint32_t));
uint64_t cgen_var_1391;
stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1391, 1);
stream->write((uint64_t*)&cgen_var_1391, 1 * 8);
marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
- AEMU_SCOPED_TRACE("vkQueueInsertDebugUtilsLabelEXT readParams");
- AEMU_SCOPED_TRACE("vkQueueInsertDebugUtilsLabelEXT returnUnmarshal");
- mImpl->log("finish vkQueueInsertDebugUtilsLabelEXT");;
+ AEMU_SCOPED_TRACE("vkQueueBeginDebugUtilsLabelEXT readParams");
+ AEMU_SCOPED_TRACE("vkQueueBeginDebugUtilsLabelEXT returnUnmarshal");
+ mImpl->log("finish vkQueueBeginDebugUtilsLabelEXT");;
}
-void VkEncoder::vkCmdBeginDebugUtilsLabelEXT(
- VkCommandBuffer commandBuffer,
- const VkDebugUtilsLabelEXT* pLabelInfo)
+void VkEncoder::vkQueueEndDebugUtilsLabelEXT(
+ VkQueue queue)
{
- AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT encode");
- mImpl->log("start vkCmdBeginDebugUtilsLabelEXT");
+ AutoLock encoderLock(mImpl->lock);
+ AEMU_SCOPED_TRACE("vkQueueEndDebugUtilsLabelEXT encode");
+ mImpl->log("start vkQueueEndDebugUtilsLabelEXT");
auto stream = mImpl->stream();
auto countingStream = mImpl->countingStream();
auto resources = mImpl->resources();
auto pool = mImpl->pool();
stream->setHandleMapping(resources->unwrapMapping());
- VkCommandBuffer local_commandBuffer;
+ VkQueue local_queue;
+ local_queue = queue;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1392;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1392, 1);
+ countingStream->write((uint64_t*)&cgen_var_1392, 1 * 8);
+ }
+ uint32_t packetSize_vkQueueEndDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkQueueEndDebugUtilsLabelEXT = OP_vkQueueEndDebugUtilsLabelEXT;
+ stream->write(&opcode_vkQueueEndDebugUtilsLabelEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkQueueEndDebugUtilsLabelEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1393;
+ stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1393, 1);
+ stream->write((uint64_t*)&cgen_var_1393, 1 * 8);
+ AEMU_SCOPED_TRACE("vkQueueEndDebugUtilsLabelEXT readParams");
+ AEMU_SCOPED_TRACE("vkQueueEndDebugUtilsLabelEXT returnUnmarshal");
+ mImpl->log("finish vkQueueEndDebugUtilsLabelEXT");;
+}
+
+void VkEncoder::vkQueueInsertDebugUtilsLabelEXT(
+ VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+ AutoLock encoderLock(mImpl->lock);
+ AEMU_SCOPED_TRACE("vkQueueInsertDebugUtilsLabelEXT encode");
+ mImpl->log("start vkQueueInsertDebugUtilsLabelEXT");
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkQueue local_queue;
VkDebugUtilsLabelEXT* local_pLabelInfo;
- local_commandBuffer = commandBuffer;
+ local_queue = queue;
local_pLabelInfo = nullptr;
if (pLabelInfo)
{
@@ -20920,62 +21289,32 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1392;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1392, 1);
- countingStream->write((uint64_t*)&cgen_var_1392, 1 * 8);
+ uint64_t cgen_var_1394;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1394, 1);
+ countingStream->write((uint64_t*)&cgen_var_1394, 1 * 8);
marshal_VkDebugUtilsLabelEXT(countingStream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
}
- uint32_t packetSize_vkCmdBeginDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ uint32_t packetSize_vkQueueInsertDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
- uint32_t opcode_vkCmdBeginDebugUtilsLabelEXT = OP_vkCmdBeginDebugUtilsLabelEXT;
- stream->write(&opcode_vkCmdBeginDebugUtilsLabelEXT, sizeof(uint32_t));
- stream->write(&packetSize_vkCmdBeginDebugUtilsLabelEXT, sizeof(uint32_t));
- uint64_t cgen_var_1393;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1393, 1);
- stream->write((uint64_t*)&cgen_var_1393, 1 * 8);
- marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
- AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT readParams");
- AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT returnUnmarshal");
- mImpl->log("finish vkCmdBeginDebugUtilsLabelEXT");;
-}
-
-void VkEncoder::vkCmdEndDebugUtilsLabelEXT(
- VkCommandBuffer commandBuffer)
-{
- AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT encode");
- mImpl->log("start vkCmdEndDebugUtilsLabelEXT");
- auto stream = mImpl->stream();
- auto countingStream = mImpl->countingStream();
- auto resources = mImpl->resources();
- auto pool = mImpl->pool();
- stream->setHandleMapping(resources->unwrapMapping());
- VkCommandBuffer local_commandBuffer;
- local_commandBuffer = commandBuffer;
- countingStream->rewind();
- {
- uint64_t cgen_var_1394;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1394, 1);
- countingStream->write((uint64_t*)&cgen_var_1394, 1 * 8);
- }
- uint32_t packetSize_vkCmdEndDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
- countingStream->rewind();
- uint32_t opcode_vkCmdEndDebugUtilsLabelEXT = OP_vkCmdEndDebugUtilsLabelEXT;
- stream->write(&opcode_vkCmdEndDebugUtilsLabelEXT, sizeof(uint32_t));
- stream->write(&packetSize_vkCmdEndDebugUtilsLabelEXT, sizeof(uint32_t));
+ uint32_t opcode_vkQueueInsertDebugUtilsLabelEXT = OP_vkQueueInsertDebugUtilsLabelEXT;
+ stream->write(&opcode_vkQueueInsertDebugUtilsLabelEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkQueueInsertDebugUtilsLabelEXT, sizeof(uint32_t));
uint64_t cgen_var_1395;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1395, 1);
+ stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1395, 1);
stream->write((uint64_t*)&cgen_var_1395, 1 * 8);
- AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT readParams");
- AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT returnUnmarshal");
- mImpl->log("finish vkCmdEndDebugUtilsLabelEXT");;
+ marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ AEMU_SCOPED_TRACE("vkQueueInsertDebugUtilsLabelEXT readParams");
+ AEMU_SCOPED_TRACE("vkQueueInsertDebugUtilsLabelEXT returnUnmarshal");
+ mImpl->log("finish vkQueueInsertDebugUtilsLabelEXT");;
}
-void VkEncoder::vkCmdInsertDebugUtilsLabelEXT(
+void VkEncoder::vkCmdBeginDebugUtilsLabelEXT(
VkCommandBuffer commandBuffer,
const VkDebugUtilsLabelEXT* pLabelInfo)
{
- AEMU_SCOPED_TRACE("vkCmdInsertDebugUtilsLabelEXT encode");
- mImpl->log("start vkCmdInsertDebugUtilsLabelEXT");
+ AutoLock encoderLock(mImpl->lock);
+ AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT encode");
+ mImpl->log("start vkCmdBeginDebugUtilsLabelEXT");
auto stream = mImpl->stream();
auto countingStream = mImpl->countingStream();
auto resources = mImpl->resources();
@@ -21001,14 +21340,92 @@
countingStream->write((uint64_t*)&cgen_var_1396, 1 * 8);
marshal_VkDebugUtilsLabelEXT(countingStream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
}
+ uint32_t packetSize_vkCmdBeginDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdBeginDebugUtilsLabelEXT = OP_vkCmdBeginDebugUtilsLabelEXT;
+ stream->write(&opcode_vkCmdBeginDebugUtilsLabelEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdBeginDebugUtilsLabelEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1397;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1397, 1);
+ stream->write((uint64_t*)&cgen_var_1397, 1 * 8);
+ marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT readParams");
+ AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT returnUnmarshal");
+ mImpl->log("finish vkCmdBeginDebugUtilsLabelEXT");;
+}
+
+void VkEncoder::vkCmdEndDebugUtilsLabelEXT(
+ VkCommandBuffer commandBuffer)
+{
+ AutoLock encoderLock(mImpl->lock);
+ AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT encode");
+ mImpl->log("start vkCmdEndDebugUtilsLabelEXT");
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ local_commandBuffer = commandBuffer;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1398;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1398, 1);
+ countingStream->write((uint64_t*)&cgen_var_1398, 1 * 8);
+ }
+ uint32_t packetSize_vkCmdEndDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCmdEndDebugUtilsLabelEXT = OP_vkCmdEndDebugUtilsLabelEXT;
+ stream->write(&opcode_vkCmdEndDebugUtilsLabelEXT, sizeof(uint32_t));
+ stream->write(&packetSize_vkCmdEndDebugUtilsLabelEXT, sizeof(uint32_t));
+ uint64_t cgen_var_1399;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1399, 1);
+ stream->write((uint64_t*)&cgen_var_1399, 1 * 8);
+ AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT readParams");
+ AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT returnUnmarshal");
+ mImpl->log("finish vkCmdEndDebugUtilsLabelEXT");;
+}
+
+void VkEncoder::vkCmdInsertDebugUtilsLabelEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+ AutoLock encoderLock(mImpl->lock);
+ AEMU_SCOPED_TRACE("vkCmdInsertDebugUtilsLabelEXT encode");
+ mImpl->log("start vkCmdInsertDebugUtilsLabelEXT");
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ VkDebugUtilsLabelEXT* local_pLabelInfo;
+ local_commandBuffer = commandBuffer;
+ local_pLabelInfo = nullptr;
+ if (pLabelInfo)
+ {
+ local_pLabelInfo = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
+ deepcopy_VkDebugUtilsLabelEXT(pool, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ }
+ if (local_pLabelInfo)
+ {
+ transform_tohost_VkDebugUtilsLabelEXT(mImpl->resources(), (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1400;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1400, 1);
+ countingStream->write((uint64_t*)&cgen_var_1400, 1 * 8);
+ marshal_VkDebugUtilsLabelEXT(countingStream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ }
uint32_t packetSize_vkCmdInsertDebugUtilsLabelEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCmdInsertDebugUtilsLabelEXT = OP_vkCmdInsertDebugUtilsLabelEXT;
stream->write(&opcode_vkCmdInsertDebugUtilsLabelEXT, sizeof(uint32_t));
stream->write(&packetSize_vkCmdInsertDebugUtilsLabelEXT, sizeof(uint32_t));
- uint64_t cgen_var_1397;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1397, 1);
- stream->write((uint64_t*)&cgen_var_1397, 1 * 8);
+ uint64_t cgen_var_1401;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1401, 1);
+ stream->write((uint64_t*)&cgen_var_1401, 1 * 8);
marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
AEMU_SCOPED_TRACE("vkCmdInsertDebugUtilsLabelEXT readParams");
AEMU_SCOPED_TRACE("vkCmdInsertDebugUtilsLabelEXT returnUnmarshal");
@@ -21021,6 +21438,7 @@
const VkAllocationCallbacks* pAllocator,
VkDebugUtilsMessengerEXT* pMessenger)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateDebugUtilsMessengerEXT encode");
mImpl->log("start vkCreateDebugUtilsMessengerEXT");
auto stream = mImpl->stream();
@@ -21055,47 +21473,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1398;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1398, 1);
- countingStream->write((uint64_t*)&cgen_var_1398, 1 * 8);
+ uint64_t cgen_var_1402;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1402, 1);
+ countingStream->write((uint64_t*)&cgen_var_1402, 1 * 8);
marshal_VkDebugUtilsMessengerCreateInfoEXT(countingStream, (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1399 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1399);
+ uint64_t cgen_var_1403 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1403);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_1400;
- countingStream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(pMessenger, &cgen_var_1400, 1);
- countingStream->write((uint64_t*)&cgen_var_1400, 8);
+ uint64_t cgen_var_1404;
+ countingStream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(pMessenger, &cgen_var_1404, 1);
+ countingStream->write((uint64_t*)&cgen_var_1404, 8);
}
uint32_t packetSize_vkCreateDebugUtilsMessengerEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateDebugUtilsMessengerEXT = OP_vkCreateDebugUtilsMessengerEXT;
stream->write(&opcode_vkCreateDebugUtilsMessengerEXT, sizeof(uint32_t));
stream->write(&packetSize_vkCreateDebugUtilsMessengerEXT, sizeof(uint32_t));
- uint64_t cgen_var_1401;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1401, 1);
- stream->write((uint64_t*)&cgen_var_1401, 1 * 8);
+ uint64_t cgen_var_1405;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1405, 1);
+ stream->write((uint64_t*)&cgen_var_1405, 1 * 8);
marshal_VkDebugUtilsMessengerCreateInfoEXT(stream, (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1402 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1402);
+ uint64_t cgen_var_1406 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1406);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_1403;
- stream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(pMessenger, &cgen_var_1403, 1);
- stream->write((uint64_t*)&cgen_var_1403, 8);
+ uint64_t cgen_var_1407;
+ stream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(pMessenger, &cgen_var_1407, 1);
+ stream->write((uint64_t*)&cgen_var_1407, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateDebugUtilsMessengerEXT readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_1404;
- stream->read((uint64_t*)&cgen_var_1404, 8);
- stream->handleMapping()->mapHandles_u64_VkDebugUtilsMessengerEXT(&cgen_var_1404, (VkDebugUtilsMessengerEXT*)pMessenger, 1);
+ uint64_t cgen_var_1408;
+ stream->read((uint64_t*)&cgen_var_1408, 8);
+ stream->handleMapping()->mapHandles_u64_VkDebugUtilsMessengerEXT(&cgen_var_1408, (VkDebugUtilsMessengerEXT*)pMessenger, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateDebugUtilsMessengerEXT returnUnmarshal");
VkResult vkCreateDebugUtilsMessengerEXT_VkResult_return = (VkResult)0;
@@ -21112,6 +21530,7 @@
VkDebugUtilsMessengerEXT messenger,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyDebugUtilsMessengerEXT encode");
mImpl->log("start vkDestroyDebugUtilsMessengerEXT");
auto stream = mImpl->stream();
@@ -21137,15 +21556,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1405;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1405, 1);
- countingStream->write((uint64_t*)&cgen_var_1405, 1 * 8);
- uint64_t cgen_var_1406;
- countingStream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(&local_messenger, &cgen_var_1406, 1);
- countingStream->write((uint64_t*)&cgen_var_1406, 1 * 8);
+ uint64_t cgen_var_1409;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1409, 1);
+ countingStream->write((uint64_t*)&cgen_var_1409, 1 * 8);
+ uint64_t cgen_var_1410;
+ countingStream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(&local_messenger, &cgen_var_1410, 1);
+ countingStream->write((uint64_t*)&cgen_var_1410, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1407 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1407);
+ uint64_t cgen_var_1411 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1411);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -21156,15 +21575,15 @@
uint32_t opcode_vkDestroyDebugUtilsMessengerEXT = OP_vkDestroyDebugUtilsMessengerEXT;
stream->write(&opcode_vkDestroyDebugUtilsMessengerEXT, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyDebugUtilsMessengerEXT, sizeof(uint32_t));
- uint64_t cgen_var_1408;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1408, 1);
- stream->write((uint64_t*)&cgen_var_1408, 1 * 8);
- uint64_t cgen_var_1409;
- stream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(&local_messenger, &cgen_var_1409, 1);
- stream->write((uint64_t*)&cgen_var_1409, 1 * 8);
+ uint64_t cgen_var_1412;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1412, 1);
+ stream->write((uint64_t*)&cgen_var_1412, 1 * 8);
+ uint64_t cgen_var_1413;
+ stream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(&local_messenger, &cgen_var_1413, 1);
+ stream->write((uint64_t*)&cgen_var_1413, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1410 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1410);
+ uint64_t cgen_var_1414 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1414);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -21181,6 +21600,7 @@
VkDebugUtilsMessageTypeFlagsEXT messageTypes,
const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkSubmitDebugUtilsMessageEXT encode");
mImpl->log("start vkSubmitDebugUtilsMessageEXT");
auto stream = mImpl->stream();
@@ -21207,9 +21627,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1411;
- countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1411, 1);
- countingStream->write((uint64_t*)&cgen_var_1411, 1 * 8);
+ uint64_t cgen_var_1415;
+ countingStream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1415, 1);
+ countingStream->write((uint64_t*)&cgen_var_1415, 1 * 8);
countingStream->write((VkDebugUtilsMessageSeverityFlagBitsEXT*)&local_messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT));
countingStream->write((VkDebugUtilsMessageTypeFlagsEXT*)&local_messageTypes, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
marshal_VkDebugUtilsMessengerCallbackDataEXT(countingStream, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData));
@@ -21219,9 +21639,9 @@
uint32_t opcode_vkSubmitDebugUtilsMessageEXT = OP_vkSubmitDebugUtilsMessageEXT;
stream->write(&opcode_vkSubmitDebugUtilsMessageEXT, sizeof(uint32_t));
stream->write(&packetSize_vkSubmitDebugUtilsMessageEXT, sizeof(uint32_t));
- uint64_t cgen_var_1412;
- stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1412, 1);
- stream->write((uint64_t*)&cgen_var_1412, 1 * 8);
+ uint64_t cgen_var_1416;
+ stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_1416, 1);
+ stream->write((uint64_t*)&cgen_var_1416, 1 * 8);
stream->write((VkDebugUtilsMessageSeverityFlagBitsEXT*)&local_messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT));
stream->write((VkDebugUtilsMessageTypeFlagsEXT*)&local_messageTypes, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
marshal_VkDebugUtilsMessengerCallbackDataEXT(stream, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData));
@@ -21237,6 +21657,7 @@
const AHardwareBuffer* buffer,
VkAndroidHardwareBufferPropertiesANDROID* pProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID encode");
mImpl->log("start vkGetAndroidHardwareBufferPropertiesANDROID");
auto stream = mImpl->stream();
@@ -21254,9 +21675,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1413;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1413, 1);
- countingStream->write((uint64_t*)&cgen_var_1413, 1 * 8);
+ uint64_t cgen_var_1417;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1417, 1);
+ countingStream->write((uint64_t*)&cgen_var_1417, 1 * 8);
countingStream->write((AHardwareBuffer*)local_buffer, sizeof(AHardwareBuffer));
marshal_VkAndroidHardwareBufferPropertiesANDROID(countingStream, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties));
}
@@ -21265,9 +21686,9 @@
uint32_t opcode_vkGetAndroidHardwareBufferPropertiesANDROID = OP_vkGetAndroidHardwareBufferPropertiesANDROID;
stream->write(&opcode_vkGetAndroidHardwareBufferPropertiesANDROID, sizeof(uint32_t));
stream->write(&packetSize_vkGetAndroidHardwareBufferPropertiesANDROID, sizeof(uint32_t));
- uint64_t cgen_var_1414;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1414, 1);
- stream->write((uint64_t*)&cgen_var_1414, 1 * 8);
+ uint64_t cgen_var_1418;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1418, 1);
+ stream->write((uint64_t*)&cgen_var_1418, 1 * 8);
stream->write((AHardwareBuffer*)local_buffer, sizeof(AHardwareBuffer));
marshal_VkAndroidHardwareBufferPropertiesANDROID(stream, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties));
AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID readParams");
@@ -21291,6 +21712,7 @@
const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
AHardwareBuffer** pBuffer)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID encode");
mImpl->log("start vkGetMemoryAndroidHardwareBufferANDROID");
auto stream = mImpl->stream();
@@ -21313,9 +21735,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1415;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1415, 1);
- countingStream->write((uint64_t*)&cgen_var_1415, 1 * 8);
+ uint64_t cgen_var_1419;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1419, 1);
+ countingStream->write((uint64_t*)&cgen_var_1419, 1 * 8);
marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(countingStream, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo));
countingStream->write((AHardwareBuffer**)pBuffer, sizeof(AHardwareBuffer*));
}
@@ -21324,9 +21746,9 @@
uint32_t opcode_vkGetMemoryAndroidHardwareBufferANDROID = OP_vkGetMemoryAndroidHardwareBufferANDROID;
stream->write(&opcode_vkGetMemoryAndroidHardwareBufferANDROID, sizeof(uint32_t));
stream->write(&packetSize_vkGetMemoryAndroidHardwareBufferANDROID, sizeof(uint32_t));
- uint64_t cgen_var_1416;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1416, 1);
- stream->write((uint64_t*)&cgen_var_1416, 1 * 8);
+ uint64_t cgen_var_1420;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1420, 1);
+ stream->write((uint64_t*)&cgen_var_1420, 1 * 8);
marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(stream, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo));
stream->write((AHardwareBuffer**)pBuffer, sizeof(AHardwareBuffer*));
AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID readParams");
@@ -21357,6 +21779,7 @@
VkCommandBuffer commandBuffer,
const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdSetSampleLocationsEXT encode");
mImpl->log("start vkCmdSetSampleLocationsEXT");
auto stream = mImpl->stream();
@@ -21379,9 +21802,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1417;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1417, 1);
- countingStream->write((uint64_t*)&cgen_var_1417, 1 * 8);
+ uint64_t cgen_var_1421;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1421, 1);
+ countingStream->write((uint64_t*)&cgen_var_1421, 1 * 8);
marshal_VkSampleLocationsInfoEXT(countingStream, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo));
}
uint32_t packetSize_vkCmdSetSampleLocationsEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -21389,9 +21812,9 @@
uint32_t opcode_vkCmdSetSampleLocationsEXT = OP_vkCmdSetSampleLocationsEXT;
stream->write(&opcode_vkCmdSetSampleLocationsEXT, sizeof(uint32_t));
stream->write(&packetSize_vkCmdSetSampleLocationsEXT, sizeof(uint32_t));
- uint64_t cgen_var_1418;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1418, 1);
- stream->write((uint64_t*)&cgen_var_1418, 1 * 8);
+ uint64_t cgen_var_1422;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1422, 1);
+ stream->write((uint64_t*)&cgen_var_1422, 1 * 8);
marshal_VkSampleLocationsInfoEXT(stream, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo));
AEMU_SCOPED_TRACE("vkCmdSetSampleLocationsEXT readParams");
AEMU_SCOPED_TRACE("vkCmdSetSampleLocationsEXT returnUnmarshal");
@@ -21403,6 +21826,7 @@
VkSampleCountFlagBits samples,
VkMultisamplePropertiesEXT* pMultisampleProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMultisamplePropertiesEXT encode");
mImpl->log("start vkGetPhysicalDeviceMultisamplePropertiesEXT");
auto stream = mImpl->stream();
@@ -21416,9 +21840,9 @@
local_samples = samples;
countingStream->rewind();
{
- uint64_t cgen_var_1419;
- countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1419, 1);
- countingStream->write((uint64_t*)&cgen_var_1419, 1 * 8);
+ uint64_t cgen_var_1423;
+ countingStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1423, 1);
+ countingStream->write((uint64_t*)&cgen_var_1423, 1 * 8);
countingStream->write((VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
marshal_VkMultisamplePropertiesEXT(countingStream, (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
}
@@ -21427,9 +21851,9 @@
uint32_t opcode_vkGetPhysicalDeviceMultisamplePropertiesEXT = OP_vkGetPhysicalDeviceMultisamplePropertiesEXT;
stream->write(&opcode_vkGetPhysicalDeviceMultisamplePropertiesEXT, sizeof(uint32_t));
stream->write(&packetSize_vkGetPhysicalDeviceMultisamplePropertiesEXT, sizeof(uint32_t));
- uint64_t cgen_var_1420;
- stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1420, 1);
- stream->write((uint64_t*)&cgen_var_1420, 1 * 8);
+ uint64_t cgen_var_1424;
+ stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_1424, 1);
+ stream->write((uint64_t*)&cgen_var_1424, 1 * 8);
stream->write((VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
marshal_VkMultisamplePropertiesEXT(stream, (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMultisamplePropertiesEXT readParams");
@@ -21460,6 +21884,7 @@
const VkAllocationCallbacks* pAllocator,
VkValidationCacheEXT* pValidationCache)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCreateValidationCacheEXT encode");
mImpl->log("start vkCreateValidationCacheEXT");
auto stream = mImpl->stream();
@@ -21494,47 +21919,47 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1421;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1421, 1);
- countingStream->write((uint64_t*)&cgen_var_1421, 1 * 8);
+ uint64_t cgen_var_1425;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1425, 1);
+ countingStream->write((uint64_t*)&cgen_var_1425, 1 * 8);
marshal_VkValidationCacheCreateInfoEXT(countingStream, (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1422 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1422);
+ uint64_t cgen_var_1426 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1426);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
}
- uint64_t cgen_var_1423;
- countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(pValidationCache, &cgen_var_1423, 1);
- countingStream->write((uint64_t*)&cgen_var_1423, 8);
+ uint64_t cgen_var_1427;
+ countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(pValidationCache, &cgen_var_1427, 1);
+ countingStream->write((uint64_t*)&cgen_var_1427, 8);
}
uint32_t packetSize_vkCreateValidationCacheEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkCreateValidationCacheEXT = OP_vkCreateValidationCacheEXT;
stream->write(&opcode_vkCreateValidationCacheEXT, sizeof(uint32_t));
stream->write(&packetSize_vkCreateValidationCacheEXT, sizeof(uint32_t));
- uint64_t cgen_var_1424;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1424, 1);
- stream->write((uint64_t*)&cgen_var_1424, 1 * 8);
+ uint64_t cgen_var_1428;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1428, 1);
+ stream->write((uint64_t*)&cgen_var_1428, 1 * 8);
marshal_VkValidationCacheCreateInfoEXT(stream, (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo));
// WARNING PTR CHECK
- uint64_t cgen_var_1425 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1425);
+ uint64_t cgen_var_1429 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1429);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
}
stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
- uint64_t cgen_var_1426;
- stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(pValidationCache, &cgen_var_1426, 1);
- stream->write((uint64_t*)&cgen_var_1426, 8);
+ uint64_t cgen_var_1430;
+ stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(pValidationCache, &cgen_var_1430, 1);
+ stream->write((uint64_t*)&cgen_var_1430, 8);
stream->setHandleMapping(resources->unwrapMapping());
AEMU_SCOPED_TRACE("vkCreateValidationCacheEXT readParams");
stream->setHandleMapping(resources->createMapping());
- uint64_t cgen_var_1427;
- stream->read((uint64_t*)&cgen_var_1427, 8);
- stream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(&cgen_var_1427, (VkValidationCacheEXT*)pValidationCache, 1);
+ uint64_t cgen_var_1431;
+ stream->read((uint64_t*)&cgen_var_1431, 8);
+ stream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(&cgen_var_1431, (VkValidationCacheEXT*)pValidationCache, 1);
stream->unsetHandleMapping();
AEMU_SCOPED_TRACE("vkCreateValidationCacheEXT returnUnmarshal");
VkResult vkCreateValidationCacheEXT_VkResult_return = (VkResult)0;
@@ -21551,6 +21976,7 @@
VkValidationCacheEXT validationCache,
const VkAllocationCallbacks* pAllocator)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkDestroyValidationCacheEXT encode");
mImpl->log("start vkDestroyValidationCacheEXT");
auto stream = mImpl->stream();
@@ -21576,15 +22002,15 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1428;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1428, 1);
- countingStream->write((uint64_t*)&cgen_var_1428, 1 * 8);
- uint64_t cgen_var_1429;
- countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1429, 1);
- countingStream->write((uint64_t*)&cgen_var_1429, 1 * 8);
+ uint64_t cgen_var_1432;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1432, 1);
+ countingStream->write((uint64_t*)&cgen_var_1432, 1 * 8);
+ uint64_t cgen_var_1433;
+ countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1433, 1);
+ countingStream->write((uint64_t*)&cgen_var_1433, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1430 = (uint64_t)(uintptr_t)local_pAllocator;
- countingStream->putBe64(cgen_var_1430);
+ uint64_t cgen_var_1434 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1434);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -21595,15 +22021,15 @@
uint32_t opcode_vkDestroyValidationCacheEXT = OP_vkDestroyValidationCacheEXT;
stream->write(&opcode_vkDestroyValidationCacheEXT, sizeof(uint32_t));
stream->write(&packetSize_vkDestroyValidationCacheEXT, sizeof(uint32_t));
- uint64_t cgen_var_1431;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1431, 1);
- stream->write((uint64_t*)&cgen_var_1431, 1 * 8);
- uint64_t cgen_var_1432;
- stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1432, 1);
- stream->write((uint64_t*)&cgen_var_1432, 1 * 8);
+ uint64_t cgen_var_1435;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1435, 1);
+ stream->write((uint64_t*)&cgen_var_1435, 1 * 8);
+ uint64_t cgen_var_1436;
+ stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1436, 1);
+ stream->write((uint64_t*)&cgen_var_1436, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1433 = (uint64_t)(uintptr_t)local_pAllocator;
- stream->putBe64(cgen_var_1433);
+ uint64_t cgen_var_1437 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1437);
if (local_pAllocator)
{
marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
@@ -21620,6 +22046,7 @@
uint32_t srcCacheCount,
const VkValidationCacheEXT* pSrcCaches)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkMergeValidationCachesEXT encode");
mImpl->log("start vkMergeValidationCachesEXT");
auto stream = mImpl->stream();
@@ -21641,19 +22068,19 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1434;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1434, 1);
- countingStream->write((uint64_t*)&cgen_var_1434, 1 * 8);
- uint64_t cgen_var_1435;
- countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_dstCache, &cgen_var_1435, 1);
- countingStream->write((uint64_t*)&cgen_var_1435, 1 * 8);
+ uint64_t cgen_var_1438;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1438, 1);
+ countingStream->write((uint64_t*)&cgen_var_1438, 1 * 8);
+ uint64_t cgen_var_1439;
+ countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_dstCache, &cgen_var_1439, 1);
+ countingStream->write((uint64_t*)&cgen_var_1439, 1 * 8);
countingStream->write((uint32_t*)&local_srcCacheCount, sizeof(uint32_t));
if (((srcCacheCount)))
{
- uint64_t* cgen_var_1436;
- countingStream->alloc((void**)&cgen_var_1436, ((srcCacheCount)) * 8);
- countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(local_pSrcCaches, cgen_var_1436, ((srcCacheCount)));
- countingStream->write((uint64_t*)cgen_var_1436, ((srcCacheCount)) * 8);
+ uint64_t* cgen_var_1440;
+ countingStream->alloc((void**)&cgen_var_1440, ((srcCacheCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(local_pSrcCaches, cgen_var_1440, ((srcCacheCount)));
+ countingStream->write((uint64_t*)cgen_var_1440, ((srcCacheCount)) * 8);
}
}
uint32_t packetSize_vkMergeValidationCachesEXT = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -21661,19 +22088,19 @@
uint32_t opcode_vkMergeValidationCachesEXT = OP_vkMergeValidationCachesEXT;
stream->write(&opcode_vkMergeValidationCachesEXT, sizeof(uint32_t));
stream->write(&packetSize_vkMergeValidationCachesEXT, sizeof(uint32_t));
- uint64_t cgen_var_1437;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1437, 1);
- stream->write((uint64_t*)&cgen_var_1437, 1 * 8);
- uint64_t cgen_var_1438;
- stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_dstCache, &cgen_var_1438, 1);
- stream->write((uint64_t*)&cgen_var_1438, 1 * 8);
+ uint64_t cgen_var_1441;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1441, 1);
+ stream->write((uint64_t*)&cgen_var_1441, 1 * 8);
+ uint64_t cgen_var_1442;
+ stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_dstCache, &cgen_var_1442, 1);
+ stream->write((uint64_t*)&cgen_var_1442, 1 * 8);
stream->write((uint32_t*)&local_srcCacheCount, sizeof(uint32_t));
if (((srcCacheCount)))
{
- uint64_t* cgen_var_1439;
- stream->alloc((void**)&cgen_var_1439, ((srcCacheCount)) * 8);
- stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(local_pSrcCaches, cgen_var_1439, ((srcCacheCount)));
- stream->write((uint64_t*)cgen_var_1439, ((srcCacheCount)) * 8);
+ uint64_t* cgen_var_1443;
+ stream->alloc((void**)&cgen_var_1443, ((srcCacheCount)) * 8);
+ stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(local_pSrcCaches, cgen_var_1443, ((srcCacheCount)));
+ stream->write((uint64_t*)cgen_var_1443, ((srcCacheCount)) * 8);
}
AEMU_SCOPED_TRACE("vkMergeValidationCachesEXT readParams");
AEMU_SCOPED_TRACE("vkMergeValidationCachesEXT returnUnmarshal");
@@ -21692,6 +22119,7 @@
size_t* pDataSize,
void* pData)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetValidationCacheDataEXT encode");
mImpl->log("start vkGetValidationCacheDataEXT");
auto stream = mImpl->stream();
@@ -21705,23 +22133,23 @@
local_validationCache = validationCache;
countingStream->rewind();
{
- uint64_t cgen_var_1440;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1440, 1);
- countingStream->write((uint64_t*)&cgen_var_1440, 1 * 8);
- uint64_t cgen_var_1441;
- countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1441, 1);
- countingStream->write((uint64_t*)&cgen_var_1441, 1 * 8);
+ uint64_t cgen_var_1444;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1444, 1);
+ countingStream->write((uint64_t*)&cgen_var_1444, 1 * 8);
+ uint64_t cgen_var_1445;
+ countingStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1445, 1);
+ countingStream->write((uint64_t*)&cgen_var_1445, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1442 = (uint64_t)(uintptr_t)pDataSize;
- countingStream->putBe64(cgen_var_1442);
+ uint64_t cgen_var_1446 = (uint64_t)(uintptr_t)pDataSize;
+ countingStream->putBe64(cgen_var_1446);
if (pDataSize)
{
- uint64_t cgen_var_1443 = (uint64_t)(*pDataSize);
- countingStream->putBe64(cgen_var_1443);
+ uint64_t cgen_var_1447 = (uint64_t)(*pDataSize);
+ countingStream->putBe64(cgen_var_1447);
}
// WARNING PTR CHECK
- uint64_t cgen_var_1444 = (uint64_t)(uintptr_t)pData;
- countingStream->putBe64(cgen_var_1444);
+ uint64_t cgen_var_1448 = (uint64_t)(uintptr_t)pData;
+ countingStream->putBe64(cgen_var_1448);
if (pData)
{
countingStream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
@@ -21732,23 +22160,23 @@
uint32_t opcode_vkGetValidationCacheDataEXT = OP_vkGetValidationCacheDataEXT;
stream->write(&opcode_vkGetValidationCacheDataEXT, sizeof(uint32_t));
stream->write(&packetSize_vkGetValidationCacheDataEXT, sizeof(uint32_t));
- uint64_t cgen_var_1445;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1445, 1);
- stream->write((uint64_t*)&cgen_var_1445, 1 * 8);
- uint64_t cgen_var_1446;
- stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1446, 1);
- stream->write((uint64_t*)&cgen_var_1446, 1 * 8);
+ uint64_t cgen_var_1449;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1449, 1);
+ stream->write((uint64_t*)&cgen_var_1449, 1 * 8);
+ uint64_t cgen_var_1450;
+ stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&local_validationCache, &cgen_var_1450, 1);
+ stream->write((uint64_t*)&cgen_var_1450, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1447 = (uint64_t)(uintptr_t)pDataSize;
- stream->putBe64(cgen_var_1447);
+ uint64_t cgen_var_1451 = (uint64_t)(uintptr_t)pDataSize;
+ stream->putBe64(cgen_var_1451);
if (pDataSize)
{
- uint64_t cgen_var_1448 = (uint64_t)(*pDataSize);
- stream->putBe64(cgen_var_1448);
+ uint64_t cgen_var_1452 = (uint64_t)(*pDataSize);
+ stream->putBe64(cgen_var_1452);
}
// WARNING PTR CHECK
- uint64_t cgen_var_1449 = (uint64_t)(uintptr_t)pData;
- stream->putBe64(cgen_var_1449);
+ uint64_t cgen_var_1453 = (uint64_t)(uintptr_t)pData;
+ stream->putBe64(cgen_var_1453);
if (pData)
{
stream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
@@ -21800,6 +22228,7 @@
const void* pHostPointer,
VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetMemoryHostPointerPropertiesEXT encode");
mImpl->log("start vkGetMemoryHostPointerPropertiesEXT");
auto stream = mImpl->stream();
@@ -21819,13 +22248,13 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1453;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1453, 1);
- countingStream->write((uint64_t*)&cgen_var_1453, 1 * 8);
+ uint64_t cgen_var_1457;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1457, 1);
+ countingStream->write((uint64_t*)&cgen_var_1457, 1 * 8);
countingStream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
// WARNING PTR CHECK
- uint64_t cgen_var_1454 = (uint64_t)(uintptr_t)local_pHostPointer;
- countingStream->putBe64(cgen_var_1454);
+ uint64_t cgen_var_1458 = (uint64_t)(uintptr_t)local_pHostPointer;
+ countingStream->putBe64(cgen_var_1458);
if (local_pHostPointer)
{
countingStream->write((void*)local_pHostPointer, sizeof(uint8_t));
@@ -21837,13 +22266,13 @@
uint32_t opcode_vkGetMemoryHostPointerPropertiesEXT = OP_vkGetMemoryHostPointerPropertiesEXT;
stream->write(&opcode_vkGetMemoryHostPointerPropertiesEXT, sizeof(uint32_t));
stream->write(&packetSize_vkGetMemoryHostPointerPropertiesEXT, sizeof(uint32_t));
- uint64_t cgen_var_1455;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1455, 1);
- stream->write((uint64_t*)&cgen_var_1455, 1 * 8);
+ uint64_t cgen_var_1459;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1459, 1);
+ stream->write((uint64_t*)&cgen_var_1459, 1 * 8);
stream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
// WARNING PTR CHECK
- uint64_t cgen_var_1456 = (uint64_t)(uintptr_t)local_pHostPointer;
- stream->putBe64(cgen_var_1456);
+ uint64_t cgen_var_1460 = (uint64_t)(uintptr_t)local_pHostPointer;
+ stream->putBe64(cgen_var_1460);
if (local_pHostPointer)
{
stream->write((void*)local_pHostPointer, sizeof(uint8_t));
@@ -21874,6 +22303,7 @@
VkDeviceSize dstOffset,
uint32_t marker)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdWriteBufferMarkerAMD encode");
mImpl->log("start vkCmdWriteBufferMarkerAMD");
auto stream = mImpl->stream();
@@ -21893,13 +22323,13 @@
local_marker = marker;
countingStream->rewind();
{
- uint64_t cgen_var_1457;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1457, 1);
- countingStream->write((uint64_t*)&cgen_var_1457, 1 * 8);
+ uint64_t cgen_var_1461;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1461, 1);
+ countingStream->write((uint64_t*)&cgen_var_1461, 1 * 8);
countingStream->write((VkPipelineStageFlagBits*)&local_pipelineStage, sizeof(VkPipelineStageFlagBits));
- uint64_t cgen_var_1458;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_1458, 1);
- countingStream->write((uint64_t*)&cgen_var_1458, 1 * 8);
+ uint64_t cgen_var_1462;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_1462, 1);
+ countingStream->write((uint64_t*)&cgen_var_1462, 1 * 8);
countingStream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
countingStream->write((uint32_t*)&local_marker, sizeof(uint32_t));
}
@@ -21908,13 +22338,13 @@
uint32_t opcode_vkCmdWriteBufferMarkerAMD = OP_vkCmdWriteBufferMarkerAMD;
stream->write(&opcode_vkCmdWriteBufferMarkerAMD, sizeof(uint32_t));
stream->write(&packetSize_vkCmdWriteBufferMarkerAMD, sizeof(uint32_t));
- uint64_t cgen_var_1459;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1459, 1);
- stream->write((uint64_t*)&cgen_var_1459, 1 * 8);
+ uint64_t cgen_var_1463;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1463, 1);
+ stream->write((uint64_t*)&cgen_var_1463, 1 * 8);
stream->write((VkPipelineStageFlagBits*)&local_pipelineStage, sizeof(VkPipelineStageFlagBits));
- uint64_t cgen_var_1460;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_1460, 1);
- stream->write((uint64_t*)&cgen_var_1460, 1 * 8);
+ uint64_t cgen_var_1464;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_dstBuffer, &cgen_var_1464, 1);
+ stream->write((uint64_t*)&cgen_var_1464, 1 * 8);
stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize));
stream->write((uint32_t*)&local_marker, sizeof(uint32_t));
AEMU_SCOPED_TRACE("vkCmdWriteBufferMarkerAMD readParams");
@@ -21934,6 +22364,7 @@
VkCommandBuffer commandBuffer,
const void* pCheckpointMarker)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkCmdSetCheckpointNV encode");
mImpl->log("start vkCmdSetCheckpointNV");
auto stream = mImpl->stream();
@@ -21951,12 +22382,12 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1461;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1461, 1);
- countingStream->write((uint64_t*)&cgen_var_1461, 1 * 8);
+ uint64_t cgen_var_1465;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1465, 1);
+ countingStream->write((uint64_t*)&cgen_var_1465, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1462 = (uint64_t)(uintptr_t)local_pCheckpointMarker;
- countingStream->putBe64(cgen_var_1462);
+ uint64_t cgen_var_1466 = (uint64_t)(uintptr_t)local_pCheckpointMarker;
+ countingStream->putBe64(cgen_var_1466);
if (local_pCheckpointMarker)
{
countingStream->write((void*)local_pCheckpointMarker, sizeof(uint8_t));
@@ -21967,12 +22398,12 @@
uint32_t opcode_vkCmdSetCheckpointNV = OP_vkCmdSetCheckpointNV;
stream->write(&opcode_vkCmdSetCheckpointNV, sizeof(uint32_t));
stream->write(&packetSize_vkCmdSetCheckpointNV, sizeof(uint32_t));
- uint64_t cgen_var_1463;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1463, 1);
- stream->write((uint64_t*)&cgen_var_1463, 1 * 8);
+ uint64_t cgen_var_1467;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1467, 1);
+ stream->write((uint64_t*)&cgen_var_1467, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1464 = (uint64_t)(uintptr_t)local_pCheckpointMarker;
- stream->putBe64(cgen_var_1464);
+ uint64_t cgen_var_1468 = (uint64_t)(uintptr_t)local_pCheckpointMarker;
+ stream->putBe64(cgen_var_1468);
if (local_pCheckpointMarker)
{
stream->write((void*)local_pCheckpointMarker, sizeof(uint8_t));
@@ -21987,6 +22418,7 @@
uint32_t* pCheckpointDataCount,
VkCheckpointDataNV* pCheckpointData)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkGetQueueCheckpointDataNV encode");
mImpl->log("start vkGetQueueCheckpointDataNV");
auto stream = mImpl->stream();
@@ -21998,19 +22430,19 @@
local_queue = queue;
countingStream->rewind();
{
- uint64_t cgen_var_1465;
- countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1465, 1);
- countingStream->write((uint64_t*)&cgen_var_1465, 1 * 8);
+ uint64_t cgen_var_1469;
+ countingStream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1469, 1);
+ countingStream->write((uint64_t*)&cgen_var_1469, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1466 = (uint64_t)(uintptr_t)pCheckpointDataCount;
- countingStream->putBe64(cgen_var_1466);
+ uint64_t cgen_var_1470 = (uint64_t)(uintptr_t)pCheckpointDataCount;
+ countingStream->putBe64(cgen_var_1470);
if (pCheckpointDataCount)
{
countingStream->write((uint32_t*)pCheckpointDataCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1467 = (uint64_t)(uintptr_t)pCheckpointData;
- countingStream->putBe64(cgen_var_1467);
+ uint64_t cgen_var_1471 = (uint64_t)(uintptr_t)pCheckpointData;
+ countingStream->putBe64(cgen_var_1471);
if (pCheckpointData)
{
for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
@@ -22024,19 +22456,19 @@
uint32_t opcode_vkGetQueueCheckpointDataNV = OP_vkGetQueueCheckpointDataNV;
stream->write(&opcode_vkGetQueueCheckpointDataNV, sizeof(uint32_t));
stream->write(&packetSize_vkGetQueueCheckpointDataNV, sizeof(uint32_t));
- uint64_t cgen_var_1468;
- stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1468, 1);
- stream->write((uint64_t*)&cgen_var_1468, 1 * 8);
+ uint64_t cgen_var_1472;
+ stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1472, 1);
+ stream->write((uint64_t*)&cgen_var_1472, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1469 = (uint64_t)(uintptr_t)pCheckpointDataCount;
- stream->putBe64(cgen_var_1469);
+ uint64_t cgen_var_1473 = (uint64_t)(uintptr_t)pCheckpointDataCount;
+ stream->putBe64(cgen_var_1473);
if (pCheckpointDataCount)
{
stream->write((uint32_t*)pCheckpointDataCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1470 = (uint64_t)(uintptr_t)pCheckpointData;
- stream->putBe64(cgen_var_1470);
+ uint64_t cgen_var_1474 = (uint64_t)(uintptr_t)pCheckpointData;
+ stream->putBe64(cgen_var_1474);
if (pCheckpointData)
{
for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
@@ -22088,9 +22520,12 @@
VkDeviceMemory memory,
uint64_t* pAddress)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE encode");
mImpl->log("start vkMapMemoryIntoAddressSpaceGOOGLE");
+ encoderLock.unlock();
mImpl->resources()->on_vkMapMemoryIntoAddressSpaceGOOGLE_pre(this, VK_SUCCESS, device, memory, pAddress);
+ encoderLock.lock();
auto stream = mImpl->stream();
auto countingStream = mImpl->countingStream();
auto resources = mImpl->resources();
@@ -22103,15 +22538,15 @@
mImpl->resources()->deviceMemoryTransform_tohost((VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
countingStream->rewind();
{
- uint64_t cgen_var_1473;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1473, 1);
- countingStream->write((uint64_t*)&cgen_var_1473, 1 * 8);
- uint64_t cgen_var_1474;
- countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1474, 1);
- countingStream->write((uint64_t*)&cgen_var_1474, 1 * 8);
+ uint64_t cgen_var_1477;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1477, 1);
+ countingStream->write((uint64_t*)&cgen_var_1477, 1 * 8);
+ uint64_t cgen_var_1478;
+ countingStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1478, 1);
+ countingStream->write((uint64_t*)&cgen_var_1478, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1475 = (uint64_t)(uintptr_t)pAddress;
- countingStream->putBe64(cgen_var_1475);
+ uint64_t cgen_var_1479 = (uint64_t)(uintptr_t)pAddress;
+ countingStream->putBe64(cgen_var_1479);
if (pAddress)
{
countingStream->write((uint64_t*)pAddress, sizeof(uint64_t));
@@ -22122,15 +22557,15 @@
uint32_t opcode_vkMapMemoryIntoAddressSpaceGOOGLE = OP_vkMapMemoryIntoAddressSpaceGOOGLE;
stream->write(&opcode_vkMapMemoryIntoAddressSpaceGOOGLE, sizeof(uint32_t));
stream->write(&packetSize_vkMapMemoryIntoAddressSpaceGOOGLE, sizeof(uint32_t));
- uint64_t cgen_var_1476;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1476, 1);
- stream->write((uint64_t*)&cgen_var_1476, 1 * 8);
- uint64_t cgen_var_1477;
- stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1477, 1);
- stream->write((uint64_t*)&cgen_var_1477, 1 * 8);
+ uint64_t cgen_var_1480;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1480, 1);
+ stream->write((uint64_t*)&cgen_var_1480, 1 * 8);
+ uint64_t cgen_var_1481;
+ stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_1481, 1);
+ stream->write((uint64_t*)&cgen_var_1481, 1 * 8);
// WARNING PTR CHECK
- uint64_t cgen_var_1478 = (uint64_t)(uintptr_t)pAddress;
- stream->putBe64(cgen_var_1478);
+ uint64_t cgen_var_1482 = (uint64_t)(uintptr_t)pAddress;
+ stream->putBe64(cgen_var_1482);
if (pAddress)
{
stream->write((uint64_t*)pAddress, sizeof(uint64_t));
@@ -22153,7 +22588,9 @@
countingStream->clearPool();
stream->clearPool();
pool->freeAll();
+ encoderLock.unlock();
mImpl->resources()->on_vkMapMemoryIntoAddressSpaceGOOGLE(this, vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return, device, memory, pAddress);
+ encoderLock.lock();
mImpl->log("finish vkMapMemoryIntoAddressSpaceGOOGLE");;
return vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return;
}
@@ -22165,6 +22602,7 @@
VkImage image,
uint32_t colorBuffer)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkRegisterImageColorBufferGOOGLE encode");
mImpl->log("start vkRegisterImageColorBufferGOOGLE");
auto stream = mImpl->stream();
@@ -22180,12 +22618,12 @@
local_colorBuffer = colorBuffer;
countingStream->rewind();
{
- uint64_t cgen_var_1480;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1480, 1);
- countingStream->write((uint64_t*)&cgen_var_1480, 1 * 8);
- uint64_t cgen_var_1481;
- countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1481, 1);
- countingStream->write((uint64_t*)&cgen_var_1481, 1 * 8);
+ uint64_t cgen_var_1484;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1484, 1);
+ countingStream->write((uint64_t*)&cgen_var_1484, 1 * 8);
+ uint64_t cgen_var_1485;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1485, 1);
+ countingStream->write((uint64_t*)&cgen_var_1485, 1 * 8);
countingStream->write((uint32_t*)&local_colorBuffer, sizeof(uint32_t));
}
uint32_t packetSize_vkRegisterImageColorBufferGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -22193,12 +22631,12 @@
uint32_t opcode_vkRegisterImageColorBufferGOOGLE = OP_vkRegisterImageColorBufferGOOGLE;
stream->write(&opcode_vkRegisterImageColorBufferGOOGLE, sizeof(uint32_t));
stream->write(&packetSize_vkRegisterImageColorBufferGOOGLE, sizeof(uint32_t));
- uint64_t cgen_var_1482;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1482, 1);
- stream->write((uint64_t*)&cgen_var_1482, 1 * 8);
- uint64_t cgen_var_1483;
- stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1483, 1);
- stream->write((uint64_t*)&cgen_var_1483, 1 * 8);
+ uint64_t cgen_var_1486;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1486, 1);
+ stream->write((uint64_t*)&cgen_var_1486, 1 * 8);
+ uint64_t cgen_var_1487;
+ stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1487, 1);
+ stream->write((uint64_t*)&cgen_var_1487, 1 * 8);
stream->write((uint32_t*)&local_colorBuffer, sizeof(uint32_t));
AEMU_SCOPED_TRACE("vkRegisterImageColorBufferGOOGLE readParams");
AEMU_SCOPED_TRACE("vkRegisterImageColorBufferGOOGLE returnUnmarshal");
@@ -22216,6 +22654,7 @@
VkBuffer buffer,
uint32_t colorBuffer)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkRegisterBufferColorBufferGOOGLE encode");
mImpl->log("start vkRegisterBufferColorBufferGOOGLE");
auto stream = mImpl->stream();
@@ -22231,12 +22670,12 @@
local_colorBuffer = colorBuffer;
countingStream->rewind();
{
- uint64_t cgen_var_1484;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1484, 1);
- countingStream->write((uint64_t*)&cgen_var_1484, 1 * 8);
- uint64_t cgen_var_1485;
- countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1485, 1);
- countingStream->write((uint64_t*)&cgen_var_1485, 1 * 8);
+ uint64_t cgen_var_1488;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1488, 1);
+ countingStream->write((uint64_t*)&cgen_var_1488, 1 * 8);
+ uint64_t cgen_var_1489;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1489, 1);
+ countingStream->write((uint64_t*)&cgen_var_1489, 1 * 8);
countingStream->write((uint32_t*)&local_colorBuffer, sizeof(uint32_t));
}
uint32_t packetSize_vkRegisterBufferColorBufferGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -22244,12 +22683,12 @@
uint32_t opcode_vkRegisterBufferColorBufferGOOGLE = OP_vkRegisterBufferColorBufferGOOGLE;
stream->write(&opcode_vkRegisterBufferColorBufferGOOGLE, sizeof(uint32_t));
stream->write(&packetSize_vkRegisterBufferColorBufferGOOGLE, sizeof(uint32_t));
- uint64_t cgen_var_1486;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1486, 1);
- stream->write((uint64_t*)&cgen_var_1486, 1 * 8);
- uint64_t cgen_var_1487;
- stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1487, 1);
- stream->write((uint64_t*)&cgen_var_1487, 1 * 8);
+ uint64_t cgen_var_1490;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1490, 1);
+ stream->write((uint64_t*)&cgen_var_1490, 1 * 8);
+ uint64_t cgen_var_1491;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1491, 1);
+ stream->write((uint64_t*)&cgen_var_1491, 1 * 8);
stream->write((uint32_t*)&local_colorBuffer, sizeof(uint32_t));
AEMU_SCOPED_TRACE("vkRegisterBufferColorBufferGOOGLE readParams");
AEMU_SCOPED_TRACE("vkRegisterBufferColorBufferGOOGLE returnUnmarshal");
@@ -22278,6 +22717,7 @@
const VkDescriptorBufferInfo* pBufferInfos,
const VkBufferView* pBufferViews)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE encode");
mImpl->log("start vkUpdateDescriptorSetWithTemplateSizedGOOGLE");
auto stream = mImpl->stream();
@@ -22357,42 +22797,42 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1488;
- countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1488, 1);
- countingStream->write((uint64_t*)&cgen_var_1488, 1 * 8);
- uint64_t cgen_var_1489;
- countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_1489, 1);
- countingStream->write((uint64_t*)&cgen_var_1489, 1 * 8);
- uint64_t cgen_var_1490;
- countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1490, 1);
- countingStream->write((uint64_t*)&cgen_var_1490, 1 * 8);
+ uint64_t cgen_var_1492;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1492, 1);
+ countingStream->write((uint64_t*)&cgen_var_1492, 1 * 8);
+ uint64_t cgen_var_1493;
+ countingStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_1493, 1);
+ countingStream->write((uint64_t*)&cgen_var_1493, 1 * 8);
+ uint64_t cgen_var_1494;
+ countingStream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1494, 1);
+ countingStream->write((uint64_t*)&cgen_var_1494, 1 * 8);
countingStream->write((uint32_t*)&local_imageInfoCount, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_bufferInfoCount, sizeof(uint32_t));
countingStream->write((uint32_t*)&local_bufferViewCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_1491 = (uint64_t)(uintptr_t)local_pImageInfoEntryIndices;
- countingStream->putBe64(cgen_var_1491);
+ uint64_t cgen_var_1495 = (uint64_t)(uintptr_t)local_pImageInfoEntryIndices;
+ countingStream->putBe64(cgen_var_1495);
if (local_pImageInfoEntryIndices)
{
countingStream->write((uint32_t*)local_pImageInfoEntryIndices, ((imageInfoCount)) * sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1492 = (uint64_t)(uintptr_t)local_pBufferInfoEntryIndices;
- countingStream->putBe64(cgen_var_1492);
+ uint64_t cgen_var_1496 = (uint64_t)(uintptr_t)local_pBufferInfoEntryIndices;
+ countingStream->putBe64(cgen_var_1496);
if (local_pBufferInfoEntryIndices)
{
countingStream->write((uint32_t*)local_pBufferInfoEntryIndices, ((bufferInfoCount)) * sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1493 = (uint64_t)(uintptr_t)local_pBufferViewEntryIndices;
- countingStream->putBe64(cgen_var_1493);
+ uint64_t cgen_var_1497 = (uint64_t)(uintptr_t)local_pBufferViewEntryIndices;
+ countingStream->putBe64(cgen_var_1497);
if (local_pBufferViewEntryIndices)
{
countingStream->write((uint32_t*)local_pBufferViewEntryIndices, ((bufferViewCount)) * sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1494 = (uint64_t)(uintptr_t)local_pImageInfos;
- countingStream->putBe64(cgen_var_1494);
+ uint64_t cgen_var_1498 = (uint64_t)(uintptr_t)local_pImageInfos;
+ countingStream->putBe64(cgen_var_1498);
if (local_pImageInfos)
{
for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i)
@@ -22401,8 +22841,8 @@
}
}
// WARNING PTR CHECK
- uint64_t cgen_var_1495 = (uint64_t)(uintptr_t)local_pBufferInfos;
- countingStream->putBe64(cgen_var_1495);
+ uint64_t cgen_var_1499 = (uint64_t)(uintptr_t)local_pBufferInfos;
+ countingStream->putBe64(cgen_var_1499);
if (local_pBufferInfos)
{
for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i)
@@ -22411,16 +22851,16 @@
}
}
// WARNING PTR CHECK
- uint64_t cgen_var_1496 = (uint64_t)(uintptr_t)local_pBufferViews;
- countingStream->putBe64(cgen_var_1496);
+ uint64_t cgen_var_1500 = (uint64_t)(uintptr_t)local_pBufferViews;
+ countingStream->putBe64(cgen_var_1500);
if (local_pBufferViews)
{
if (((bufferViewCount)))
{
- uint64_t* cgen_var_1497;
- countingStream->alloc((void**)&cgen_var_1497, ((bufferViewCount)) * 8);
- countingStream->handleMapping()->mapHandles_VkBufferView_u64(local_pBufferViews, cgen_var_1497, ((bufferViewCount)));
- countingStream->write((uint64_t*)cgen_var_1497, ((bufferViewCount)) * 8);
+ uint64_t* cgen_var_1501;
+ countingStream->alloc((void**)&cgen_var_1501, ((bufferViewCount)) * 8);
+ countingStream->handleMapping()->mapHandles_VkBufferView_u64(local_pBufferViews, cgen_var_1501, ((bufferViewCount)));
+ countingStream->write((uint64_t*)cgen_var_1501, ((bufferViewCount)) * 8);
}
}
}
@@ -22429,42 +22869,42 @@
uint32_t opcode_vkUpdateDescriptorSetWithTemplateSizedGOOGLE = OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE;
stream->write(&opcode_vkUpdateDescriptorSetWithTemplateSizedGOOGLE, sizeof(uint32_t));
stream->write(&packetSize_vkUpdateDescriptorSetWithTemplateSizedGOOGLE, sizeof(uint32_t));
- uint64_t cgen_var_1498;
- stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1498, 1);
- stream->write((uint64_t*)&cgen_var_1498, 1 * 8);
- uint64_t cgen_var_1499;
- stream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_1499, 1);
- stream->write((uint64_t*)&cgen_var_1499, 1 * 8);
- uint64_t cgen_var_1500;
- stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1500, 1);
- stream->write((uint64_t*)&cgen_var_1500, 1 * 8);
+ uint64_t cgen_var_1502;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1502, 1);
+ stream->write((uint64_t*)&cgen_var_1502, 1 * 8);
+ uint64_t cgen_var_1503;
+ stream->handleMapping()->mapHandles_VkDescriptorSet_u64(&local_descriptorSet, &cgen_var_1503, 1);
+ stream->write((uint64_t*)&cgen_var_1503, 1 * 8);
+ uint64_t cgen_var_1504;
+ stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(&local_descriptorUpdateTemplate, &cgen_var_1504, 1);
+ stream->write((uint64_t*)&cgen_var_1504, 1 * 8);
stream->write((uint32_t*)&local_imageInfoCount, sizeof(uint32_t));
stream->write((uint32_t*)&local_bufferInfoCount, sizeof(uint32_t));
stream->write((uint32_t*)&local_bufferViewCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_1501 = (uint64_t)(uintptr_t)local_pImageInfoEntryIndices;
- stream->putBe64(cgen_var_1501);
+ uint64_t cgen_var_1505 = (uint64_t)(uintptr_t)local_pImageInfoEntryIndices;
+ stream->putBe64(cgen_var_1505);
if (local_pImageInfoEntryIndices)
{
stream->write((uint32_t*)local_pImageInfoEntryIndices, ((imageInfoCount)) * sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1502 = (uint64_t)(uintptr_t)local_pBufferInfoEntryIndices;
- stream->putBe64(cgen_var_1502);
+ uint64_t cgen_var_1506 = (uint64_t)(uintptr_t)local_pBufferInfoEntryIndices;
+ stream->putBe64(cgen_var_1506);
if (local_pBufferInfoEntryIndices)
{
stream->write((uint32_t*)local_pBufferInfoEntryIndices, ((bufferInfoCount)) * sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1503 = (uint64_t)(uintptr_t)local_pBufferViewEntryIndices;
- stream->putBe64(cgen_var_1503);
+ uint64_t cgen_var_1507 = (uint64_t)(uintptr_t)local_pBufferViewEntryIndices;
+ stream->putBe64(cgen_var_1507);
if (local_pBufferViewEntryIndices)
{
stream->write((uint32_t*)local_pBufferViewEntryIndices, ((bufferViewCount)) * sizeof(uint32_t));
}
// WARNING PTR CHECK
- uint64_t cgen_var_1504 = (uint64_t)(uintptr_t)local_pImageInfos;
- stream->putBe64(cgen_var_1504);
+ uint64_t cgen_var_1508 = (uint64_t)(uintptr_t)local_pImageInfos;
+ stream->putBe64(cgen_var_1508);
if (local_pImageInfos)
{
for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i)
@@ -22473,8 +22913,8 @@
}
}
// WARNING PTR CHECK
- uint64_t cgen_var_1505 = (uint64_t)(uintptr_t)local_pBufferInfos;
- stream->putBe64(cgen_var_1505);
+ uint64_t cgen_var_1509 = (uint64_t)(uintptr_t)local_pBufferInfos;
+ stream->putBe64(cgen_var_1509);
if (local_pBufferInfos)
{
for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i)
@@ -22483,16 +22923,16 @@
}
}
// WARNING PTR CHECK
- uint64_t cgen_var_1506 = (uint64_t)(uintptr_t)local_pBufferViews;
- stream->putBe64(cgen_var_1506);
+ uint64_t cgen_var_1510 = (uint64_t)(uintptr_t)local_pBufferViews;
+ stream->putBe64(cgen_var_1510);
if (local_pBufferViews)
{
if (((bufferViewCount)))
{
- uint64_t* cgen_var_1507;
- stream->alloc((void**)&cgen_var_1507, ((bufferViewCount)) * 8);
- stream->handleMapping()->mapHandles_VkBufferView_u64(local_pBufferViews, cgen_var_1507, ((bufferViewCount)));
- stream->write((uint64_t*)cgen_var_1507, ((bufferViewCount)) * 8);
+ uint64_t* cgen_var_1511;
+ stream->alloc((void**)&cgen_var_1511, ((bufferViewCount)) * 8);
+ stream->handleMapping()->mapHandles_VkBufferView_u64(local_pBufferViews, cgen_var_1511, ((bufferViewCount)));
+ stream->write((uint64_t*)cgen_var_1511, ((bufferViewCount)) * 8);
}
}
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE readParams");
@@ -22506,6 +22946,7 @@
VkCommandBuffer commandBuffer,
const VkCommandBufferBeginInfo* pBeginInfo)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE encode");
mImpl->log("start vkBeginCommandBufferAsyncGOOGLE");
auto stream = mImpl->stream();
@@ -22528,9 +22969,9 @@
}
countingStream->rewind();
{
- uint64_t cgen_var_1508;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1508, 1);
- countingStream->write((uint64_t*)&cgen_var_1508, 1 * 8);
+ uint64_t cgen_var_1512;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1512, 1);
+ countingStream->write((uint64_t*)&cgen_var_1512, 1 * 8);
marshal_VkCommandBufferBeginInfo(countingStream, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
}
uint32_t packetSize_vkBeginCommandBufferAsyncGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -22538,9 +22979,9 @@
uint32_t opcode_vkBeginCommandBufferAsyncGOOGLE = OP_vkBeginCommandBufferAsyncGOOGLE;
stream->write(&opcode_vkBeginCommandBufferAsyncGOOGLE, sizeof(uint32_t));
stream->write(&packetSize_vkBeginCommandBufferAsyncGOOGLE, sizeof(uint32_t));
- uint64_t cgen_var_1509;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1509, 1);
- stream->write((uint64_t*)&cgen_var_1509, 1 * 8);
+ uint64_t cgen_var_1513;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1513, 1);
+ stream->write((uint64_t*)&cgen_var_1513, 1 * 8);
marshal_VkCommandBufferBeginInfo(stream, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE readParams");
AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE returnUnmarshal");
@@ -22550,6 +22991,7 @@
void VkEncoder::vkEndCommandBufferAsyncGOOGLE(
VkCommandBuffer commandBuffer)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE encode");
mImpl->log("start vkEndCommandBufferAsyncGOOGLE");
auto stream = mImpl->stream();
@@ -22561,18 +23003,18 @@
local_commandBuffer = commandBuffer;
countingStream->rewind();
{
- uint64_t cgen_var_1510;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1510, 1);
- countingStream->write((uint64_t*)&cgen_var_1510, 1 * 8);
+ uint64_t cgen_var_1514;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1514, 1);
+ countingStream->write((uint64_t*)&cgen_var_1514, 1 * 8);
}
uint32_t packetSize_vkEndCommandBufferAsyncGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
countingStream->rewind();
uint32_t opcode_vkEndCommandBufferAsyncGOOGLE = OP_vkEndCommandBufferAsyncGOOGLE;
stream->write(&opcode_vkEndCommandBufferAsyncGOOGLE, sizeof(uint32_t));
stream->write(&packetSize_vkEndCommandBufferAsyncGOOGLE, sizeof(uint32_t));
- uint64_t cgen_var_1511;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1511, 1);
- stream->write((uint64_t*)&cgen_var_1511, 1 * 8);
+ uint64_t cgen_var_1515;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1515, 1);
+ stream->write((uint64_t*)&cgen_var_1515, 1 * 8);
AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE readParams");
AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE returnUnmarshal");
mImpl->log("finish vkEndCommandBufferAsyncGOOGLE");;
@@ -22582,6 +23024,7 @@
VkCommandBuffer commandBuffer,
VkCommandBufferResetFlags flags)
{
+ AutoLock encoderLock(mImpl->lock);
AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE encode");
mImpl->log("start vkResetCommandBufferAsyncGOOGLE");
auto stream = mImpl->stream();
@@ -22595,9 +23038,9 @@
local_flags = flags;
countingStream->rewind();
{
- uint64_t cgen_var_1512;
- countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1512, 1);
- countingStream->write((uint64_t*)&cgen_var_1512, 1 * 8);
+ uint64_t cgen_var_1516;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1516, 1);
+ countingStream->write((uint64_t*)&cgen_var_1516, 1 * 8);
countingStream->write((VkCommandBufferResetFlags*)&local_flags, sizeof(VkCommandBufferResetFlags));
}
uint32_t packetSize_vkResetCommandBufferAsyncGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
@@ -22605,15 +23048,262 @@
uint32_t opcode_vkResetCommandBufferAsyncGOOGLE = OP_vkResetCommandBufferAsyncGOOGLE;
stream->write(&opcode_vkResetCommandBufferAsyncGOOGLE, sizeof(uint32_t));
stream->write(&packetSize_vkResetCommandBufferAsyncGOOGLE, sizeof(uint32_t));
- uint64_t cgen_var_1513;
- stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1513, 1);
- stream->write((uint64_t*)&cgen_var_1513, 1 * 8);
+ uint64_t cgen_var_1517;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1517, 1);
+ stream->write((uint64_t*)&cgen_var_1517, 1 * 8);
stream->write((VkCommandBufferResetFlags*)&local_flags, sizeof(VkCommandBufferResetFlags));
AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE readParams");
AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE returnUnmarshal");
mImpl->log("finish vkResetCommandBufferAsyncGOOGLE");;
}
+void VkEncoder::vkCommandBufferHostSyncGOOGLE(
+ VkCommandBuffer commandBuffer,
+ uint32_t needHostSync,
+ uint32_t sequenceNumber)
+{
+ AutoLock encoderLock(mImpl->lock);
+ AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE encode");
+ mImpl->log("start vkCommandBufferHostSyncGOOGLE");
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkCommandBuffer local_commandBuffer;
+ uint32_t local_needHostSync;
+ uint32_t local_sequenceNumber;
+ local_commandBuffer = commandBuffer;
+ local_needHostSync = needHostSync;
+ local_sequenceNumber = sequenceNumber;
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1518;
+ countingStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1518, 1);
+ countingStream->write((uint64_t*)&cgen_var_1518, 1 * 8);
+ countingStream->write((uint32_t*)&local_needHostSync, sizeof(uint32_t));
+ countingStream->write((uint32_t*)&local_sequenceNumber, sizeof(uint32_t));
+ }
+ uint32_t packetSize_vkCommandBufferHostSyncGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCommandBufferHostSyncGOOGLE = OP_vkCommandBufferHostSyncGOOGLE;
+ stream->write(&opcode_vkCommandBufferHostSyncGOOGLE, sizeof(uint32_t));
+ stream->write(&packetSize_vkCommandBufferHostSyncGOOGLE, sizeof(uint32_t));
+ uint64_t cgen_var_1519;
+ stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1519, 1);
+ stream->write((uint64_t*)&cgen_var_1519, 1 * 8);
+ stream->write((uint32_t*)&local_needHostSync, sizeof(uint32_t));
+ stream->write((uint32_t*)&local_sequenceNumber, sizeof(uint32_t));
+ AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE readParams");
+ AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE returnUnmarshal");
+ mImpl->log("finish vkCommandBufferHostSyncGOOGLE");;
+}
+
+#endif
+#ifdef VK_GOOGLE_create_resources_with_requirements
+VkResult VkEncoder::vkCreateImageWithRequirementsGOOGLE(
+ VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage,
+ VkMemoryRequirements* pMemoryRequirements)
+{
+ AutoLock encoderLock(mImpl->lock);
+ AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE encode");
+ mImpl->log("start vkCreateImageWithRequirementsGOOGLE");
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkImageCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkImageCreateInfo*)pool->alloc(sizeof(const VkImageCreateInfo));
+ deepcopy_VkImageCreateInfo(pool, pCreateInfo, (VkImageCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ mImpl->resources()->unwrap_VkNativeBufferANDROID(pCreateInfo, local_pCreateInfo);
+ local_pAllocator = nullptr;
+ if (local_pCreateInfo)
+ {
+ transform_tohost_VkImageCreateInfo(mImpl->resources(), (VkImageCreateInfo*)(local_pCreateInfo));
+ }
+ if (local_pAllocator)
+ {
+ transform_tohost_VkAllocationCallbacks(mImpl->resources(), (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1520;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1520, 1);
+ countingStream->write((uint64_t*)&cgen_var_1520, 1 * 8);
+ marshal_VkImageCreateInfo(countingStream, (VkImageCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1521 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1521);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_1522;
+ countingStream->handleMapping()->mapHandles_VkImage_u64(pImage, &cgen_var_1522, 1);
+ countingStream->write((uint64_t*)&cgen_var_1522, 8);
+ marshal_VkMemoryRequirements(countingStream, (VkMemoryRequirements*)(pMemoryRequirements));
+ }
+ uint32_t packetSize_vkCreateImageWithRequirementsGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateImageWithRequirementsGOOGLE = OP_vkCreateImageWithRequirementsGOOGLE;
+ stream->write(&opcode_vkCreateImageWithRequirementsGOOGLE, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateImageWithRequirementsGOOGLE, sizeof(uint32_t));
+ uint64_t cgen_var_1523;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1523, 1);
+ stream->write((uint64_t*)&cgen_var_1523, 1 * 8);
+ marshal_VkImageCreateInfo(stream, (VkImageCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1524 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1524);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_1525;
+ stream->handleMapping()->mapHandles_VkImage_u64(pImage, &cgen_var_1525, 1);
+ stream->write((uint64_t*)&cgen_var_1525, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
+ AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE readParams");
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_1526;
+ stream->read((uint64_t*)&cgen_var_1526, 8);
+ stream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1526, (VkImage*)pImage, 1);
+ stream->unsetHandleMapping();
+ unmarshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
+ if (pMemoryRequirements)
+ {
+ transform_fromhost_VkMemoryRequirements(mImpl->resources(), (VkMemoryRequirements*)(pMemoryRequirements));
+ }
+ AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE returnUnmarshal");
+ VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateImageWithRequirementsGOOGLE_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ mImpl->log("finish vkCreateImageWithRequirementsGOOGLE");;
+ return vkCreateImageWithRequirementsGOOGLE_VkResult_return;
+}
+
+VkResult VkEncoder::vkCreateBufferWithRequirementsGOOGLE(
+ VkDevice device,
+ const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer,
+ VkMemoryRequirements* pMemoryRequirements)
+{
+ AutoLock encoderLock(mImpl->lock);
+ AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE encode");
+ mImpl->log("start vkCreateBufferWithRequirementsGOOGLE");
+ auto stream = mImpl->stream();
+ auto countingStream = mImpl->countingStream();
+ auto resources = mImpl->resources();
+ auto pool = mImpl->pool();
+ stream->setHandleMapping(resources->unwrapMapping());
+ VkDevice local_device;
+ VkBufferCreateInfo* local_pCreateInfo;
+ VkAllocationCallbacks* local_pAllocator;
+ local_device = device;
+ local_pCreateInfo = nullptr;
+ if (pCreateInfo)
+ {
+ local_pCreateInfo = (VkBufferCreateInfo*)pool->alloc(sizeof(const VkBufferCreateInfo));
+ deepcopy_VkBufferCreateInfo(pool, pCreateInfo, (VkBufferCreateInfo*)(local_pCreateInfo));
+ }
+ local_pAllocator = nullptr;
+ if (pAllocator)
+ {
+ local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
+ deepcopy_VkAllocationCallbacks(pool, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ local_pAllocator = nullptr;
+ if (local_pCreateInfo)
+ {
+ transform_tohost_VkBufferCreateInfo(mImpl->resources(), (VkBufferCreateInfo*)(local_pCreateInfo));
+ }
+ if (local_pAllocator)
+ {
+ transform_tohost_VkAllocationCallbacks(mImpl->resources(), (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ countingStream->rewind();
+ {
+ uint64_t cgen_var_1527;
+ countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1527, 1);
+ countingStream->write((uint64_t*)&cgen_var_1527, 1 * 8);
+ marshal_VkBufferCreateInfo(countingStream, (VkBufferCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1528 = (uint64_t)(uintptr_t)local_pAllocator;
+ countingStream->putBe64(cgen_var_1528);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(countingStream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ uint64_t cgen_var_1529;
+ countingStream->handleMapping()->mapHandles_VkBuffer_u64(pBuffer, &cgen_var_1529, 1);
+ countingStream->write((uint64_t*)&cgen_var_1529, 8);
+ marshal_VkMemoryRequirements(countingStream, (VkMemoryRequirements*)(pMemoryRequirements));
+ }
+ uint32_t packetSize_vkCreateBufferWithRequirementsGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten();
+ countingStream->rewind();
+ uint32_t opcode_vkCreateBufferWithRequirementsGOOGLE = OP_vkCreateBufferWithRequirementsGOOGLE;
+ stream->write(&opcode_vkCreateBufferWithRequirementsGOOGLE, sizeof(uint32_t));
+ stream->write(&packetSize_vkCreateBufferWithRequirementsGOOGLE, sizeof(uint32_t));
+ uint64_t cgen_var_1530;
+ stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1530, 1);
+ stream->write((uint64_t*)&cgen_var_1530, 1 * 8);
+ marshal_VkBufferCreateInfo(stream, (VkBufferCreateInfo*)(local_pCreateInfo));
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1531 = (uint64_t)(uintptr_t)local_pAllocator;
+ stream->putBe64(cgen_var_1531);
+ if (local_pAllocator)
+ {
+ marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator));
+ }
+ stream->unsetHandleMapping() /* emit_marshal, is handle, possibly out */;
+ uint64_t cgen_var_1532;
+ stream->handleMapping()->mapHandles_VkBuffer_u64(pBuffer, &cgen_var_1532, 1);
+ stream->write((uint64_t*)&cgen_var_1532, 8);
+ stream->setHandleMapping(resources->unwrapMapping());
+ marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
+ AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE readParams");
+ stream->setHandleMapping(resources->createMapping());
+ uint64_t cgen_var_1533;
+ stream->read((uint64_t*)&cgen_var_1533, 8);
+ stream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1533, (VkBuffer*)pBuffer, 1);
+ stream->unsetHandleMapping();
+ unmarshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements));
+ if (pMemoryRequirements)
+ {
+ transform_fromhost_VkMemoryRequirements(mImpl->resources(), (VkMemoryRequirements*)(pMemoryRequirements));
+ }
+ AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE returnUnmarshal");
+ VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
+ stream->read(&vkCreateBufferWithRequirementsGOOGLE_VkResult_return, sizeof(VkResult));
+ countingStream->clearPool();
+ stream->clearPool();
+ pool->freeAll();
+ mImpl->log("finish vkCreateBufferWithRequirementsGOOGLE");;
+ return vkCreateBufferWithRequirementsGOOGLE_VkResult_return;
+}
+
#endif
} // namespace goldfish_vk
diff --git a/system/vulkan_enc/VkEncoder.h b/system/vulkan_enc/VkEncoder.h
index 8328b32..dd2cd64 100644
--- a/system/vulkan_enc/VkEncoder.h
+++ b/system/vulkan_enc/VkEncoder.h
@@ -28,6 +28,7 @@
#include "goldfish_vk_private_defs.h"
+#include <functional>
#include <memory>
class IOStream;
@@ -39,6 +40,12 @@
public:
VkEncoder(IOStream* stream);
~VkEncoder();
+
+ void flush();
+
+ using CleanupCallback = std::function<void()>;
+ void registerCleanupCallback(void* handle, CleanupCallback cb);
+ void unregisterCleanupCallback(void* handle);
#ifdef VK_VERSION_1_0
VkResult vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
@@ -1781,6 +1788,24 @@
void vkResetCommandBufferAsyncGOOGLE(
VkCommandBuffer commandBuffer,
VkCommandBufferResetFlags flags);
+ void vkCommandBufferHostSyncGOOGLE(
+ VkCommandBuffer commandBuffer,
+ uint32_t needHostSync,
+ uint32_t sequenceNumber);
+#endif
+#ifdef VK_GOOGLE_create_resources_with_requirements
+ VkResult vkCreateImageWithRequirementsGOOGLE(
+ VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage,
+ VkMemoryRequirements* pMemoryRequirements);
+ VkResult vkCreateBufferWithRequirementsGOOGLE(
+ VkDevice device,
+ const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer,
+ VkMemoryRequirements* pMemoryRequirements);
#endif
private:
diff --git a/system/vulkan_enc/VulkanHandles.h b/system/vulkan_enc/VulkanHandles.h
index 481e601..ea926d8 100644
--- a/system/vulkan_enc/VulkanHandles.h
+++ b/system/vulkan_enc/VulkanHandles.h
@@ -19,11 +19,11 @@
#define GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f) \
f(VkPhysicalDevice) \
f(VkQueue) \
- f(VkCommandBuffer) \
#define GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(f) \
f(VkInstance) \
f(VkDevice) \
+ f(VkCommandBuffer) \
GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f)
#define GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f) \
diff --git a/system/vulkan_enc/VulkanStreamGuest.cpp b/system/vulkan_enc/VulkanStreamGuest.cpp
index bbb5437..43f3706 100644
--- a/system/vulkan_enc/VulkanStreamGuest.cpp
+++ b/system/vulkan_enc/VulkanStreamGuest.cpp
@@ -14,6 +14,7 @@
#include "VulkanStreamGuest.h"
#include "IOStream.h"
+#include "ResourceTracker.h"
#include "android/base/Pool.h"
#include "android/base/Tracing.h"
@@ -27,7 +28,10 @@
class VulkanStreamGuest::Impl : public android::base::Stream {
public:
- Impl(IOStream* stream) : mStream(stream) { unsetHandleMapping(); }
+ Impl(IOStream* stream) : mStream(stream) {
+ unsetHandleMapping();
+ mFeatureBits = ResourceTracker::get()->getStreamFeatures();
+ }
~Impl() { }
@@ -49,8 +53,7 @@
}
ssize_t read(void *buffer, size_t size) override {
- commitWrite();
- if (!mStream->readFully(buffer, size)) {
+ if (!mStream->readback(buffer, size)) {
ALOGE("FATAL: Could not read back %zu bytes", size);
abort();
}
@@ -77,6 +80,10 @@
commitWrite();
}
+ uint32_t getFeatureBits() const {
+ return mFeatureBits;
+ }
+
private:
size_t oustandingWriteBuffer() const {
return mWritePos;
@@ -107,6 +114,7 @@
IOStream* mStream = nullptr;
DefaultHandleMapping mDefaultHandleMapping;
VulkanHandleMapping* mCurrentHandleMapping;
+ uint32_t mFeatureBits = 0;
};
VulkanStreamGuest::VulkanStreamGuest(IOStream *stream) :
@@ -178,6 +186,10 @@
mImpl->flush();
}
+uint32_t VulkanStreamGuest::getFeatureBits() const {
+ return mImpl->getFeatureBits();
+}
+
VulkanCountingStream::VulkanCountingStream() : VulkanStreamGuest(nullptr) { }
VulkanCountingStream::~VulkanCountingStream() = default;
diff --git a/system/vulkan_enc/VulkanStreamGuest.h b/system/vulkan_enc/VulkanStreamGuest.h
index 8fa4aaa..d70b9fb 100644
--- a/system/vulkan_enc/VulkanStreamGuest.h
+++ b/system/vulkan_enc/VulkanStreamGuest.h
@@ -16,6 +16,8 @@
#include "android/base/files/Stream.h"
#include "android/base/files/StreamSerializing.h"
+#include "goldfish_vk_private_defs.h"
+
#include "VulkanHandleMapping.h"
#include <memory>
@@ -51,6 +53,9 @@
VulkanHandleMapping* handleMapping() const;
void flush();
+
+ uint32_t getFeatureBits() const;
+
private:
class Impl;
std::unique_ptr<Impl> mImpl;
diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
index 5b004c0..1513661 100644
--- a/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
@@ -6384,6 +6384,8 @@
#endif
#ifdef VK_GOOGLE_async_command_buffers
#endif
+#ifdef VK_GOOGLE_create_resources_with_requirements
+#endif
void deepcopy_extension_struct(
Pool* pool,
const void* structExtension,
diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.h b/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
index b367ee0..ca6d6dc 100644
--- a/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
+++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
@@ -2026,5 +2026,7 @@
#endif
#ifdef VK_GOOGLE_async_command_buffers
#endif
+#ifdef VK_GOOGLE_create_resources_with_requirements
+#endif
} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp b/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
index c42f6e8..481ce6c 100644
--- a/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
@@ -282,6 +282,8 @@
#endif
#ifdef VK_GOOGLE_async_command_buffers
#endif
+#ifdef VK_GOOGLE_create_resources_with_requirements
+#endif
uint32_t goldfish_vk_struct_type(
const void* structExtension)
{
diff --git a/system/vulkan_enc/goldfish_vk_extension_structs_guest.h b/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
index 1d671f8..7df1ac1 100644
--- a/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
+++ b/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
@@ -299,5 +299,7 @@
#endif
#ifdef VK_GOOGLE_async_command_buffers
#endif
+#ifdef VK_GOOGLE_create_resources_with_requirements
+#endif
} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp b/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
index 7d16b31..fbc6a48 100644
--- a/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
@@ -4748,6 +4748,8 @@
#endif
#ifdef VK_GOOGLE_async_command_buffers
#endif
+#ifdef VK_GOOGLE_create_resources_with_requirements
+#endif
void handlemap_extension_struct(
VulkanHandleMapping* handlemap,
void* structExtension_out)
diff --git a/system/vulkan_enc/goldfish_vk_handlemap_guest.h b/system/vulkan_enc/goldfish_vk_handlemap_guest.h
index e973064..911ff2f 100644
--- a/system/vulkan_enc/goldfish_vk_handlemap_guest.h
+++ b/system/vulkan_enc/goldfish_vk_handlemap_guest.h
@@ -1679,5 +1679,7 @@
#endif
#ifdef VK_GOOGLE_async_command_buffers
#endif
+#ifdef VK_GOOGLE_create_resources_with_requirements
+#endif
} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
index a67e9ad..0ed32d3 100644
--- a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
@@ -52,9 +52,35 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- vkStream->putString(forMarshaling->pApplicationName);
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
+ {
+ // WARNING PTR CHECK
+ uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pApplicationName;
+ vkStream->putBe64(cgen_var_0);
+ if (forMarshaling->pApplicationName)
+ {
+ vkStream->putString(forMarshaling->pApplicationName);
+ }
+ }
+ else
+ {
+ vkStream->putString(forMarshaling->pApplicationName);
+ }
vkStream->write((uint32_t*)&forMarshaling->applicationVersion, sizeof(uint32_t));
- vkStream->putString(forMarshaling->pEngineName);
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
+ {
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pEngineName;
+ vkStream->putBe64(cgen_var_1);
+ if (forMarshaling->pEngineName)
+ {
+ vkStream->putString(forMarshaling->pEngineName);
+ }
+ }
+ else
+ {
+ vkStream->putString(forMarshaling->pEngineName);
+ }
vkStream->write((uint32_t*)&forMarshaling->engineVersion, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->apiVersion, sizeof(uint32_t));
}
@@ -72,9 +98,43 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- vkStream->loadStringInPlace((char**)&forUnmarshaling->pApplicationName);
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
+ {
+ // WARNING PTR CHECK
+ const char* check_pApplicationName;
+ check_pApplicationName = (const char*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pApplicationName)
+ {
+ if (!(check_pApplicationName))
+ {
+ fprintf(stderr, "fatal: forUnmarshaling->pApplicationName inconsistent between guest and host\n");
+ }
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pApplicationName);
+ }
+ }
+ else
+ {
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pApplicationName);
+ }
vkStream->read((uint32_t*)&forUnmarshaling->applicationVersion, sizeof(uint32_t));
- vkStream->loadStringInPlace((char**)&forUnmarshaling->pEngineName);
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
+ {
+ // WARNING PTR CHECK
+ const char* check_pEngineName;
+ check_pEngineName = (const char*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pEngineName)
+ {
+ if (!(check_pEngineName))
+ {
+ fprintf(stderr, "fatal: forUnmarshaling->pEngineName inconsistent between guest and host\n");
+ }
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pEngineName);
+ }
+ }
+ else
+ {
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pEngineName);
+ }
vkStream->read((uint32_t*)&forUnmarshaling->engineVersion, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->apiVersion, sizeof(uint32_t));
}
@@ -93,8 +153,8 @@
}
vkStream->write((VkInstanceCreateFlags*)&forMarshaling->flags, sizeof(VkInstanceCreateFlags));
// WARNING PTR CHECK
- uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pApplicationInfo;
- vkStream->putBe64(cgen_var_0);
+ uint64_t cgen_var_4 = (uint64_t)(uintptr_t)forMarshaling->pApplicationInfo;
+ vkStream->putBe64(cgen_var_4);
if (forMarshaling->pApplicationInfo)
{
marshal_VkApplicationInfo(vkStream, (const VkApplicationInfo*)(forMarshaling->pApplicationInfo));
@@ -141,22 +201,22 @@
const VkAllocationCallbacks* forMarshaling)
{
// WARNING PTR CHECK
- uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
- vkStream->putBe64(cgen_var_2);
+ uint64_t cgen_var_6 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
+ vkStream->putBe64(cgen_var_6);
if (forMarshaling->pUserData)
{
vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
}
- uint64_t cgen_var_3 = (uint64_t)forMarshaling->pfnAllocation;
- vkStream->putBe64(cgen_var_3);
- uint64_t cgen_var_4 = (uint64_t)forMarshaling->pfnReallocation;
- vkStream->putBe64(cgen_var_4);
- uint64_t cgen_var_5 = (uint64_t)forMarshaling->pfnFree;
- vkStream->putBe64(cgen_var_5);
- uint64_t cgen_var_6 = (uint64_t)forMarshaling->pfnInternalAllocation;
- vkStream->putBe64(cgen_var_6);
- uint64_t cgen_var_7 = (uint64_t)forMarshaling->pfnInternalFree;
+ uint64_t cgen_var_7 = (uint64_t)forMarshaling->pfnAllocation;
vkStream->putBe64(cgen_var_7);
+ uint64_t cgen_var_8 = (uint64_t)forMarshaling->pfnReallocation;
+ vkStream->putBe64(cgen_var_8);
+ uint64_t cgen_var_9 = (uint64_t)forMarshaling->pfnFree;
+ vkStream->putBe64(cgen_var_9);
+ uint64_t cgen_var_10 = (uint64_t)forMarshaling->pfnInternalAllocation;
+ vkStream->putBe64(cgen_var_10);
+ uint64_t cgen_var_11 = (uint64_t)forMarshaling->pfnInternalFree;
+ vkStream->putBe64(cgen_var_11);
}
void unmarshal_VkAllocationCallbacks(
@@ -431,8 +491,8 @@
vkStream->write((uint32_t*)forMarshaling->maxViewportDimensions, 2 * sizeof(uint32_t));
vkStream->write((float*)forMarshaling->viewportBoundsRange, 2 * sizeof(float));
vkStream->write((uint32_t*)&forMarshaling->viewportSubPixelBits, sizeof(uint32_t));
- uint64_t cgen_var_14 = (uint64_t)forMarshaling->minMemoryMapAlignment;
- vkStream->putBe64(cgen_var_14);
+ uint64_t cgen_var_18 = (uint64_t)forMarshaling->minMemoryMapAlignment;
+ vkStream->putBe64(cgen_var_18);
vkStream->write((VkDeviceSize*)&forMarshaling->minTexelBufferOffsetAlignment, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->minUniformBufferOffsetAlignment, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->minStorageBufferOffsetAlignment, sizeof(VkDeviceSize));
@@ -782,8 +842,8 @@
vkStream->write((uint32_t*)&forMarshaling->enabledExtensionCount, sizeof(uint32_t));
saveStringArray(vkStream, forMarshaling->ppEnabledExtensionNames, forMarshaling->enabledExtensionCount);
// WARNING PTR CHECK
- uint64_t cgen_var_16 = (uint64_t)(uintptr_t)forMarshaling->pEnabledFeatures;
- vkStream->putBe64(cgen_var_16);
+ uint64_t cgen_var_20 = (uint64_t)(uintptr_t)forMarshaling->pEnabledFeatures;
+ vkStream->putBe64(cgen_var_20);
if (forMarshaling->pEnabledFeatures)
{
marshal_VkPhysicalDeviceFeatures(vkStream, (const VkPhysicalDeviceFeatures*)(forMarshaling->pEnabledFeatures));
@@ -877,27 +937,27 @@
vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
if (forMarshaling->waitSemaphoreCount)
{
- uint64_t* cgen_var_18;
- vkStream->alloc((void**)&cgen_var_18, forMarshaling->waitSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pWaitSemaphores, cgen_var_18, forMarshaling->waitSemaphoreCount);
- vkStream->write((uint64_t*)cgen_var_18, forMarshaling->waitSemaphoreCount * 8);
+ uint64_t* cgen_var_22;
+ vkStream->alloc((void**)&cgen_var_22, forMarshaling->waitSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pWaitSemaphores, cgen_var_22, forMarshaling->waitSemaphoreCount);
+ vkStream->write((uint64_t*)cgen_var_22, forMarshaling->waitSemaphoreCount * 8);
}
vkStream->write((const VkPipelineStageFlags*)forMarshaling->pWaitDstStageMask, forMarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
vkStream->write((uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
if (forMarshaling->commandBufferCount)
{
- uint64_t* cgen_var_19;
- vkStream->alloc((void**)&cgen_var_19, forMarshaling->commandBufferCount * 8);
- vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(forMarshaling->pCommandBuffers, cgen_var_19, forMarshaling->commandBufferCount);
- vkStream->write((uint64_t*)cgen_var_19, forMarshaling->commandBufferCount * 8);
+ uint64_t* cgen_var_23;
+ vkStream->alloc((void**)&cgen_var_23, forMarshaling->commandBufferCount * 8);
+ vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(forMarshaling->pCommandBuffers, cgen_var_23, forMarshaling->commandBufferCount);
+ vkStream->write((uint64_t*)cgen_var_23, forMarshaling->commandBufferCount * 8);
}
vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
if (forMarshaling->signalSemaphoreCount)
{
- uint64_t* cgen_var_20;
- vkStream->alloc((void**)&cgen_var_20, forMarshaling->signalSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pSignalSemaphores, cgen_var_20, forMarshaling->signalSemaphoreCount);
- vkStream->write((uint64_t*)cgen_var_20, forMarshaling->signalSemaphoreCount * 8);
+ uint64_t* cgen_var_24;
+ vkStream->alloc((void**)&cgen_var_24, forMarshaling->signalSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pSignalSemaphores, cgen_var_24, forMarshaling->signalSemaphoreCount);
+ vkStream->write((uint64_t*)cgen_var_24, forMarshaling->signalSemaphoreCount * 8);
}
}
@@ -917,27 +977,27 @@
vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
if (forUnmarshaling->waitSemaphoreCount)
{
- uint64_t* cgen_var_21;
- vkStream->alloc((void**)&cgen_var_21, forUnmarshaling->waitSemaphoreCount * 8);
- vkStream->read((uint64_t*)cgen_var_21, forUnmarshaling->waitSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_21, (VkSemaphore*)forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount);
+ uint64_t* cgen_var_25;
+ vkStream->alloc((void**)&cgen_var_25, forUnmarshaling->waitSemaphoreCount * 8);
+ vkStream->read((uint64_t*)cgen_var_25, forUnmarshaling->waitSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_25, (VkSemaphore*)forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount);
}
vkStream->read((VkPipelineStageFlags*)forUnmarshaling->pWaitDstStageMask, forUnmarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
vkStream->read((uint32_t*)&forUnmarshaling->commandBufferCount, sizeof(uint32_t));
if (forUnmarshaling->commandBufferCount)
{
- uint64_t* cgen_var_22;
- vkStream->alloc((void**)&cgen_var_22, forUnmarshaling->commandBufferCount * 8);
- vkStream->read((uint64_t*)cgen_var_22, forUnmarshaling->commandBufferCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(cgen_var_22, (VkCommandBuffer*)forUnmarshaling->pCommandBuffers, forUnmarshaling->commandBufferCount);
+ uint64_t* cgen_var_26;
+ vkStream->alloc((void**)&cgen_var_26, forUnmarshaling->commandBufferCount * 8);
+ vkStream->read((uint64_t*)cgen_var_26, forUnmarshaling->commandBufferCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(cgen_var_26, (VkCommandBuffer*)forUnmarshaling->pCommandBuffers, forUnmarshaling->commandBufferCount);
}
vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreCount, sizeof(uint32_t));
if (forUnmarshaling->signalSemaphoreCount)
{
- uint64_t* cgen_var_23;
- vkStream->alloc((void**)&cgen_var_23, forUnmarshaling->signalSemaphoreCount * 8);
- vkStream->read((uint64_t*)cgen_var_23, forUnmarshaling->signalSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_23, (VkSemaphore*)forUnmarshaling->pSignalSemaphores, forUnmarshaling->signalSemaphoreCount);
+ uint64_t* cgen_var_27;
+ vkStream->alloc((void**)&cgen_var_27, forUnmarshaling->signalSemaphoreCount * 8);
+ vkStream->read((uint64_t*)cgen_var_27, forUnmarshaling->signalSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_27, (VkSemaphore*)forUnmarshaling->pSignalSemaphores, forUnmarshaling->signalSemaphoreCount);
}
}
@@ -986,9 +1046,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_24;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_24, 1);
- vkStream->write((uint64_t*)&cgen_var_24, 1 * 8);
+ uint64_t cgen_var_28;
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_28, 1);
+ vkStream->write((uint64_t*)&cgen_var_28, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}
@@ -1006,9 +1066,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_25;
- vkStream->read((uint64_t*)&cgen_var_25, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_25, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ uint64_t cgen_var_29;
+ vkStream->read((uint64_t*)&cgen_var_29, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_29, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}
@@ -1077,9 +1137,9 @@
{
vkStream->write((VkDeviceSize*)&forMarshaling->resourceOffset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
- uint64_t cgen_var_26;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_26, 1);
- vkStream->write((uint64_t*)&cgen_var_26, 1 * 8);
+ uint64_t cgen_var_30;
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_30, 1);
+ vkStream->write((uint64_t*)&cgen_var_30, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
vkStream->write((VkSparseMemoryBindFlags*)&forMarshaling->flags, sizeof(VkSparseMemoryBindFlags));
}
@@ -1090,9 +1150,9 @@
{
vkStream->read((VkDeviceSize*)&forUnmarshaling->resourceOffset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
- uint64_t cgen_var_27;
- vkStream->read((uint64_t*)&cgen_var_27, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_27, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ uint64_t cgen_var_31;
+ vkStream->read((uint64_t*)&cgen_var_31, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_31, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
vkStream->read((VkSparseMemoryBindFlags*)&forUnmarshaling->flags, sizeof(VkSparseMemoryBindFlags));
}
@@ -1101,9 +1161,9 @@
VulkanStreamGuest* vkStream,
const VkSparseBufferMemoryBindInfo* forMarshaling)
{
- uint64_t cgen_var_28;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_28, 1);
- vkStream->write((uint64_t*)&cgen_var_28, 1 * 8);
+ uint64_t cgen_var_32;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_32, 1);
+ vkStream->write((uint64_t*)&cgen_var_32, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
{
@@ -1115,9 +1175,9 @@
VulkanStreamGuest* vkStream,
VkSparseBufferMemoryBindInfo* forUnmarshaling)
{
- uint64_t cgen_var_29;
- vkStream->read((uint64_t*)&cgen_var_29, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_29, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ uint64_t cgen_var_33;
+ vkStream->read((uint64_t*)&cgen_var_33, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_33, (VkBuffer*)&forUnmarshaling->buffer, 1);
vkStream->read((uint32_t*)&forUnmarshaling->bindCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i)
{
@@ -1129,9 +1189,9 @@
VulkanStreamGuest* vkStream,
const VkSparseImageOpaqueMemoryBindInfo* forMarshaling)
{
- uint64_t cgen_var_30;
- vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_30, 1);
- vkStream->write((uint64_t*)&cgen_var_30, 1 * 8);
+ uint64_t cgen_var_34;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_34, 1);
+ vkStream->write((uint64_t*)&cgen_var_34, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
{
@@ -1143,9 +1203,9 @@
VulkanStreamGuest* vkStream,
VkSparseImageOpaqueMemoryBindInfo* forUnmarshaling)
{
- uint64_t cgen_var_31;
- vkStream->read((uint64_t*)&cgen_var_31, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_31, (VkImage*)&forUnmarshaling->image, 1);
+ uint64_t cgen_var_35;
+ vkStream->read((uint64_t*)&cgen_var_35, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_35, (VkImage*)&forUnmarshaling->image, 1);
vkStream->read((uint32_t*)&forUnmarshaling->bindCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i)
{
@@ -1196,9 +1256,9 @@
marshal_VkImageSubresource(vkStream, (VkImageSubresource*)(&forMarshaling->subresource));
marshal_VkOffset3D(vkStream, (VkOffset3D*)(&forMarshaling->offset));
marshal_VkExtent3D(vkStream, (VkExtent3D*)(&forMarshaling->extent));
- uint64_t cgen_var_32;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_32, 1);
- vkStream->write((uint64_t*)&cgen_var_32, 1 * 8);
+ uint64_t cgen_var_36;
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_36, 1);
+ vkStream->write((uint64_t*)&cgen_var_36, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
vkStream->write((VkSparseMemoryBindFlags*)&forMarshaling->flags, sizeof(VkSparseMemoryBindFlags));
}
@@ -1210,9 +1270,9 @@
unmarshal_VkImageSubresource(vkStream, (VkImageSubresource*)(&forUnmarshaling->subresource));
unmarshal_VkOffset3D(vkStream, (VkOffset3D*)(&forUnmarshaling->offset));
unmarshal_VkExtent3D(vkStream, (VkExtent3D*)(&forUnmarshaling->extent));
- uint64_t cgen_var_33;
- vkStream->read((uint64_t*)&cgen_var_33, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_33, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ uint64_t cgen_var_37;
+ vkStream->read((uint64_t*)&cgen_var_37, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_37, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
vkStream->read((VkSparseMemoryBindFlags*)&forUnmarshaling->flags, sizeof(VkSparseMemoryBindFlags));
}
@@ -1221,9 +1281,9 @@
VulkanStreamGuest* vkStream,
const VkSparseImageMemoryBindInfo* forMarshaling)
{
- uint64_t cgen_var_34;
- vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_34, 1);
- vkStream->write((uint64_t*)&cgen_var_34, 1 * 8);
+ uint64_t cgen_var_38;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_38, 1);
+ vkStream->write((uint64_t*)&cgen_var_38, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
{
@@ -1235,9 +1295,9 @@
VulkanStreamGuest* vkStream,
VkSparseImageMemoryBindInfo* forUnmarshaling)
{
- uint64_t cgen_var_35;
- vkStream->read((uint64_t*)&cgen_var_35, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_35, (VkImage*)&forUnmarshaling->image, 1);
+ uint64_t cgen_var_39;
+ vkStream->read((uint64_t*)&cgen_var_39, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_39, (VkImage*)&forUnmarshaling->image, 1);
vkStream->read((uint32_t*)&forUnmarshaling->bindCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i)
{
@@ -1260,10 +1320,10 @@
vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
if (forMarshaling->waitSemaphoreCount)
{
- uint64_t* cgen_var_36;
- vkStream->alloc((void**)&cgen_var_36, forMarshaling->waitSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pWaitSemaphores, cgen_var_36, forMarshaling->waitSemaphoreCount);
- vkStream->write((uint64_t*)cgen_var_36, forMarshaling->waitSemaphoreCount * 8);
+ uint64_t* cgen_var_40;
+ vkStream->alloc((void**)&cgen_var_40, forMarshaling->waitSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pWaitSemaphores, cgen_var_40, forMarshaling->waitSemaphoreCount);
+ vkStream->write((uint64_t*)cgen_var_40, forMarshaling->waitSemaphoreCount * 8);
}
vkStream->write((uint32_t*)&forMarshaling->bufferBindCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferBindCount; ++i)
@@ -1283,10 +1343,10 @@
vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
if (forMarshaling->signalSemaphoreCount)
{
- uint64_t* cgen_var_37;
- vkStream->alloc((void**)&cgen_var_37, forMarshaling->signalSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pSignalSemaphores, cgen_var_37, forMarshaling->signalSemaphoreCount);
- vkStream->write((uint64_t*)cgen_var_37, forMarshaling->signalSemaphoreCount * 8);
+ uint64_t* cgen_var_41;
+ vkStream->alloc((void**)&cgen_var_41, forMarshaling->signalSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pSignalSemaphores, cgen_var_41, forMarshaling->signalSemaphoreCount);
+ vkStream->write((uint64_t*)cgen_var_41, forMarshaling->signalSemaphoreCount * 8);
}
}
@@ -1306,10 +1366,10 @@
vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
if (forUnmarshaling->waitSemaphoreCount)
{
- uint64_t* cgen_var_38;
- vkStream->alloc((void**)&cgen_var_38, forUnmarshaling->waitSemaphoreCount * 8);
- vkStream->read((uint64_t*)cgen_var_38, forUnmarshaling->waitSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_38, (VkSemaphore*)forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount);
+ uint64_t* cgen_var_42;
+ vkStream->alloc((void**)&cgen_var_42, forUnmarshaling->waitSemaphoreCount * 8);
+ vkStream->read((uint64_t*)cgen_var_42, forUnmarshaling->waitSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_42, (VkSemaphore*)forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount);
}
vkStream->read((uint32_t*)&forUnmarshaling->bufferBindCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bufferBindCount; ++i)
@@ -1329,10 +1389,10 @@
vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreCount, sizeof(uint32_t));
if (forUnmarshaling->signalSemaphoreCount)
{
- uint64_t* cgen_var_39;
- vkStream->alloc((void**)&cgen_var_39, forUnmarshaling->signalSemaphoreCount * 8);
- vkStream->read((uint64_t*)cgen_var_39, forUnmarshaling->signalSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_39, (VkSemaphore*)forUnmarshaling->pSignalSemaphores, forUnmarshaling->signalSemaphoreCount);
+ uint64_t* cgen_var_43;
+ vkStream->alloc((void**)&cgen_var_43, forUnmarshaling->signalSemaphoreCount * 8);
+ vkStream->read((uint64_t*)cgen_var_43, forUnmarshaling->signalSemaphoreCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_43, (VkSemaphore*)forUnmarshaling->pSignalSemaphores, forUnmarshaling->signalSemaphoreCount);
}
}
@@ -1484,8 +1544,8 @@
vkStream->write((VkSharingMode*)&forMarshaling->sharingMode, sizeof(VkSharingMode));
vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_40 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
- vkStream->putBe64(cgen_var_40);
+ uint64_t cgen_var_44 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
+ vkStream->putBe64(cgen_var_44);
if (forMarshaling->pQueueFamilyIndices)
{
vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
@@ -1536,9 +1596,9 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
vkStream->write((VkBufferViewCreateFlags*)&forMarshaling->flags, sizeof(VkBufferViewCreateFlags));
- uint64_t cgen_var_42;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_42, 1);
- vkStream->write((uint64_t*)&cgen_var_42, 1 * 8);
+ uint64_t cgen_var_46;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_46, 1);
+ vkStream->write((uint64_t*)&cgen_var_46, 1 * 8);
vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->range, sizeof(VkDeviceSize));
@@ -1558,9 +1618,9 @@
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
vkStream->read((VkBufferViewCreateFlags*)&forUnmarshaling->flags, sizeof(VkBufferViewCreateFlags));
- uint64_t cgen_var_43;
- vkStream->read((uint64_t*)&cgen_var_43, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_43, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ uint64_t cgen_var_47;
+ vkStream->read((uint64_t*)&cgen_var_47, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_47, (VkBuffer*)&forUnmarshaling->buffer, 1);
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->range, sizeof(VkDeviceSize));
@@ -1590,8 +1650,8 @@
vkStream->write((VkSharingMode*)&forMarshaling->sharingMode, sizeof(VkSharingMode));
vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_44 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
- vkStream->putBe64(cgen_var_44);
+ uint64_t cgen_var_48 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
+ vkStream->putBe64(cgen_var_48);
if (forMarshaling->pQueueFamilyIndices)
{
vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
@@ -1714,9 +1774,9 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
vkStream->write((VkImageViewCreateFlags*)&forMarshaling->flags, sizeof(VkImageViewCreateFlags));
- uint64_t cgen_var_46;
- vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_46, 1);
- vkStream->write((uint64_t*)&cgen_var_46, 1 * 8);
+ uint64_t cgen_var_50;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_50, 1);
+ vkStream->write((uint64_t*)&cgen_var_50, 1 * 8);
vkStream->write((VkImageViewType*)&forMarshaling->viewType, sizeof(VkImageViewType));
vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
marshal_VkComponentMapping(vkStream, (VkComponentMapping*)(&forMarshaling->components));
@@ -1737,9 +1797,9 @@
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
vkStream->read((VkImageViewCreateFlags*)&forUnmarshaling->flags, sizeof(VkImageViewCreateFlags));
- uint64_t cgen_var_47;
- vkStream->read((uint64_t*)&cgen_var_47, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_47, (VkImage*)&forUnmarshaling->image, 1);
+ uint64_t cgen_var_51;
+ vkStream->read((uint64_t*)&cgen_var_51, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_51, (VkImage*)&forUnmarshaling->image, 1);
vkStream->read((VkImageViewType*)&forUnmarshaling->viewType, sizeof(VkImageViewType));
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
unmarshal_VkComponentMapping(vkStream, (VkComponentMapping*)(&forUnmarshaling->components));
@@ -1759,8 +1819,8 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
vkStream->write((VkShaderModuleCreateFlags*)&forMarshaling->flags, sizeof(VkShaderModuleCreateFlags));
- uint64_t cgen_var_48 = (uint64_t)forMarshaling->codeSize;
- vkStream->putBe64(cgen_var_48);
+ uint64_t cgen_var_52 = (uint64_t)forMarshaling->codeSize;
+ vkStream->putBe64(cgen_var_52);
vkStream->write((const uint32_t*)forMarshaling->pCode, (forMarshaling->codeSize / 4) * sizeof(const uint32_t));
}
@@ -1795,8 +1855,8 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
vkStream->write((VkPipelineCacheCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCacheCreateFlags));
- uint64_t cgen_var_50 = (uint64_t)forMarshaling->initialDataSize;
- vkStream->putBe64(cgen_var_50);
+ uint64_t cgen_var_54 = (uint64_t)forMarshaling->initialDataSize;
+ vkStream->putBe64(cgen_var_54);
vkStream->write((const void*)forMarshaling->pInitialData, forMarshaling->initialDataSize * sizeof(const uint8_t));
}
@@ -1824,8 +1884,8 @@
{
vkStream->write((uint32_t*)&forMarshaling->constantID, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
- uint64_t cgen_var_52 = (uint64_t)forMarshaling->size;
- vkStream->putBe64(cgen_var_52);
+ uint64_t cgen_var_56 = (uint64_t)forMarshaling->size;
+ vkStream->putBe64(cgen_var_56);
}
void unmarshal_VkSpecializationMapEntry(
@@ -1846,8 +1906,8 @@
{
marshal_VkSpecializationMapEntry(vkStream, (const VkSpecializationMapEntry*)(forMarshaling->pMapEntries + i));
}
- uint64_t cgen_var_54 = (uint64_t)forMarshaling->dataSize;
- vkStream->putBe64(cgen_var_54);
+ uint64_t cgen_var_58 = (uint64_t)forMarshaling->dataSize;
+ vkStream->putBe64(cgen_var_58);
vkStream->write((const void*)forMarshaling->pData, forMarshaling->dataSize * sizeof(const uint8_t));
}
@@ -1878,13 +1938,13 @@
}
vkStream->write((VkPipelineShaderStageCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineShaderStageCreateFlags));
vkStream->write((VkShaderStageFlagBits*)&forMarshaling->stage, sizeof(VkShaderStageFlagBits));
- uint64_t cgen_var_56;
- vkStream->handleMapping()->mapHandles_VkShaderModule_u64(&forMarshaling->module, &cgen_var_56, 1);
- vkStream->write((uint64_t*)&cgen_var_56, 1 * 8);
+ uint64_t cgen_var_60;
+ vkStream->handleMapping()->mapHandles_VkShaderModule_u64(&forMarshaling->module, &cgen_var_60, 1);
+ vkStream->write((uint64_t*)&cgen_var_60, 1 * 8);
vkStream->putString(forMarshaling->pName);
// WARNING PTR CHECK
- uint64_t cgen_var_57 = (uint64_t)(uintptr_t)forMarshaling->pSpecializationInfo;
- vkStream->putBe64(cgen_var_57);
+ uint64_t cgen_var_61 = (uint64_t)(uintptr_t)forMarshaling->pSpecializationInfo;
+ vkStream->putBe64(cgen_var_61);
if (forMarshaling->pSpecializationInfo)
{
marshal_VkSpecializationInfo(vkStream, (const VkSpecializationInfo*)(forMarshaling->pSpecializationInfo));
@@ -1906,9 +1966,9 @@
}
vkStream->read((VkPipelineShaderStageCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineShaderStageCreateFlags));
vkStream->read((VkShaderStageFlagBits*)&forUnmarshaling->stage, sizeof(VkShaderStageFlagBits));
- uint64_t cgen_var_58;
- vkStream->read((uint64_t*)&cgen_var_58, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkShaderModule(&cgen_var_58, (VkShaderModule*)&forUnmarshaling->module, 1);
+ uint64_t cgen_var_62;
+ vkStream->read((uint64_t*)&cgen_var_62, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkShaderModule(&cgen_var_62, (VkShaderModule*)&forUnmarshaling->module, 1);
vkStream->loadStringInPlace((char**)&forUnmarshaling->pName);
// WARNING PTR CHECK
const VkSpecializationInfo* check_pSpecializationInfo;
@@ -2167,8 +2227,8 @@
vkStream->write((VkPipelineViewportStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineViewportStateCreateFlags));
vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_60 = (uint64_t)(uintptr_t)forMarshaling->pViewports;
- vkStream->putBe64(cgen_var_60);
+ uint64_t cgen_var_64 = (uint64_t)(uintptr_t)forMarshaling->pViewports;
+ vkStream->putBe64(cgen_var_64);
if (forMarshaling->pViewports)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
@@ -2178,8 +2238,8 @@
}
vkStream->write((uint32_t*)&forMarshaling->scissorCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_61 = (uint64_t)(uintptr_t)forMarshaling->pScissors;
- vkStream->putBe64(cgen_var_61);
+ uint64_t cgen_var_65 = (uint64_t)(uintptr_t)forMarshaling->pScissors;
+ vkStream->putBe64(cgen_var_65);
if (forMarshaling->pScissors)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->scissorCount; ++i)
@@ -2303,8 +2363,8 @@
vkStream->write((VkBool32*)&forMarshaling->sampleShadingEnable, sizeof(VkBool32));
vkStream->write((float*)&forMarshaling->minSampleShading, sizeof(float));
// WARNING PTR CHECK
- uint64_t cgen_var_64 = (uint64_t)(uintptr_t)forMarshaling->pSampleMask;
- vkStream->putBe64(cgen_var_64);
+ uint64_t cgen_var_68 = (uint64_t)(uintptr_t)forMarshaling->pSampleMask;
+ vkStream->putBe64(cgen_var_68);
if (forMarshaling->pSampleMask)
{
vkStream->write((const VkSampleMask*)forMarshaling->pSampleMask, (((forMarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
@@ -2551,58 +2611,58 @@
marshal_VkPipelineVertexInputStateCreateInfo(vkStream, (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState));
marshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, (const VkPipelineInputAssemblyStateCreateInfo*)(forMarshaling->pInputAssemblyState));
// WARNING PTR CHECK
- uint64_t cgen_var_66 = (uint64_t)(uintptr_t)forMarshaling->pTessellationState;
- vkStream->putBe64(cgen_var_66);
+ uint64_t cgen_var_70 = (uint64_t)(uintptr_t)forMarshaling->pTessellationState;
+ vkStream->putBe64(cgen_var_70);
if (forMarshaling->pTessellationState)
{
marshal_VkPipelineTessellationStateCreateInfo(vkStream, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState));
}
// WARNING PTR CHECK
- uint64_t cgen_var_67 = (uint64_t)(uintptr_t)forMarshaling->pViewportState;
- vkStream->putBe64(cgen_var_67);
+ uint64_t cgen_var_71 = (uint64_t)(uintptr_t)forMarshaling->pViewportState;
+ vkStream->putBe64(cgen_var_71);
if (forMarshaling->pViewportState)
{
marshal_VkPipelineViewportStateCreateInfo(vkStream, (const VkPipelineViewportStateCreateInfo*)(forMarshaling->pViewportState));
}
marshal_VkPipelineRasterizationStateCreateInfo(vkStream, (const VkPipelineRasterizationStateCreateInfo*)(forMarshaling->pRasterizationState));
// WARNING PTR CHECK
- uint64_t cgen_var_68 = (uint64_t)(uintptr_t)forMarshaling->pMultisampleState;
- vkStream->putBe64(cgen_var_68);
+ uint64_t cgen_var_72 = (uint64_t)(uintptr_t)forMarshaling->pMultisampleState;
+ vkStream->putBe64(cgen_var_72);
if (forMarshaling->pMultisampleState)
{
marshal_VkPipelineMultisampleStateCreateInfo(vkStream, (const VkPipelineMultisampleStateCreateInfo*)(forMarshaling->pMultisampleState));
}
// WARNING PTR CHECK
- uint64_t cgen_var_69 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilState;
- vkStream->putBe64(cgen_var_69);
+ uint64_t cgen_var_73 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilState;
+ vkStream->putBe64(cgen_var_73);
if (forMarshaling->pDepthStencilState)
{
marshal_VkPipelineDepthStencilStateCreateInfo(vkStream, (const VkPipelineDepthStencilStateCreateInfo*)(forMarshaling->pDepthStencilState));
}
// WARNING PTR CHECK
- uint64_t cgen_var_70 = (uint64_t)(uintptr_t)forMarshaling->pColorBlendState;
- vkStream->putBe64(cgen_var_70);
+ uint64_t cgen_var_74 = (uint64_t)(uintptr_t)forMarshaling->pColorBlendState;
+ vkStream->putBe64(cgen_var_74);
if (forMarshaling->pColorBlendState)
{
marshal_VkPipelineColorBlendStateCreateInfo(vkStream, (const VkPipelineColorBlendStateCreateInfo*)(forMarshaling->pColorBlendState));
}
// WARNING PTR CHECK
- uint64_t cgen_var_71 = (uint64_t)(uintptr_t)forMarshaling->pDynamicState;
- vkStream->putBe64(cgen_var_71);
+ uint64_t cgen_var_75 = (uint64_t)(uintptr_t)forMarshaling->pDynamicState;
+ vkStream->putBe64(cgen_var_75);
if (forMarshaling->pDynamicState)
{
marshal_VkPipelineDynamicStateCreateInfo(vkStream, (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState));
}
- uint64_t cgen_var_72;
- vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_72, 1);
- vkStream->write((uint64_t*)&cgen_var_72, 1 * 8);
- uint64_t cgen_var_73;
- vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_73, 1);
- vkStream->write((uint64_t*)&cgen_var_73, 1 * 8);
+ 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);
vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
- uint64_t cgen_var_74;
- vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle, &cgen_var_74, 1);
- vkStream->write((uint64_t*)&cgen_var_74, 1 * 8);
+ 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);
vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
}
@@ -2694,16 +2754,16 @@
}
unmarshal_VkPipelineDynamicStateCreateInfo(vkStream, (VkPipelineDynamicStateCreateInfo*)(forUnmarshaling->pDynamicState));
}
- uint64_t cgen_var_81;
- vkStream->read((uint64_t*)&cgen_var_81, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_81, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
- uint64_t cgen_var_82;
- vkStream->read((uint64_t*)&cgen_var_82, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_82, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+ 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);
vkStream->read((uint32_t*)&forUnmarshaling->subpass, sizeof(uint32_t));
- uint64_t cgen_var_83;
- vkStream->read((uint64_t*)&cgen_var_83, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_83, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
+ 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);
vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
}
@@ -2721,12 +2781,12 @@
}
vkStream->write((VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
marshal_VkPipelineShaderStageCreateInfo(vkStream, (VkPipelineShaderStageCreateInfo*)(&forMarshaling->stage));
- uint64_t cgen_var_84;
- vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_84, 1);
- vkStream->write((uint64_t*)&cgen_var_84, 1 * 8);
- uint64_t cgen_var_85;
- vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle, &cgen_var_85, 1);
- vkStream->write((uint64_t*)&cgen_var_85, 1 * 8);
+ 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);
vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
}
@@ -2745,12 +2805,12 @@
}
vkStream->read((VkPipelineCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCreateFlags));
unmarshal_VkPipelineShaderStageCreateInfo(vkStream, (VkPipelineShaderStageCreateInfo*)(&forUnmarshaling->stage));
- uint64_t cgen_var_86;
- vkStream->read((uint64_t*)&cgen_var_86, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_86, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
- 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_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);
vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
}
@@ -2788,10 +2848,10 @@
vkStream->write((uint32_t*)&forMarshaling->setLayoutCount, sizeof(uint32_t));
if (forMarshaling->setLayoutCount)
{
- uint64_t* cgen_var_88;
- vkStream->alloc((void**)&cgen_var_88, forMarshaling->setLayoutCount * 8);
- vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(forMarshaling->pSetLayouts, cgen_var_88, forMarshaling->setLayoutCount);
- vkStream->write((uint64_t*)cgen_var_88, forMarshaling->setLayoutCount * 8);
+ 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);
}
vkStream->write((uint32_t*)&forMarshaling->pushConstantRangeCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)forMarshaling->pushConstantRangeCount; ++i)
@@ -2817,10 +2877,10 @@
vkStream->read((uint32_t*)&forUnmarshaling->setLayoutCount, sizeof(uint32_t));
if (forUnmarshaling->setLayoutCount)
{
- uint64_t* cgen_var_89;
- vkStream->alloc((void**)&cgen_var_89, forUnmarshaling->setLayoutCount * 8);
- vkStream->read((uint64_t*)cgen_var_89, forUnmarshaling->setLayoutCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(cgen_var_89, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts, 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);
}
vkStream->read((uint32_t*)&forUnmarshaling->pushConstantRangeCount, sizeof(uint32_t));
for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pushConstantRangeCount; ++i)
@@ -2899,16 +2959,16 @@
vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
vkStream->write((VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
// WARNING PTR CHECK
- uint64_t cgen_var_90 = (uint64_t)(uintptr_t)forMarshaling->pImmutableSamplers;
- vkStream->putBe64(cgen_var_90);
+ uint64_t cgen_var_94 = (uint64_t)(uintptr_t)forMarshaling->pImmutableSamplers;
+ vkStream->putBe64(cgen_var_94);
if (forMarshaling->pImmutableSamplers)
{
if (forMarshaling->descriptorCount)
{
- uint64_t* cgen_var_91;
- vkStream->alloc((void**)&cgen_var_91, forMarshaling->descriptorCount * 8);
- vkStream->handleMapping()->mapHandles_VkSampler_u64(forMarshaling->pImmutableSamplers, cgen_var_91, forMarshaling->descriptorCount);
- vkStream->write((uint64_t*)cgen_var_91, forMarshaling->descriptorCount * 8);
+ 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);
}
}
}
@@ -2932,10 +2992,10 @@
}
if (forUnmarshaling->descriptorCount)
{
- uint64_t* cgen_var_93;
- vkStream->alloc((void**)&cgen_var_93, forUnmarshaling->descriptorCount * 8);
- vkStream->read((uint64_t*)cgen_var_93, forUnmarshaling->descriptorCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSampler(cgen_var_93, (VkSampler*)forUnmarshaling->pImmutableSamplers, 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);
}
}
}
@@ -3052,16 +3112,16 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_94;
- vkStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&forMarshaling->descriptorPool, &cgen_var_94, 1);
- vkStream->write((uint64_t*)&cgen_var_94, 1 * 8);
+ 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);
vkStream->write((uint32_t*)&forMarshaling->descriptorSetCount, sizeof(uint32_t));
if (forMarshaling->descriptorSetCount)
{
- uint64_t* cgen_var_95;
- vkStream->alloc((void**)&cgen_var_95, forMarshaling->descriptorSetCount * 8);
- vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(forMarshaling->pSetLayouts, cgen_var_95, forMarshaling->descriptorSetCount);
- vkStream->write((uint64_t*)cgen_var_95, forMarshaling->descriptorSetCount * 8);
+ 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);
}
}
@@ -3078,16 +3138,16 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_96;
- vkStream->read((uint64_t*)&cgen_var_96, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_96, (VkDescriptorPool*)&forUnmarshaling->descriptorPool, 1);
+ 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);
vkStream->read((uint32_t*)&forUnmarshaling->descriptorSetCount, sizeof(uint32_t));
if (forUnmarshaling->descriptorSetCount)
{
- uint64_t* cgen_var_97;
- vkStream->alloc((void**)&cgen_var_97, forUnmarshaling->descriptorSetCount * 8);
- vkStream->read((uint64_t*)cgen_var_97, forUnmarshaling->descriptorSetCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(cgen_var_97, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts, 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);
}
}
@@ -3095,12 +3155,12 @@
VulkanStreamGuest* vkStream,
const VkDescriptorImageInfo* forMarshaling)
{
- uint64_t cgen_var_98;
- vkStream->handleMapping()->mapHandles_VkSampler_u64(&forMarshaling->sampler, &cgen_var_98, 1);
- vkStream->write((uint64_t*)&cgen_var_98, 1 * 8);
- uint64_t cgen_var_99;
- vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_99, 1);
- vkStream->write((uint64_t*)&cgen_var_99, 1 * 8);
+ 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);
vkStream->write((VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
}
@@ -3108,12 +3168,12 @@
VulkanStreamGuest* vkStream,
VkDescriptorImageInfo* forUnmarshaling)
{
- uint64_t cgen_var_100;
- vkStream->read((uint64_t*)&cgen_var_100, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_100, (VkSampler*)&forUnmarshaling->sampler, 1);
- uint64_t cgen_var_101;
- vkStream->read((uint64_t*)&cgen_var_101, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_101, (VkImageView*)&forUnmarshaling->imageView, 1);
+ 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);
vkStream->read((VkImageLayout*)&forUnmarshaling->imageLayout, sizeof(VkImageLayout));
}
@@ -3121,9 +3181,9 @@
VulkanStreamGuest* vkStream,
const VkDescriptorBufferInfo* forMarshaling)
{
- uint64_t cgen_var_102;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_102, 1);
- vkStream->write((uint64_t*)&cgen_var_102, 1 * 8);
+ 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);
vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->range, sizeof(VkDeviceSize));
}
@@ -3132,9 +3192,9 @@
VulkanStreamGuest* vkStream,
VkDescriptorBufferInfo* forUnmarshaling)
{
- uint64_t cgen_var_103;
- vkStream->read((uint64_t*)&cgen_var_103, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_103, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ 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);
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->range, sizeof(VkDeviceSize));
}
@@ -3151,16 +3211,16 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_104;
- vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_104, 1);
- vkStream->write((uint64_t*)&cgen_var_104, 1 * 8);
+ 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);
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_105 = (uint64_t)(uintptr_t)forMarshaling->pImageInfo;
- vkStream->putBe64(cgen_var_105);
+ uint64_t cgen_var_109 = (uint64_t)(uintptr_t)forMarshaling->pImageInfo;
+ vkStream->putBe64(cgen_var_109);
if (forMarshaling->pImageInfo)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i)
@@ -3169,8 +3229,8 @@
}
}
// WARNING PTR CHECK
- uint64_t cgen_var_106 = (uint64_t)(uintptr_t)forMarshaling->pBufferInfo;
- vkStream->putBe64(cgen_var_106);
+ uint64_t cgen_var_110 = (uint64_t)(uintptr_t)forMarshaling->pBufferInfo;
+ vkStream->putBe64(cgen_var_110);
if (forMarshaling->pBufferInfo)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i)
@@ -3179,16 +3239,16 @@
}
}
// WARNING PTR CHECK
- uint64_t cgen_var_107 = (uint64_t)(uintptr_t)forMarshaling->pTexelBufferView;
- vkStream->putBe64(cgen_var_107);
+ uint64_t cgen_var_111 = (uint64_t)(uintptr_t)forMarshaling->pTexelBufferView;
+ vkStream->putBe64(cgen_var_111);
if (forMarshaling->pTexelBufferView)
{
if (forMarshaling->descriptorCount)
{
- uint64_t* cgen_var_108;
- vkStream->alloc((void**)&cgen_var_108, forMarshaling->descriptorCount * 8);
- vkStream->handleMapping()->mapHandles_VkBufferView_u64(forMarshaling->pTexelBufferView, cgen_var_108, forMarshaling->descriptorCount);
- vkStream->write((uint64_t*)cgen_var_108, forMarshaling->descriptorCount * 8);
+ 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);
}
}
}
@@ -3206,9 +3266,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_109;
- vkStream->read((uint64_t*)&cgen_var_109, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_109, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
+ 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);
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));
@@ -3252,10 +3312,10 @@
}
if (forUnmarshaling->descriptorCount)
{
- uint64_t* cgen_var_113;
- vkStream->alloc((void**)&cgen_var_113, forUnmarshaling->descriptorCount * 8);
- vkStream->read((uint64_t*)cgen_var_113, forUnmarshaling->descriptorCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBufferView(cgen_var_113, (VkBufferView*)forUnmarshaling->pTexelBufferView, 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);
}
}
}
@@ -3272,14 +3332,14 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_114;
- vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->srcSet, &cgen_var_114, 1);
- vkStream->write((uint64_t*)&cgen_var_114, 1 * 8);
+ 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);
vkStream->write((uint32_t*)&forMarshaling->srcBinding, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->srcArrayElement, sizeof(uint32_t));
- uint64_t cgen_var_115;
- vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_115, 1);
- vkStream->write((uint64_t*)&cgen_var_115, 1 * 8);
+ 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);
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));
@@ -3298,14 +3358,14 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_116;
- vkStream->read((uint64_t*)&cgen_var_116, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_116, (VkDescriptorSet*)&forUnmarshaling->srcSet, 1);
+ 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);
vkStream->read((uint32_t*)&forUnmarshaling->srcBinding, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->srcArrayElement, sizeof(uint32_t));
- uint64_t cgen_var_117;
- vkStream->read((uint64_t*)&cgen_var_117, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_117, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
+ 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);
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));
@@ -3324,16 +3384,16 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
vkStream->write((VkFramebufferCreateFlags*)&forMarshaling->flags, sizeof(VkFramebufferCreateFlags));
- uint64_t cgen_var_118;
- vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_118, 1);
- vkStream->write((uint64_t*)&cgen_var_118, 1 * 8);
+ 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);
vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
if (forMarshaling->attachmentCount)
{
- uint64_t* cgen_var_119;
- vkStream->alloc((void**)&cgen_var_119, forMarshaling->attachmentCount * 8);
- vkStream->handleMapping()->mapHandles_VkImageView_u64(forMarshaling->pAttachments, cgen_var_119, forMarshaling->attachmentCount);
- vkStream->write((uint64_t*)cgen_var_119, forMarshaling->attachmentCount * 8);
+ 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);
}
vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
@@ -3354,16 +3414,16 @@
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
vkStream->read((VkFramebufferCreateFlags*)&forUnmarshaling->flags, sizeof(VkFramebufferCreateFlags));
- uint64_t cgen_var_120;
- vkStream->read((uint64_t*)&cgen_var_120, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_120, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+ 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);
vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
if (forUnmarshaling->attachmentCount)
{
- uint64_t* cgen_var_121;
- vkStream->alloc((void**)&cgen_var_121, forUnmarshaling->attachmentCount * 8);
- vkStream->read((uint64_t*)cgen_var_121, forUnmarshaling->attachmentCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImageView(cgen_var_121, (VkImageView*)forUnmarshaling->pAttachments, 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);
}
vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
@@ -3433,8 +3493,8 @@
marshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pColorAttachments + i));
}
// WARNING PTR CHECK
- uint64_t cgen_var_122 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
- vkStream->putBe64(cgen_var_122);
+ uint64_t cgen_var_126 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
+ vkStream->putBe64(cgen_var_126);
if (forMarshaling->pResolveAttachments)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
@@ -3443,8 +3503,8 @@
}
}
// WARNING PTR CHECK
- uint64_t cgen_var_123 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
- vkStream->putBe64(cgen_var_123);
+ uint64_t cgen_var_127 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
+ vkStream->putBe64(cgen_var_127);
if (forMarshaling->pDepthStencilAttachment)
{
marshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pDepthStencilAttachment));
@@ -3630,9 +3690,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_126;
- vkStream->handleMapping()->mapHandles_VkCommandPool_u64(&forMarshaling->commandPool, &cgen_var_126, 1);
- vkStream->write((uint64_t*)&cgen_var_126, 1 * 8);
+ 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);
vkStream->write((VkCommandBufferLevel*)&forMarshaling->level, sizeof(VkCommandBufferLevel));
vkStream->write((uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
}
@@ -3650,9 +3710,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_127;
- vkStream->read((uint64_t*)&cgen_var_127, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkCommandPool(&cgen_var_127, (VkCommandPool*)&forUnmarshaling->commandPool, 1);
+ 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);
vkStream->read((VkCommandBufferLevel*)&forUnmarshaling->level, sizeof(VkCommandBufferLevel));
vkStream->read((uint32_t*)&forUnmarshaling->commandBufferCount, sizeof(uint32_t));
}
@@ -3669,13 +3729,13 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_128;
- vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_128, 1);
- vkStream->write((uint64_t*)&cgen_var_128, 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->subpass, sizeof(uint32_t));
- uint64_t cgen_var_129;
- vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer, &cgen_var_129, 1);
- vkStream->write((uint64_t*)&cgen_var_129, 1 * 8);
+ 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);
vkStream->write((VkBool32*)&forMarshaling->occlusionQueryEnable, sizeof(VkBool32));
vkStream->write((VkQueryControlFlags*)&forMarshaling->queryFlags, sizeof(VkQueryControlFlags));
vkStream->write((VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
@@ -3694,13 +3754,13 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_130;
- vkStream->read((uint64_t*)&cgen_var_130, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_130, (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->subpass, sizeof(uint32_t));
- uint64_t cgen_var_131;
- vkStream->read((uint64_t*)&cgen_var_131, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_131, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
+ 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);
vkStream->read((VkBool32*)&forUnmarshaling->occlusionQueryEnable, sizeof(VkBool32));
vkStream->read((VkQueryControlFlags*)&forUnmarshaling->queryFlags, sizeof(VkQueryControlFlags));
vkStream->read((VkQueryPipelineStatisticFlags*)&forUnmarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
@@ -3720,8 +3780,8 @@
}
vkStream->write((VkCommandBufferUsageFlags*)&forMarshaling->flags, sizeof(VkCommandBufferUsageFlags));
// WARNING PTR CHECK
- uint64_t cgen_var_132 = (uint64_t)(uintptr_t)forMarshaling->pInheritanceInfo;
- vkStream->putBe64(cgen_var_132);
+ uint64_t cgen_var_136 = (uint64_t)(uintptr_t)forMarshaling->pInheritanceInfo;
+ vkStream->putBe64(cgen_var_136);
if (forMarshaling->pInheritanceInfo)
{
marshal_VkCommandBufferInheritanceInfo(vkStream, (const VkCommandBufferInheritanceInfo*)(forMarshaling->pInheritanceInfo));
@@ -4022,9 +4082,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_134;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_134, 1);
- vkStream->write((uint64_t*)&cgen_var_134, 1 * 8);
+ 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);
vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}
@@ -4046,9 +4106,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_135;
- vkStream->read((uint64_t*)&cgen_var_135, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_135, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ 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);
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}
@@ -4071,9 +4131,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_136;
- vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_136, 1);
- vkStream->write((uint64_t*)&cgen_var_136, 1 * 8);
+ 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);
marshal_VkImageSubresourceRange(vkStream, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
}
@@ -4096,9 +4156,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_137;
- vkStream->read((uint64_t*)&cgen_var_137, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_137, (VkImage*)&forUnmarshaling->image, 1);
+ 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);
unmarshal_VkImageSubresourceRange(vkStream, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
}
@@ -4114,17 +4174,17 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_138;
- vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_138, 1);
- vkStream->write((uint64_t*)&cgen_var_138, 1 * 8);
- uint64_t cgen_var_139;
- vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer, &cgen_var_139, 1);
- vkStream->write((uint64_t*)&cgen_var_139, 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);
+ 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);
marshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->renderArea));
vkStream->write((uint32_t*)&forMarshaling->clearValueCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_140 = (uint64_t)(uintptr_t)forMarshaling->pClearValues;
- vkStream->putBe64(cgen_var_140);
+ uint64_t cgen_var_144 = (uint64_t)(uintptr_t)forMarshaling->pClearValues;
+ vkStream->putBe64(cgen_var_144);
if (forMarshaling->pClearValues)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->clearValueCount; ++i)
@@ -4147,12 +4207,12 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_141;
- vkStream->read((uint64_t*)&cgen_var_141, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_141, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
- uint64_t cgen_var_142;
- vkStream->read((uint64_t*)&cgen_var_142, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_142, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
+ 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);
unmarshal_VkRect2D(vkStream, (VkRect2D*)(&forUnmarshaling->renderArea));
vkStream->read((uint32_t*)&forUnmarshaling->clearValueCount, sizeof(uint32_t));
// WARNING PTR CHECK
@@ -4340,12 +4400,12 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_144;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_144, 1);
- vkStream->write((uint64_t*)&cgen_var_144, 1 * 8);
- uint64_t cgen_var_145;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_145, 1);
- vkStream->write((uint64_t*)&cgen_var_145, 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);
+ 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);
vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
}
@@ -4362,12 +4422,12 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_146;
- vkStream->read((uint64_t*)&cgen_var_146, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_146, (VkBuffer*)&forUnmarshaling->buffer, 1);
- uint64_t cgen_var_147;
- vkStream->read((uint64_t*)&cgen_var_147, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_147, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ 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);
vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
}
@@ -4383,12 +4443,12 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_148;
- vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &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_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);
vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
}
@@ -4405,12 +4465,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_VkImage(&cgen_var_150, (VkImage*)&forUnmarshaling->image, 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_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);
vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
}
@@ -4496,12 +4556,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_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_153, 1);
- vkStream->write((uint64_t*)&cgen_var_153, 1 * 8);
+ 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);
}
void unmarshal_VkMemoryDedicatedAllocateInfo(
@@ -4517,12 +4577,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_VkBuffer(&cgen_var_155, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ 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);
}
void marshal_VkMemoryAllocateFlagsInfo(
@@ -4830,10 +4890,10 @@
vkStream->write((uint32_t*)&forMarshaling->physicalDeviceCount, sizeof(uint32_t));
if (forMarshaling->physicalDeviceCount)
{
- uint64_t* cgen_var_156;
- vkStream->alloc((void**)&cgen_var_156, forMarshaling->physicalDeviceCount * 8);
- vkStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(forMarshaling->pPhysicalDevices, cgen_var_156, forMarshaling->physicalDeviceCount);
- vkStream->write((uint64_t*)cgen_var_156, forMarshaling->physicalDeviceCount * 8);
+ 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);
}
}
@@ -4853,10 +4913,10 @@
vkStream->read((uint32_t*)&forUnmarshaling->physicalDeviceCount, sizeof(uint32_t));
if (forUnmarshaling->physicalDeviceCount)
{
- uint64_t* cgen_var_157;
- vkStream->alloc((void**)&cgen_var_157, forUnmarshaling->physicalDeviceCount * 8);
- vkStream->read((uint64_t*)cgen_var_157, forUnmarshaling->physicalDeviceCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPhysicalDevice(cgen_var_157, (VkPhysicalDevice*)forUnmarshaling->pPhysicalDevices, 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);
}
}
@@ -4872,9 +4932,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- 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_162;
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_162, 1);
+ vkStream->write((uint64_t*)&cgen_var_162, 1 * 8);
}
void unmarshal_VkBufferMemoryRequirementsInfo2(
@@ -4890,9 +4950,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- 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_163;
+ vkStream->read((uint64_t*)&cgen_var_163, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_163, (VkBuffer*)&forUnmarshaling->buffer, 1);
}
void marshal_VkImageMemoryRequirementsInfo2(
@@ -4907,9 +4967,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_160;
- vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_160, 1);
- vkStream->write((uint64_t*)&cgen_var_160, 1 * 8);
+ 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);
}
void unmarshal_VkImageMemoryRequirementsInfo2(
@@ -4925,9 +4985,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_161;
- vkStream->read((uint64_t*)&cgen_var_161, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_161, (VkImage*)&forUnmarshaling->image, 1);
+ 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);
}
void marshal_VkImageSparseMemoryRequirementsInfo2(
@@ -4942,9 +5002,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- 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_166;
+ vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_166, 1);
+ vkStream->write((uint64_t*)&cgen_var_166, 1 * 8);
}
void unmarshal_VkImageSparseMemoryRequirementsInfo2(
@@ -4960,9 +5020,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_VkImage(&cgen_var_163, (VkImage*)&forUnmarshaling->image, 1);
+ 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);
}
void marshal_VkMemoryRequirements2(
@@ -5799,9 +5859,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_164;
- vkStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&forMarshaling->conversion, &cgen_var_164, 1);
- vkStream->write((uint64_t*)&cgen_var_164, 1 * 8);
+ 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);
}
void unmarshal_VkSamplerYcbcrConversionInfo(
@@ -5817,9 +5877,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_VkSamplerYcbcrConversion(&cgen_var_165, (VkSamplerYcbcrConversion*)&forUnmarshaling->conversion, 1);
+ 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);
}
void marshal_VkBindImagePlaneMemoryInfo(
@@ -5954,10 +6014,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_166 = (uint64_t)forMarshaling->offset;
- vkStream->putBe64(cgen_var_166);
- uint64_t cgen_var_167 = (uint64_t)forMarshaling->stride;
- vkStream->putBe64(cgen_var_167);
+ 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);
}
void unmarshal_VkDescriptorUpdateTemplateEntry(
@@ -5991,13 +6051,13 @@
marshal_VkDescriptorUpdateTemplateEntry(vkStream, (const VkDescriptorUpdateTemplateEntry*)(forMarshaling->pDescriptorUpdateEntries + i));
}
vkStream->write((VkDescriptorUpdateTemplateType*)&forMarshaling->templateType, sizeof(VkDescriptorUpdateTemplateType));
- uint64_t cgen_var_170;
- vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&forMarshaling->descriptorSetLayout, &cgen_var_170, 1);
- vkStream->write((uint64_t*)&cgen_var_170, 1 * 8);
+ 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);
vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
- uint64_t cgen_var_171;
- vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_171, 1);
- vkStream->write((uint64_t*)&cgen_var_171, 1 * 8);
+ 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);
vkStream->write((uint32_t*)&forMarshaling->set, sizeof(uint32_t));
}
@@ -6021,13 +6081,13 @@
unmarshal_VkDescriptorUpdateTemplateEntry(vkStream, (VkDescriptorUpdateTemplateEntry*)(forUnmarshaling->pDescriptorUpdateEntries + i));
}
vkStream->read((VkDescriptorUpdateTemplateType*)&forUnmarshaling->templateType, sizeof(VkDescriptorUpdateTemplateType));
- uint64_t cgen_var_172;
- vkStream->read((uint64_t*)&cgen_var_172, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(&cgen_var_172, (VkDescriptorSetLayout*)&forUnmarshaling->descriptorSetLayout, 1);
+ 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);
vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
- uint64_t cgen_var_173;
- vkStream->read((uint64_t*)&cgen_var_173, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_173, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
+ 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);
vkStream->read((uint32_t*)&forUnmarshaling->set, sizeof(uint32_t));
}
@@ -6663,9 +6723,9 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
vkStream->write((VkSwapchainCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkSwapchainCreateFlagsKHR));
- uint64_t cgen_var_174;
- vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_174, 1);
- vkStream->write((uint64_t*)&cgen_var_174, 1 * 8);
+ 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);
vkStream->write((uint32_t*)&forMarshaling->minImageCount, sizeof(uint32_t));
vkStream->write((VkFormat*)&forMarshaling->imageFormat, sizeof(VkFormat));
vkStream->write((VkColorSpaceKHR*)&forMarshaling->imageColorSpace, sizeof(VkColorSpaceKHR));
@@ -6675,8 +6735,8 @@
vkStream->write((VkSharingMode*)&forMarshaling->imageSharingMode, sizeof(VkSharingMode));
vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_175 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
- vkStream->putBe64(cgen_var_175);
+ uint64_t cgen_var_179 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
+ vkStream->putBe64(cgen_var_179);
if (forMarshaling->pQueueFamilyIndices)
{
vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
@@ -6685,9 +6745,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_176;
- vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->oldSwapchain, &cgen_var_176, 1);
- vkStream->write((uint64_t*)&cgen_var_176, 1 * 8);
+ 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);
}
void unmarshal_VkSwapchainCreateInfoKHR(
@@ -6704,9 +6764,9 @@
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
vkStream->read((VkSwapchainCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkSwapchainCreateFlagsKHR));
- uint64_t cgen_var_177;
- vkStream->read((uint64_t*)&cgen_var_177, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_177, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
+ 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);
vkStream->read((uint32_t*)&forUnmarshaling->minImageCount, sizeof(uint32_t));
vkStream->read((VkFormat*)&forUnmarshaling->imageFormat, sizeof(VkFormat));
vkStream->read((VkColorSpaceKHR*)&forUnmarshaling->imageColorSpace, sizeof(VkColorSpaceKHR));
@@ -6730,9 +6790,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_179;
- vkStream->read((uint64_t*)&cgen_var_179, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_179, (VkSwapchainKHR*)&forUnmarshaling->oldSwapchain, 1);
+ 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);
}
void marshal_VkPresentInfoKHR(
@@ -6750,23 +6810,23 @@
vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
if (forMarshaling->waitSemaphoreCount)
{
- uint64_t* cgen_var_180;
- vkStream->alloc((void**)&cgen_var_180, forMarshaling->waitSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pWaitSemaphores, cgen_var_180, forMarshaling->waitSemaphoreCount);
- vkStream->write((uint64_t*)cgen_var_180, forMarshaling->waitSemaphoreCount * 8);
+ 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);
}
vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
if (forMarshaling->swapchainCount)
{
- uint64_t* cgen_var_181;
- vkStream->alloc((void**)&cgen_var_181, forMarshaling->swapchainCount * 8);
- vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(forMarshaling->pSwapchains, cgen_var_181, forMarshaling->swapchainCount);
- vkStream->write((uint64_t*)cgen_var_181, forMarshaling->swapchainCount * 8);
+ 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);
}
vkStream->write((const uint32_t*)forMarshaling->pImageIndices, forMarshaling->swapchainCount * sizeof(const uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_182 = (uint64_t)(uintptr_t)forMarshaling->pResults;
- vkStream->putBe64(cgen_var_182);
+ uint64_t cgen_var_186 = (uint64_t)(uintptr_t)forMarshaling->pResults;
+ vkStream->putBe64(cgen_var_186);
if (forMarshaling->pResults)
{
vkStream->write((VkResult*)forMarshaling->pResults, forMarshaling->swapchainCount * sizeof(VkResult));
@@ -6789,18 +6849,18 @@
vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
if (forUnmarshaling->waitSemaphoreCount)
{
- uint64_t* cgen_var_183;
- vkStream->alloc((void**)&cgen_var_183, forUnmarshaling->waitSemaphoreCount * 8);
- vkStream->read((uint64_t*)cgen_var_183, forUnmarshaling->waitSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_183, (VkSemaphore*)forUnmarshaling->pWaitSemaphores, 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);
}
vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
if (forUnmarshaling->swapchainCount)
{
- uint64_t* cgen_var_184;
- vkStream->alloc((void**)&cgen_var_184, forUnmarshaling->swapchainCount * 8);
- vkStream->read((uint64_t*)cgen_var_184, forUnmarshaling->swapchainCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(cgen_var_184, (VkSwapchainKHR*)forUnmarshaling->pSwapchains, 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);
}
vkStream->read((uint32_t*)forUnmarshaling->pImageIndices, forUnmarshaling->swapchainCount * sizeof(const uint32_t));
// WARNING PTR CHECK
@@ -6828,9 +6888,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_186;
- vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_186, 1);
- vkStream->write((uint64_t*)&cgen_var_186, 1 * 8);
+ 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);
}
void unmarshal_VkImageSwapchainCreateInfoKHR(
@@ -6846,9 +6906,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_187;
- vkStream->read((uint64_t*)&cgen_var_187, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_187, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
+ 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);
}
void marshal_VkBindImageMemorySwapchainInfoKHR(
@@ -6863,9 +6923,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_188;
- vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_188, 1);
- vkStream->write((uint64_t*)&cgen_var_188, 1 * 8);
+ 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);
vkStream->write((uint32_t*)&forMarshaling->imageIndex, sizeof(uint32_t));
}
@@ -6882,9 +6942,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_189;
- vkStream->read((uint64_t*)&cgen_var_189, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_189, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 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->swapchain, 1);
vkStream->read((uint32_t*)&forUnmarshaling->imageIndex, sizeof(uint32_t));
}
@@ -6900,16 +6960,16 @@
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_194;
+ vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_194, 1);
+ vkStream->write((uint64_t*)&cgen_var_194, 1 * 8);
vkStream->write((uint64_t*)&forMarshaling->timeout, sizeof(uint64_t));
- uint64_t cgen_var_191;
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_191, 1);
- vkStream->write((uint64_t*)&cgen_var_191, 1 * 8);
- uint64_t cgen_var_192;
- vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_192, 1);
- vkStream->write((uint64_t*)&cgen_var_192, 1 * 8);
+ 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);
vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
}
@@ -6926,16 +6986,16 @@
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_197;
+ vkStream->read((uint64_t*)&cgen_var_197, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_197, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
vkStream->read((uint64_t*)&forUnmarshaling->timeout, sizeof(uint64_t));
- uint64_t cgen_var_194;
- vkStream->read((uint64_t*)&cgen_var_194, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_194, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
- uint64_t cgen_var_195;
- vkStream->read((uint64_t*)&cgen_var_195, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_195, (VkFence*)&forUnmarshaling->fence, 1);
+ 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);
vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
}
@@ -7044,9 +7104,9 @@
VulkanStreamGuest* vkStream,
const VkDisplayPropertiesKHR* forMarshaling)
{
- uint64_t cgen_var_196;
- vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->display, &cgen_var_196, 1);
- vkStream->write((uint64_t*)&cgen_var_196, 1 * 8);
+ 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);
vkStream->putString(forMarshaling->displayName);
marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->physicalDimensions));
marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->physicalResolution));
@@ -7059,9 +7119,9 @@
VulkanStreamGuest* vkStream,
VkDisplayPropertiesKHR* forUnmarshaling)
{
- uint64_t cgen_var_197;
- vkStream->read((uint64_t*)&cgen_var_197, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_197, (VkDisplayKHR*)&forUnmarshaling->display, 1);
+ 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);
vkStream->loadStringInPlace((char**)&forUnmarshaling->displayName);
unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->physicalDimensions));
unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->physicalResolution));
@@ -7090,9 +7150,9 @@
VulkanStreamGuest* vkStream,
const VkDisplayModePropertiesKHR* forMarshaling)
{
- uint64_t cgen_var_198;
- vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode, &cgen_var_198, 1);
- vkStream->write((uint64_t*)&cgen_var_198, 1 * 8);
+ 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);
marshal_VkDisplayModeParametersKHR(vkStream, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters));
}
@@ -7100,9 +7160,9 @@
VulkanStreamGuest* vkStream,
VkDisplayModePropertiesKHR* forUnmarshaling)
{
- uint64_t cgen_var_199;
- vkStream->read((uint64_t*)&cgen_var_199, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_199, (VkDisplayModeKHR*)&forUnmarshaling->displayMode, 1);
+ 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);
unmarshal_VkDisplayModeParametersKHR(vkStream, (VkDisplayModeParametersKHR*)(&forUnmarshaling->parameters));
}
@@ -7173,9 +7233,9 @@
VulkanStreamGuest* vkStream,
const VkDisplayPlanePropertiesKHR* forMarshaling)
{
- uint64_t cgen_var_200;
- vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->currentDisplay, &cgen_var_200, 1);
- vkStream->write((uint64_t*)&cgen_var_200, 1 * 8);
+ 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);
vkStream->write((uint32_t*)&forMarshaling->currentStackIndex, sizeof(uint32_t));
}
@@ -7183,9 +7243,9 @@
VulkanStreamGuest* vkStream,
VkDisplayPlanePropertiesKHR* 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->currentDisplay, 1);
+ 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);
vkStream->read((uint32_t*)&forUnmarshaling->currentStackIndex, sizeof(uint32_t));
}
@@ -7202,9 +7262,9 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
vkStream->write((VkDisplaySurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkDisplaySurfaceCreateFlagsKHR));
- 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_206;
+ vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode, &cgen_var_206, 1);
+ vkStream->write((uint64_t*)&cgen_var_206, 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));
@@ -7227,9 +7287,9 @@
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
vkStream->read((VkDisplaySurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkDisplaySurfaceCreateFlagsKHR));
- 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_207;
+ vkStream->read((uint64_t*)&cgen_var_207, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_207, (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));
@@ -7291,8 +7351,8 @@
}
vkStream->write((VkXlibSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkXlibSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
- uint64_t cgen_var_204 = (uint64_t)(uintptr_t)forMarshaling->dpy;
- vkStream->putBe64(cgen_var_204);
+ uint64_t cgen_var_208 = (uint64_t)(uintptr_t)forMarshaling->dpy;
+ vkStream->putBe64(cgen_var_208);
if (forMarshaling->dpy)
{
vkStream->write((Display*)forMarshaling->dpy, sizeof(Display));
@@ -7344,8 +7404,8 @@
}
vkStream->write((VkXcbSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkXcbSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
- uint64_t cgen_var_206 = (uint64_t)(uintptr_t)forMarshaling->connection;
- vkStream->putBe64(cgen_var_206);
+ uint64_t cgen_var_210 = (uint64_t)(uintptr_t)forMarshaling->connection;
+ vkStream->putBe64(cgen_var_210);
if (forMarshaling->connection)
{
vkStream->write((xcb_connection_t*)forMarshaling->connection, sizeof(xcb_connection_t));
@@ -7397,15 +7457,15 @@
}
vkStream->write((VkWaylandSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkWaylandSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
- uint64_t cgen_var_208 = (uint64_t)(uintptr_t)forMarshaling->display;
- vkStream->putBe64(cgen_var_208);
+ uint64_t cgen_var_212 = (uint64_t)(uintptr_t)forMarshaling->display;
+ vkStream->putBe64(cgen_var_212);
if (forMarshaling->display)
{
vkStream->write((wl_display*)forMarshaling->display, sizeof(wl_display));
}
// WARNING PTR CHECK
- uint64_t cgen_var_209 = (uint64_t)(uintptr_t)forMarshaling->surface;
- vkStream->putBe64(cgen_var_209);
+ uint64_t cgen_var_213 = (uint64_t)(uintptr_t)forMarshaling->surface;
+ vkStream->putBe64(cgen_var_213);
if (forMarshaling->surface)
{
vkStream->write((wl_surface*)forMarshaling->surface, sizeof(wl_surface));
@@ -7466,15 +7526,15 @@
}
vkStream->write((VkMirSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkMirSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
- uint64_t cgen_var_212 = (uint64_t)(uintptr_t)forMarshaling->connection;
- vkStream->putBe64(cgen_var_212);
+ uint64_t cgen_var_216 = (uint64_t)(uintptr_t)forMarshaling->connection;
+ vkStream->putBe64(cgen_var_216);
if (forMarshaling->connection)
{
vkStream->write((MirConnection*)forMarshaling->connection, sizeof(MirConnection));
}
// WARNING PTR CHECK
- uint64_t cgen_var_213 = (uint64_t)(uintptr_t)forMarshaling->mirSurface;
- vkStream->putBe64(cgen_var_213);
+ uint64_t cgen_var_217 = (uint64_t)(uintptr_t)forMarshaling->mirSurface;
+ vkStream->putBe64(cgen_var_217);
if (forMarshaling->mirSurface)
{
vkStream->write((MirSurface*)forMarshaling->mirSurface, sizeof(MirSurface));
@@ -7535,8 +7595,8 @@
}
vkStream->write((VkAndroidSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkAndroidSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
- uint64_t cgen_var_216 = (uint64_t)(uintptr_t)forMarshaling->window;
- vkStream->putBe64(cgen_var_216);
+ uint64_t cgen_var_220 = (uint64_t)(uintptr_t)forMarshaling->window;
+ vkStream->putBe64(cgen_var_220);
if (forMarshaling->window)
{
vkStream->write((ANativeWindow*)forMarshaling->window, sizeof(ANativeWindow));
@@ -7675,8 +7735,8 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
// WARNING PTR CHECK
- uint64_t cgen_var_218 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
- vkStream->putBe64(cgen_var_218);
+ uint64_t cgen_var_222 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+ vkStream->putBe64(cgen_var_222);
if (forMarshaling->pAttributes)
{
vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
@@ -7756,9 +7816,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_220;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_220, 1);
- vkStream->write((uint64_t*)&cgen_var_220, 1 * 8);
+ 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);
vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
}
@@ -7775,9 +7835,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_221;
- vkStream->read((uint64_t*)&cgen_var_221, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_221, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ 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);
vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
}
@@ -7859,9 +7919,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_222;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_222, 1);
- vkStream->write((uint64_t*)&cgen_var_222, 1 * 8);
+ 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);
vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
}
@@ -7878,9 +7938,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_223;
- vkStream->read((uint64_t*)&cgen_var_223, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_223, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ 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);
vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
}
@@ -7901,20 +7961,20 @@
vkStream->write((uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
if (forMarshaling->acquireCount)
{
- uint64_t* cgen_var_224;
- vkStream->alloc((void**)&cgen_var_224, forMarshaling->acquireCount * 8);
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pAcquireSyncs, cgen_var_224, forMarshaling->acquireCount);
- vkStream->write((uint64_t*)cgen_var_224, forMarshaling->acquireCount * 8);
+ 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);
}
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_225;
- vkStream->alloc((void**)&cgen_var_225, forMarshaling->releaseCount * 8);
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pReleaseSyncs, cgen_var_225, forMarshaling->releaseCount);
- vkStream->write((uint64_t*)cgen_var_225, forMarshaling->releaseCount * 8);
+ 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);
}
vkStream->write((const uint64_t*)forMarshaling->pReleaseKeys, forMarshaling->releaseCount * sizeof(const uint64_t));
}
@@ -7935,20 +7995,20 @@
vkStream->read((uint32_t*)&forUnmarshaling->acquireCount, sizeof(uint32_t));
if (forUnmarshaling->acquireCount)
{
- uint64_t* cgen_var_226;
- vkStream->alloc((void**)&cgen_var_226, forUnmarshaling->acquireCount * 8);
- vkStream->read((uint64_t*)cgen_var_226, forUnmarshaling->acquireCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_226, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs, 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);
}
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_227;
- vkStream->alloc((void**)&cgen_var_227, forUnmarshaling->releaseCount * 8);
- vkStream->read((uint64_t*)cgen_var_227, forUnmarshaling->releaseCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_227, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs, 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);
}
vkStream->read((uint64_t*)forUnmarshaling->pReleaseKeys, forUnmarshaling->releaseCount * sizeof(const uint64_t));
}
@@ -7971,9 +8031,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_228;
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_228, 1);
- vkStream->write((uint64_t*)&cgen_var_228, 1 * 8);
+ 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);
vkStream->write((VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
@@ -7993,9 +8053,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_229;
- vkStream->read((uint64_t*)&cgen_var_229, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_229, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ 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);
vkStream->read((VkSemaphoreImportFlags*)&forUnmarshaling->flags, sizeof(VkSemaphoreImportFlags));
vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
@@ -8015,8 +8075,8 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
// WARNING PTR CHECK
- uint64_t cgen_var_230 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
- vkStream->putBe64(cgen_var_230);
+ uint64_t cgen_var_234 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+ vkStream->putBe64(cgen_var_234);
if (forMarshaling->pAttributes)
{
vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
@@ -8067,16 +8127,16 @@
}
vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreValuesCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_232 = (uint64_t)(uintptr_t)forMarshaling->pWaitSemaphoreValues;
- vkStream->putBe64(cgen_var_232);
+ uint64_t cgen_var_236 = (uint64_t)(uintptr_t)forMarshaling->pWaitSemaphoreValues;
+ vkStream->putBe64(cgen_var_236);
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_233 = (uint64_t)(uintptr_t)forMarshaling->pSignalSemaphoreValues;
- vkStream->putBe64(cgen_var_233);
+ uint64_t cgen_var_237 = (uint64_t)(uintptr_t)forMarshaling->pSignalSemaphoreValues;
+ vkStream->putBe64(cgen_var_237);
if (forMarshaling->pSignalSemaphoreValues)
{
vkStream->write((const uint64_t*)forMarshaling->pSignalSemaphoreValues, forMarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
@@ -8134,9 +8194,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_236;
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_236, 1);
- vkStream->write((uint64_t*)&cgen_var_236, 1 * 8);
+ 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);
vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}
@@ -8153,9 +8213,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_237;
- vkStream->read((uint64_t*)&cgen_var_237, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_237, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ 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);
vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}
@@ -8173,9 +8233,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_238;
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_238, 1);
- vkStream->write((uint64_t*)&cgen_var_238, 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((int*)&forMarshaling->fd, sizeof(int));
@@ -8194,9 +8254,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_239;
- vkStream->read((uint64_t*)&cgen_var_239, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_239, (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((int*)&forUnmarshaling->fd, sizeof(int));
@@ -8214,9 +8274,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_244;
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_244, 1);
+ vkStream->write((uint64_t*)&cgen_var_244, 1 * 8);
vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}
@@ -8233,9 +8293,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_245;
+ vkStream->read((uint64_t*)&cgen_var_245, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_245, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}
@@ -8300,8 +8360,8 @@
{
vkStream->write((uint32_t*)&forMarshaling->rectangleCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_242 = (uint64_t)(uintptr_t)forMarshaling->pRectangles;
- vkStream->putBe64(cgen_var_242);
+ uint64_t cgen_var_246 = (uint64_t)(uintptr_t)forMarshaling->pRectangles;
+ vkStream->putBe64(cgen_var_246);
if (forMarshaling->pRectangles)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->rectangleCount; ++i)
@@ -8346,8 +8406,8 @@
}
vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_244 = (uint64_t)(uintptr_t)forMarshaling->pRegions;
- vkStream->putBe64(cgen_var_244);
+ uint64_t cgen_var_248 = (uint64_t)(uintptr_t)forMarshaling->pRegions;
+ vkStream->putBe64(cgen_var_248);
if (forMarshaling->pRegions)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i)
@@ -8499,8 +8559,8 @@
marshal_VkAttachmentReference2KHR(vkStream, (const VkAttachmentReference2KHR*)(forMarshaling->pColorAttachments + i));
}
// WARNING PTR CHECK
- uint64_t cgen_var_246 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
- vkStream->putBe64(cgen_var_246);
+ uint64_t cgen_var_250 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
+ vkStream->putBe64(cgen_var_250);
if (forMarshaling->pResolveAttachments)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
@@ -8509,8 +8569,8 @@
}
}
// WARNING PTR CHECK
- uint64_t cgen_var_247 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
- vkStream->putBe64(cgen_var_247);
+ uint64_t cgen_var_251 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
+ vkStream->putBe64(cgen_var_251);
if (forMarshaling->pDepthStencilAttachment)
{
marshal_VkAttachmentReference2KHR(vkStream, (const VkAttachmentReference2KHR*)(forMarshaling->pDepthStencilAttachment));
@@ -8795,9 +8855,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_250;
- vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_250, 1);
- vkStream->write((uint64_t*)&cgen_var_250, 1 * 8);
+ 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);
vkStream->write((VkFenceImportFlags*)&forMarshaling->flags, sizeof(VkFenceImportFlags));
vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
@@ -8817,9 +8877,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_251;
- vkStream->read((uint64_t*)&cgen_var_251, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_251, (VkFence*)&forUnmarshaling->fence, 1);
+ 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);
vkStream->read((VkFenceImportFlags*)&forUnmarshaling->flags, sizeof(VkFenceImportFlags));
vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
@@ -8839,8 +8899,8 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
// WARNING PTR CHECK
- uint64_t cgen_var_252 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
- vkStream->putBe64(cgen_var_252);
+ uint64_t cgen_var_256 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+ vkStream->putBe64(cgen_var_256);
if (forMarshaling->pAttributes)
{
vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
@@ -8889,9 +8949,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_258;
+ vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_258, 1);
+ vkStream->write((uint64_t*)&cgen_var_258, 1 * 8);
vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
}
@@ -8908,9 +8968,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_259;
+ vkStream->read((uint64_t*)&cgen_var_259, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_259, (VkFence*)&forUnmarshaling->fence, 1);
vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
}
@@ -8928,9 +8988,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_256;
- vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_256, 1);
- vkStream->write((uint64_t*)&cgen_var_256, 1 * 8);
+ 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);
vkStream->write((VkFenceImportFlags*)&forMarshaling->flags, sizeof(VkFenceImportFlags));
vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
vkStream->write((int*)&forMarshaling->fd, sizeof(int));
@@ -8949,9 +9009,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_257;
- vkStream->read((uint64_t*)&cgen_var_257, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_257, (VkFence*)&forUnmarshaling->fence, 1);
+ 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);
vkStream->read((VkFenceImportFlags*)&forUnmarshaling->flags, sizeof(VkFenceImportFlags));
vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
vkStream->read((int*)&forUnmarshaling->fd, sizeof(int));
@@ -8969,9 +9029,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_262;
+ vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_262, 1);
+ vkStream->write((uint64_t*)&cgen_var_262, 1 * 8);
vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
}
@@ -8988,9 +9048,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_263;
+ vkStream->read((uint64_t*)&cgen_var_263, 1 * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_263, (VkFence*)&forUnmarshaling->fence, 1);
vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
}
@@ -9010,9 +9070,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_260;
- vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_260, 1);
- vkStream->write((uint64_t*)&cgen_var_260, 1 * 8);
+ 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);
}
void unmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
@@ -9028,9 +9088,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_VkSurfaceKHR(&cgen_var_261, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
+ 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);
}
void marshal_VkSurfaceCapabilities2KHR(
@@ -9204,9 +9264,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_262;
- vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->mode, &cgen_var_262, 1);
- vkStream->write((uint64_t*)&cgen_var_262, 1 * 8);
+ 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);
vkStream->write((uint32_t*)&forMarshaling->planeIndex, sizeof(uint32_t));
}
@@ -9223,9 +9283,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_VkDisplayModeKHR(&cgen_var_263, (VkDisplayModeKHR*)&forUnmarshaling->mode, 1);
+ 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);
vkStream->read((uint32_t*)&forUnmarshaling->planeIndex, sizeof(uint32_t));
}
@@ -9363,8 +9423,8 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
// WARNING PTR CHECK
- uint64_t cgen_var_264 = (uint64_t)(uintptr_t)forMarshaling->handle;
- vkStream->putBe64(cgen_var_264);
+ uint64_t cgen_var_268 = (uint64_t)(uintptr_t)forMarshaling->handle;
+ vkStream->putBe64(cgen_var_268);
if (forMarshaling->handle)
{
vkStream->write((const uint32_t*)forMarshaling->handle, sizeof(const uint32_t));
@@ -9422,11 +9482,11 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
vkStream->write((VkDebugReportFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugReportFlagsEXT));
- uint64_t cgen_var_266 = (uint64_t)forMarshaling->pfnCallback;
- vkStream->putBe64(cgen_var_266);
+ uint64_t cgen_var_270 = (uint64_t)forMarshaling->pfnCallback;
+ vkStream->putBe64(cgen_var_270);
// WARNING PTR CHECK
- uint64_t cgen_var_267 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
- vkStream->putBe64(cgen_var_267);
+ uint64_t cgen_var_271 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
+ vkStream->putBe64(cgen_var_271);
if (forMarshaling->pUserData)
{
vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
@@ -9556,8 +9616,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_270 = (uint64_t)forMarshaling->tagSize;
- vkStream->putBe64(cgen_var_270);
+ uint64_t cgen_var_274 = (uint64_t)forMarshaling->tagSize;
+ vkStream->putBe64(cgen_var_274);
vkStream->write((const void*)forMarshaling->pTag, forMarshaling->tagSize * sizeof(const uint8_t));
}
@@ -9692,12 +9752,12 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_272;
- vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_272, 1);
- vkStream->write((uint64_t*)&cgen_var_272, 1 * 8);
- uint64_t cgen_var_273;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_273, 1);
- vkStream->write((uint64_t*)&cgen_var_273, 1 * 8);
+ 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);
}
void unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
@@ -9713,12 +9773,12 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_274;
- vkStream->read((uint64_t*)&cgen_var_274, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_274, (VkImage*)&forUnmarshaling->image, 1);
- uint64_t cgen_var_275;
- vkStream->read((uint64_t*)&cgen_var_275, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_275, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ 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);
}
#endif
@@ -9771,10 +9831,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_276 = (uint64_t)forMarshaling->ldsUsageSizeInBytes;
- vkStream->putBe64(cgen_var_276);
- uint64_t cgen_var_277 = (uint64_t)forMarshaling->scratchMemUsageInBytes;
- vkStream->putBe64(cgen_var_277);
+ 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);
}
void unmarshal_VkShaderResourceUsageAMD(
@@ -9952,8 +10012,8 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
// WARNING PTR CHECK
- uint64_t cgen_var_280 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
- vkStream->putBe64(cgen_var_280);
+ uint64_t cgen_var_284 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+ vkStream->putBe64(cgen_var_284);
if (forMarshaling->pAttributes)
{
vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
@@ -10005,20 +10065,20 @@
vkStream->write((uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
if (forMarshaling->acquireCount)
{
- uint64_t* cgen_var_282;
- vkStream->alloc((void**)&cgen_var_282, forMarshaling->acquireCount * 8);
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pAcquireSyncs, cgen_var_282, forMarshaling->acquireCount);
- vkStream->write((uint64_t*)cgen_var_282, forMarshaling->acquireCount * 8);
+ 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);
}
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_283;
- vkStream->alloc((void**)&cgen_var_283, forMarshaling->releaseCount * 8);
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pReleaseSyncs, cgen_var_283, forMarshaling->releaseCount);
- vkStream->write((uint64_t*)cgen_var_283, forMarshaling->releaseCount * 8);
+ 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);
}
vkStream->write((const uint64_t*)forMarshaling->pReleaseKeys, forMarshaling->releaseCount * sizeof(const uint64_t));
}
@@ -10039,20 +10099,20 @@
vkStream->read((uint32_t*)&forUnmarshaling->acquireCount, sizeof(uint32_t));
if (forUnmarshaling->acquireCount)
{
- uint64_t* cgen_var_284;
- vkStream->alloc((void**)&cgen_var_284, forUnmarshaling->acquireCount * 8);
- vkStream->read((uint64_t*)cgen_var_284, forUnmarshaling->acquireCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_284, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs, 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);
}
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_285;
- vkStream->alloc((void**)&cgen_var_285, forUnmarshaling->releaseCount * 8);
- vkStream->read((uint64_t*)cgen_var_285, forUnmarshaling->releaseCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_285, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs, 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);
}
vkStream->read((uint64_t*)forUnmarshaling->pReleaseKeys, forUnmarshaling->releaseCount * sizeof(const uint64_t));
}
@@ -10108,8 +10168,8 @@
}
vkStream->write((VkViSurfaceCreateFlagsNN*)&forMarshaling->flags, sizeof(VkViSurfaceCreateFlagsNN));
// WARNING PTR CHECK
- uint64_t cgen_var_286 = (uint64_t)(uintptr_t)forMarshaling->window;
- vkStream->putBe64(cgen_var_286);
+ uint64_t cgen_var_290 = (uint64_t)(uintptr_t)forMarshaling->window;
+ vkStream->putBe64(cgen_var_290);
if (forMarshaling->window)
{
vkStream->write((void*)forMarshaling->window, sizeof(uint8_t));
@@ -10161,9 +10221,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_288;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_288, 1);
- vkStream->write((uint64_t*)&cgen_var_288, 1 * 8);
+ 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);
vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
vkStream->write((VkConditionalRenderingFlagsEXT*)&forMarshaling->flags, sizeof(VkConditionalRenderingFlagsEXT));
}
@@ -10181,9 +10241,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- 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);
+ 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);
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
vkStream->read((VkConditionalRenderingFlagsEXT*)&forUnmarshaling->flags, sizeof(VkConditionalRenderingFlagsEXT));
}
@@ -10329,9 +10389,9 @@
const VkIndirectCommandsTokenNVX* forMarshaling)
{
vkStream->write((VkIndirectCommandsTokenTypeNVX*)&forMarshaling->tokenType, sizeof(VkIndirectCommandsTokenTypeNVX));
- uint64_t cgen_var_290;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_290, 1);
- vkStream->write((uint64_t*)&cgen_var_290, 1 * 8);
+ 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);
vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
}
@@ -10340,9 +10400,9 @@
VkIndirectCommandsTokenNVX* forUnmarshaling)
{
vkStream->read((VkIndirectCommandsTokenTypeNVX*)&forUnmarshaling->tokenType, sizeof(VkIndirectCommandsTokenTypeNVX));
- uint64_t cgen_var_291;
- vkStream->read((uint64_t*)&cgen_var_291, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_291, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ 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);
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
}
@@ -10421,28 +10481,28 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_292;
- vkStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&forMarshaling->objectTable, &cgen_var_292, 1);
- vkStream->write((uint64_t*)&cgen_var_292, 1 * 8);
- uint64_t cgen_var_293;
- vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&forMarshaling->indirectCommandsLayout, &cgen_var_293, 1);
- vkStream->write((uint64_t*)&cgen_var_293, 1 * 8);
+ 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);
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_294;
- vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&forMarshaling->targetCommandBuffer, &cgen_var_294, 1);
- vkStream->write((uint64_t*)&cgen_var_294, 1 * 8);
- uint64_t cgen_var_295;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesCountBuffer, &cgen_var_295, 1);
- vkStream->write((uint64_t*)&cgen_var_295, 1 * 8);
+ 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);
vkStream->write((VkDeviceSize*)&forMarshaling->sequencesCountOffset, sizeof(VkDeviceSize));
- uint64_t cgen_var_296;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesIndexBuffer, &cgen_var_296, 1);
- vkStream->write((uint64_t*)&cgen_var_296, 1 * 8);
+ 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);
vkStream->write((VkDeviceSize*)&forMarshaling->sequencesIndexOffset, sizeof(VkDeviceSize));
}
@@ -10459,28 +10519,28 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_297;
- vkStream->read((uint64_t*)&cgen_var_297, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_297, (VkObjectTableNVX*)&forUnmarshaling->objectTable, 1);
- uint64_t cgen_var_298;
- vkStream->read((uint64_t*)&cgen_var_298, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_298, (VkIndirectCommandsLayoutNVX*)&forUnmarshaling->indirectCommandsLayout, 1);
+ 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);
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_299;
- vkStream->read((uint64_t*)&cgen_var_299, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(&cgen_var_299, (VkCommandBuffer*)&forUnmarshaling->targetCommandBuffer, 1);
- uint64_t cgen_var_300;
- vkStream->read((uint64_t*)&cgen_var_300, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_300, (VkBuffer*)&forUnmarshaling->sequencesCountBuffer, 1);
+ 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);
vkStream->read((VkDeviceSize*)&forUnmarshaling->sequencesCountOffset, sizeof(VkDeviceSize));
- uint64_t cgen_var_301;
- vkStream->read((uint64_t*)&cgen_var_301, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_301, (VkBuffer*)&forUnmarshaling->sequencesIndexBuffer, 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->sequencesIndexBuffer, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->sequencesIndexOffset, sizeof(VkDeviceSize));
}
@@ -10496,12 +10556,12 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_302;
- vkStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&forMarshaling->objectTable, &cgen_var_302, 1);
- vkStream->write((uint64_t*)&cgen_var_302, 1 * 8);
- uint64_t cgen_var_303;
- vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&forMarshaling->indirectCommandsLayout, &cgen_var_303, 1);
- vkStream->write((uint64_t*)&cgen_var_303, 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->maxSequencesCount, sizeof(uint32_t));
}
@@ -10518,12 +10578,12 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_304;
- vkStream->read((uint64_t*)&cgen_var_304, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_304, (VkObjectTableNVX*)&forUnmarshaling->objectTable, 1);
- uint64_t cgen_var_305;
- vkStream->read((uint64_t*)&cgen_var_305, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_305, (VkIndirectCommandsLayoutNVX*)&forUnmarshaling->indirectCommandsLayout, 1);
+ 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);
vkStream->read((uint32_t*)&forUnmarshaling->maxSequencesCount, sizeof(uint32_t));
}
@@ -10596,9 +10656,9 @@
{
vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_306;
- vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->pipeline, &cgen_var_306, 1);
- vkStream->write((uint64_t*)&cgen_var_306, 1 * 8);
+ 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);
}
void unmarshal_VkObjectTablePipelineEntryNVX(
@@ -10607,9 +10667,9 @@
{
vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_307;
- vkStream->read((uint64_t*)&cgen_var_307, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_307, (VkPipeline*)&forUnmarshaling->pipeline, 1);
+ 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);
}
void marshal_VkObjectTableDescriptorSetEntryNVX(
@@ -10618,12 +10678,12 @@
{
vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_308;
- vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_308, 1);
- vkStream->write((uint64_t*)&cgen_var_308, 1 * 8);
- uint64_t cgen_var_309;
- vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->descriptorSet, &cgen_var_309, 1);
- vkStream->write((uint64_t*)&cgen_var_309, 1 * 8);
+ 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);
}
void unmarshal_VkObjectTableDescriptorSetEntryNVX(
@@ -10632,12 +10692,12 @@
{
vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_310;
- vkStream->read((uint64_t*)&cgen_var_310, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_310, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
- uint64_t cgen_var_311;
- vkStream->read((uint64_t*)&cgen_var_311, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_311, (VkDescriptorSet*)&forUnmarshaling->descriptorSet, 1);
+ 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);
}
void marshal_VkObjectTableVertexBufferEntryNVX(
@@ -10646,9 +10706,9 @@
{
vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_312;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_312, 1);
- vkStream->write((uint64_t*)&cgen_var_312, 1 * 8);
+ 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);
}
void unmarshal_VkObjectTableVertexBufferEntryNVX(
@@ -10657,9 +10717,9 @@
{
vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_313;
- vkStream->read((uint64_t*)&cgen_var_313, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_313, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ 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);
}
void marshal_VkObjectTableIndexBufferEntryNVX(
@@ -10668,9 +10728,9 @@
{
vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_314;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_314, 1);
- vkStream->write((uint64_t*)&cgen_var_314, 1 * 8);
+ 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);
vkStream->write((VkIndexType*)&forMarshaling->indexType, sizeof(VkIndexType));
}
@@ -10680,9 +10740,9 @@
{
vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_315;
- vkStream->read((uint64_t*)&cgen_var_315, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_315, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ 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);
vkStream->read((VkIndexType*)&forUnmarshaling->indexType, sizeof(VkIndexType));
}
@@ -10692,9 +10752,9 @@
{
vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
- uint64_t cgen_var_316;
- vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_316, 1);
- vkStream->write((uint64_t*)&cgen_var_316, 1 * 8);
+ 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);
vkStream->write((VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
}
@@ -10704,9 +10764,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_VkPipelineLayout(&cgen_var_317, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
+ 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);
vkStream->read((VkShaderStageFlags*)&forUnmarshaling->stageFlags, sizeof(VkShaderStageFlags));
}
@@ -10743,8 +10803,8 @@
vkStream->write((VkBool32*)&forMarshaling->viewportWScalingEnable, sizeof(VkBool32));
vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_318 = (uint64_t)(uintptr_t)forMarshaling->pViewportWScalings;
- vkStream->putBe64(cgen_var_318);
+ uint64_t cgen_var_322 = (uint64_t)(uintptr_t)forMarshaling->pViewportWScalings;
+ vkStream->putBe64(cgen_var_322);
if (forMarshaling->pViewportWScalings)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
@@ -11036,8 +11096,8 @@
}
vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_320 = (uint64_t)(uintptr_t)forMarshaling->pTimes;
- vkStream->putBe64(cgen_var_320);
+ uint64_t cgen_var_324 = (uint64_t)(uintptr_t)forMarshaling->pTimes;
+ vkStream->putBe64(cgen_var_324);
if (forMarshaling->pTimes)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i)
@@ -11153,8 +11213,8 @@
vkStream->write((VkPipelineViewportSwizzleStateCreateFlagsNV*)&forMarshaling->flags, sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV));
vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_322 = (uint64_t)(uintptr_t)forMarshaling->pViewportSwizzles;
- vkStream->putBe64(cgen_var_322);
+ uint64_t cgen_var_326 = (uint64_t)(uintptr_t)forMarshaling->pViewportSwizzles;
+ vkStream->putBe64(cgen_var_326);
if (forMarshaling->pViewportSwizzles)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
@@ -11244,8 +11304,8 @@
vkStream->write((VkDiscardRectangleModeEXT*)&forMarshaling->discardRectangleMode, sizeof(VkDiscardRectangleModeEXT));
vkStream->write((uint32_t*)&forMarshaling->discardRectangleCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_324 = (uint64_t)(uintptr_t)forMarshaling->pDiscardRectangles;
- vkStream->putBe64(cgen_var_324);
+ uint64_t cgen_var_328 = (uint64_t)(uintptr_t)forMarshaling->pDiscardRectangles;
+ vkStream->putBe64(cgen_var_328);
if (forMarshaling->pDiscardRectangles)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->discardRectangleCount; ++i)
@@ -11452,8 +11512,8 @@
}
vkStream->write((VkIOSSurfaceCreateFlagsMVK*)&forMarshaling->flags, sizeof(VkIOSSurfaceCreateFlagsMVK));
// WARNING PTR CHECK
- uint64_t cgen_var_326 = (uint64_t)(uintptr_t)forMarshaling->pView;
- vkStream->putBe64(cgen_var_326);
+ uint64_t cgen_var_330 = (uint64_t)(uintptr_t)forMarshaling->pView;
+ vkStream->putBe64(cgen_var_330);
if (forMarshaling->pView)
{
vkStream->write((const void*)forMarshaling->pView, sizeof(const uint8_t));
@@ -11503,8 +11563,8 @@
}
vkStream->write((VkMacOSSurfaceCreateFlagsMVK*)&forMarshaling->flags, sizeof(VkMacOSSurfaceCreateFlagsMVK));
// WARNING PTR CHECK
- uint64_t cgen_var_328 = (uint64_t)(uintptr_t)forMarshaling->pView;
- vkStream->putBe64(cgen_var_328);
+ uint64_t cgen_var_332 = (uint64_t)(uintptr_t)forMarshaling->pView;
+ vkStream->putBe64(cgen_var_332);
if (forMarshaling->pView)
{
vkStream->write((const void*)forMarshaling->pView, sizeof(const uint8_t));
@@ -11558,7 +11618,20 @@
}
vkStream->write((VkObjectType*)&forMarshaling->objectType, sizeof(VkObjectType));
vkStream->write((uint64_t*)&forMarshaling->objectHandle, sizeof(uint64_t));
- vkStream->putString(forMarshaling->pObjectName);
+ 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);
+ if (forMarshaling->pObjectName)
+ {
+ vkStream->putString(forMarshaling->pObjectName);
+ }
+ }
+ else
+ {
+ vkStream->putString(forMarshaling->pObjectName);
+ }
}
void unmarshal_VkDebugUtilsObjectNameInfoEXT(
@@ -11576,7 +11649,24 @@
}
vkStream->read((VkObjectType*)&forUnmarshaling->objectType, sizeof(VkObjectType));
vkStream->read((uint64_t*)&forUnmarshaling->objectHandle, sizeof(uint64_t));
- vkStream->loadStringInPlace((char**)&forUnmarshaling->pObjectName);
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
+ {
+ // WARNING PTR CHECK
+ const char* check_pObjectName;
+ check_pObjectName = (const char*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pObjectName)
+ {
+ if (!(check_pObjectName))
+ {
+ fprintf(stderr, "fatal: forUnmarshaling->pObjectName inconsistent between guest and host\n");
+ }
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pObjectName);
+ }
+ }
+ else
+ {
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pObjectName);
+ }
}
void marshal_VkDebugUtilsObjectTagInfoEXT(
@@ -11594,8 +11684,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_330 = (uint64_t)forMarshaling->tagSize;
- vkStream->putBe64(cgen_var_330);
+ uint64_t cgen_var_336 = (uint64_t)forMarshaling->tagSize;
+ vkStream->putBe64(cgen_var_336);
vkStream->write((const void*)forMarshaling->pTag, forMarshaling->tagSize * sizeof(const uint8_t));
}
@@ -11665,13 +11755,26 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
vkStream->write((VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
- vkStream->putString(forMarshaling->pMessageIdName);
+ 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);
+ if (forMarshaling->pMessageIdName)
+ {
+ vkStream->putString(forMarshaling->pMessageIdName);
+ }
+ }
+ else
+ {
+ vkStream->putString(forMarshaling->pMessageIdName);
+ }
vkStream->write((int32_t*)&forMarshaling->messageIdNumber, sizeof(int32_t));
vkStream->putString(forMarshaling->pMessage);
vkStream->write((uint32_t*)&forMarshaling->queueLabelCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_332 = (uint64_t)(uintptr_t)forMarshaling->pQueueLabels;
- vkStream->putBe64(cgen_var_332);
+ uint64_t cgen_var_339 = (uint64_t)(uintptr_t)forMarshaling->pQueueLabels;
+ vkStream->putBe64(cgen_var_339);
if (forMarshaling->pQueueLabels)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueLabelCount; ++i)
@@ -11681,8 +11784,8 @@
}
vkStream->write((uint32_t*)&forMarshaling->cmdBufLabelCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_333 = (uint64_t)(uintptr_t)forMarshaling->pCmdBufLabels;
- vkStream->putBe64(cgen_var_333);
+ uint64_t cgen_var_340 = (uint64_t)(uintptr_t)forMarshaling->pCmdBufLabels;
+ vkStream->putBe64(cgen_var_340);
if (forMarshaling->pCmdBufLabels)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->cmdBufLabelCount; ++i)
@@ -11692,8 +11795,8 @@
}
vkStream->write((uint32_t*)&forMarshaling->objectCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_334 = (uint64_t)(uintptr_t)forMarshaling->pObjects;
- vkStream->putBe64(cgen_var_334);
+ uint64_t cgen_var_341 = (uint64_t)(uintptr_t)forMarshaling->pObjects;
+ vkStream->putBe64(cgen_var_341);
if (forMarshaling->pObjects)
{
for (uint32_t i = 0; i < (uint32_t)forMarshaling->objectCount; ++i)
@@ -11717,7 +11820,24 @@
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
vkStream->read((VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forUnmarshaling->flags, sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
- vkStream->loadStringInPlace((char**)&forUnmarshaling->pMessageIdName);
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
+ {
+ // WARNING PTR CHECK
+ const char* check_pMessageIdName;
+ check_pMessageIdName = (const char*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pMessageIdName)
+ {
+ if (!(check_pMessageIdName))
+ {
+ fprintf(stderr, "fatal: forUnmarshaling->pMessageIdName inconsistent between guest and host\n");
+ }
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pMessageIdName);
+ }
+ }
+ else
+ {
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pMessageIdName);
+ }
vkStream->read((int32_t*)&forUnmarshaling->messageIdNumber, sizeof(int32_t));
vkStream->loadStringInPlace((char**)&forUnmarshaling->pMessage);
vkStream->read((uint32_t*)&forUnmarshaling->queueLabelCount, sizeof(uint32_t));
@@ -11782,11 +11902,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_338 = (uint64_t)forMarshaling->pfnUserCallback;
- vkStream->putBe64(cgen_var_338);
+ uint64_t cgen_var_346 = (uint64_t)forMarshaling->pfnUserCallback;
+ vkStream->putBe64(cgen_var_346);
// WARNING PTR CHECK
- uint64_t cgen_var_339 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
- vkStream->putBe64(cgen_var_339);
+ uint64_t cgen_var_347 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
+ vkStream->putBe64(cgen_var_347);
if (forMarshaling->pUserData)
{
vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
@@ -11977,9 +12097,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_342;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_342, 1);
- vkStream->write((uint64_t*)&cgen_var_342, 1 * 8);
+ 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);
}
void unmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
@@ -11995,9 +12115,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_343;
- vkStream->read((uint64_t*)&cgen_var_343, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_343, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ 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);
}
void marshal_VkExternalFormatANDROID(
@@ -12515,8 +12635,8 @@
vkStream->write((VkBool32*)&forMarshaling->coverageModulationTableEnable, sizeof(VkBool32));
vkStream->write((uint32_t*)&forMarshaling->coverageModulationTableCount, sizeof(uint32_t));
// WARNING PTR CHECK
- uint64_t cgen_var_344 = (uint64_t)(uintptr_t)forMarshaling->pCoverageModulationTable;
- vkStream->putBe64(cgen_var_344);
+ uint64_t cgen_var_352 = (uint64_t)(uintptr_t)forMarshaling->pCoverageModulationTable;
+ vkStream->putBe64(cgen_var_352);
if (forMarshaling->pCoverageModulationTable)
{
vkStream->write((const float*)forMarshaling->pCoverageModulationTable, forMarshaling->coverageModulationTableCount * sizeof(const float));
@@ -12572,8 +12692,8 @@
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
vkStream->write((VkValidationCacheCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkValidationCacheCreateFlagsEXT));
- uint64_t cgen_var_346 = (uint64_t)forMarshaling->initialDataSize;
- vkStream->putBe64(cgen_var_346);
+ uint64_t cgen_var_354 = (uint64_t)forMarshaling->initialDataSize;
+ vkStream->putBe64(cgen_var_354);
vkStream->write((const void*)forMarshaling->pInitialData, forMarshaling->initialDataSize * sizeof(const uint8_t));
}
@@ -12607,9 +12727,9 @@
vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
marshal_extension_struct(vkStream, forMarshaling->pNext);
}
- uint64_t cgen_var_348;
- vkStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&forMarshaling->validationCache, &cgen_var_348, 1);
- vkStream->write((uint64_t*)&cgen_var_348, 1 * 8);
+ 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);
}
void unmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
@@ -12625,9 +12745,9 @@
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
}
- uint64_t cgen_var_349;
- vkStream->read((uint64_t*)&cgen_var_349, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(&cgen_var_349, (VkValidationCacheEXT*)&forUnmarshaling->validationCache, 1);
+ 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);
}
#endif
@@ -12924,8 +13044,8 @@
}
vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
// WARNING PTR CHECK
- uint64_t cgen_var_350 = (uint64_t)(uintptr_t)forMarshaling->pHostPointer;
- vkStream->putBe64(cgen_var_350);
+ uint64_t cgen_var_358 = (uint64_t)(uintptr_t)forMarshaling->pHostPointer;
+ vkStream->putBe64(cgen_var_358);
if (forMarshaling->pHostPointer)
{
vkStream->write((void*)forMarshaling->pHostPointer, sizeof(uint8_t));
@@ -13219,8 +13339,8 @@
}
vkStream->write((VkPipelineStageFlagBits*)&forMarshaling->stage, sizeof(VkPipelineStageFlagBits));
// WARNING PTR CHECK
- uint64_t cgen_var_352 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
- vkStream->putBe64(cgen_var_352);
+ uint64_t cgen_var_360 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
+ vkStream->putBe64(cgen_var_360);
if (forMarshaling->pCheckpointMarker)
{
vkStream->write((void*)forMarshaling->pCheckpointMarker, sizeof(uint8_t));
@@ -13333,6 +13453,8 @@
#endif
#ifdef VK_GOOGLE_async_command_buffers
#endif
+#ifdef VK_GOOGLE_create_resources_with_requirements
+#endif
void marshal_extension_struct(
VulkanStreamGuest* vkStream,
const void* structExtension)
@@ -14659,5 +14781,1461 @@
}
}
+const char* api_opcode_to_string(
+ const uint32_t opcode)
+{
+ switch(opcode)
+ {
+#ifdef VK_VERSION_1_0
+ case OP_vkCreateInstance:
+ {
+ return "OP_vkCreateInstance";
+ }
+ case OP_vkDestroyInstance:
+ {
+ return "OP_vkDestroyInstance";
+ }
+ case OP_vkEnumeratePhysicalDevices:
+ {
+ return "OP_vkEnumeratePhysicalDevices";
+ }
+ case OP_vkGetPhysicalDeviceFeatures:
+ {
+ return "OP_vkGetPhysicalDeviceFeatures";
+ }
+ case OP_vkGetPhysicalDeviceFormatProperties:
+ {
+ return "OP_vkGetPhysicalDeviceFormatProperties";
+ }
+ case OP_vkGetPhysicalDeviceImageFormatProperties:
+ {
+ return "OP_vkGetPhysicalDeviceImageFormatProperties";
+ }
+ case OP_vkGetPhysicalDeviceProperties:
+ {
+ return "OP_vkGetPhysicalDeviceProperties";
+ }
+ case OP_vkGetPhysicalDeviceQueueFamilyProperties:
+ {
+ return "OP_vkGetPhysicalDeviceQueueFamilyProperties";
+ }
+ case OP_vkGetPhysicalDeviceMemoryProperties:
+ {
+ return "OP_vkGetPhysicalDeviceMemoryProperties";
+ }
+ case OP_vkGetInstanceProcAddr:
+ {
+ return "OP_vkGetInstanceProcAddr";
+ }
+ case OP_vkGetDeviceProcAddr:
+ {
+ return "OP_vkGetDeviceProcAddr";
+ }
+ case OP_vkCreateDevice:
+ {
+ return "OP_vkCreateDevice";
+ }
+ case OP_vkDestroyDevice:
+ {
+ return "OP_vkDestroyDevice";
+ }
+ case OP_vkEnumerateInstanceExtensionProperties:
+ {
+ return "OP_vkEnumerateInstanceExtensionProperties";
+ }
+ case OP_vkEnumerateDeviceExtensionProperties:
+ {
+ return "OP_vkEnumerateDeviceExtensionProperties";
+ }
+ case OP_vkEnumerateInstanceLayerProperties:
+ {
+ return "OP_vkEnumerateInstanceLayerProperties";
+ }
+ case OP_vkEnumerateDeviceLayerProperties:
+ {
+ return "OP_vkEnumerateDeviceLayerProperties";
+ }
+ case OP_vkGetDeviceQueue:
+ {
+ return "OP_vkGetDeviceQueue";
+ }
+ case OP_vkQueueSubmit:
+ {
+ return "OP_vkQueueSubmit";
+ }
+ case OP_vkQueueWaitIdle:
+ {
+ return "OP_vkQueueWaitIdle";
+ }
+ case OP_vkDeviceWaitIdle:
+ {
+ return "OP_vkDeviceWaitIdle";
+ }
+ case OP_vkAllocateMemory:
+ {
+ return "OP_vkAllocateMemory";
+ }
+ case OP_vkFreeMemory:
+ {
+ return "OP_vkFreeMemory";
+ }
+ case OP_vkMapMemory:
+ {
+ return "OP_vkMapMemory";
+ }
+ case OP_vkUnmapMemory:
+ {
+ return "OP_vkUnmapMemory";
+ }
+ case OP_vkFlushMappedMemoryRanges:
+ {
+ return "OP_vkFlushMappedMemoryRanges";
+ }
+ case OP_vkInvalidateMappedMemoryRanges:
+ {
+ return "OP_vkInvalidateMappedMemoryRanges";
+ }
+ case OP_vkGetDeviceMemoryCommitment:
+ {
+ return "OP_vkGetDeviceMemoryCommitment";
+ }
+ case OP_vkBindBufferMemory:
+ {
+ return "OP_vkBindBufferMemory";
+ }
+ case OP_vkBindImageMemory:
+ {
+ return "OP_vkBindImageMemory";
+ }
+ case OP_vkGetBufferMemoryRequirements:
+ {
+ return "OP_vkGetBufferMemoryRequirements";
+ }
+ case OP_vkGetImageMemoryRequirements:
+ {
+ return "OP_vkGetImageMemoryRequirements";
+ }
+ case OP_vkGetImageSparseMemoryRequirements:
+ {
+ return "OP_vkGetImageSparseMemoryRequirements";
+ }
+ case OP_vkGetPhysicalDeviceSparseImageFormatProperties:
+ {
+ return "OP_vkGetPhysicalDeviceSparseImageFormatProperties";
+ }
+ case OP_vkQueueBindSparse:
+ {
+ return "OP_vkQueueBindSparse";
+ }
+ case OP_vkCreateFence:
+ {
+ return "OP_vkCreateFence";
+ }
+ case OP_vkDestroyFence:
+ {
+ return "OP_vkDestroyFence";
+ }
+ case OP_vkResetFences:
+ {
+ return "OP_vkResetFences";
+ }
+ case OP_vkGetFenceStatus:
+ {
+ return "OP_vkGetFenceStatus";
+ }
+ case OP_vkWaitForFences:
+ {
+ return "OP_vkWaitForFences";
+ }
+ case OP_vkCreateSemaphore:
+ {
+ return "OP_vkCreateSemaphore";
+ }
+ case OP_vkDestroySemaphore:
+ {
+ return "OP_vkDestroySemaphore";
+ }
+ case OP_vkCreateEvent:
+ {
+ return "OP_vkCreateEvent";
+ }
+ case OP_vkDestroyEvent:
+ {
+ return "OP_vkDestroyEvent";
+ }
+ case OP_vkGetEventStatus:
+ {
+ return "OP_vkGetEventStatus";
+ }
+ case OP_vkSetEvent:
+ {
+ return "OP_vkSetEvent";
+ }
+ case OP_vkResetEvent:
+ {
+ return "OP_vkResetEvent";
+ }
+ case OP_vkCreateQueryPool:
+ {
+ return "OP_vkCreateQueryPool";
+ }
+ case OP_vkDestroyQueryPool:
+ {
+ return "OP_vkDestroyQueryPool";
+ }
+ case OP_vkGetQueryPoolResults:
+ {
+ return "OP_vkGetQueryPoolResults";
+ }
+ case OP_vkCreateBuffer:
+ {
+ return "OP_vkCreateBuffer";
+ }
+ case OP_vkDestroyBuffer:
+ {
+ return "OP_vkDestroyBuffer";
+ }
+ case OP_vkCreateBufferView:
+ {
+ return "OP_vkCreateBufferView";
+ }
+ case OP_vkDestroyBufferView:
+ {
+ return "OP_vkDestroyBufferView";
+ }
+ case OP_vkCreateImage:
+ {
+ return "OP_vkCreateImage";
+ }
+ case OP_vkDestroyImage:
+ {
+ return "OP_vkDestroyImage";
+ }
+ case OP_vkGetImageSubresourceLayout:
+ {
+ return "OP_vkGetImageSubresourceLayout";
+ }
+ case OP_vkCreateImageView:
+ {
+ return "OP_vkCreateImageView";
+ }
+ case OP_vkDestroyImageView:
+ {
+ return "OP_vkDestroyImageView";
+ }
+ case OP_vkCreateShaderModule:
+ {
+ return "OP_vkCreateShaderModule";
+ }
+ case OP_vkDestroyShaderModule:
+ {
+ return "OP_vkDestroyShaderModule";
+ }
+ case OP_vkCreatePipelineCache:
+ {
+ return "OP_vkCreatePipelineCache";
+ }
+ case OP_vkDestroyPipelineCache:
+ {
+ return "OP_vkDestroyPipelineCache";
+ }
+ case OP_vkGetPipelineCacheData:
+ {
+ return "OP_vkGetPipelineCacheData";
+ }
+ case OP_vkMergePipelineCaches:
+ {
+ return "OP_vkMergePipelineCaches";
+ }
+ case OP_vkCreateGraphicsPipelines:
+ {
+ return "OP_vkCreateGraphicsPipelines";
+ }
+ case OP_vkCreateComputePipelines:
+ {
+ return "OP_vkCreateComputePipelines";
+ }
+ case OP_vkDestroyPipeline:
+ {
+ return "OP_vkDestroyPipeline";
+ }
+ case OP_vkCreatePipelineLayout:
+ {
+ return "OP_vkCreatePipelineLayout";
+ }
+ case OP_vkDestroyPipelineLayout:
+ {
+ return "OP_vkDestroyPipelineLayout";
+ }
+ case OP_vkCreateSampler:
+ {
+ return "OP_vkCreateSampler";
+ }
+ case OP_vkDestroySampler:
+ {
+ return "OP_vkDestroySampler";
+ }
+ case OP_vkCreateDescriptorSetLayout:
+ {
+ return "OP_vkCreateDescriptorSetLayout";
+ }
+ case OP_vkDestroyDescriptorSetLayout:
+ {
+ return "OP_vkDestroyDescriptorSetLayout";
+ }
+ case OP_vkCreateDescriptorPool:
+ {
+ return "OP_vkCreateDescriptorPool";
+ }
+ case OP_vkDestroyDescriptorPool:
+ {
+ return "OP_vkDestroyDescriptorPool";
+ }
+ case OP_vkResetDescriptorPool:
+ {
+ return "OP_vkResetDescriptorPool";
+ }
+ case OP_vkAllocateDescriptorSets:
+ {
+ return "OP_vkAllocateDescriptorSets";
+ }
+ case OP_vkFreeDescriptorSets:
+ {
+ return "OP_vkFreeDescriptorSets";
+ }
+ case OP_vkUpdateDescriptorSets:
+ {
+ return "OP_vkUpdateDescriptorSets";
+ }
+ case OP_vkCreateFramebuffer:
+ {
+ return "OP_vkCreateFramebuffer";
+ }
+ case OP_vkDestroyFramebuffer:
+ {
+ return "OP_vkDestroyFramebuffer";
+ }
+ case OP_vkCreateRenderPass:
+ {
+ return "OP_vkCreateRenderPass";
+ }
+ case OP_vkDestroyRenderPass:
+ {
+ return "OP_vkDestroyRenderPass";
+ }
+ case OP_vkGetRenderAreaGranularity:
+ {
+ return "OP_vkGetRenderAreaGranularity";
+ }
+ case OP_vkCreateCommandPool:
+ {
+ return "OP_vkCreateCommandPool";
+ }
+ case OP_vkDestroyCommandPool:
+ {
+ return "OP_vkDestroyCommandPool";
+ }
+ case OP_vkResetCommandPool:
+ {
+ return "OP_vkResetCommandPool";
+ }
+ case OP_vkAllocateCommandBuffers:
+ {
+ return "OP_vkAllocateCommandBuffers";
+ }
+ case OP_vkFreeCommandBuffers:
+ {
+ return "OP_vkFreeCommandBuffers";
+ }
+ case OP_vkBeginCommandBuffer:
+ {
+ return "OP_vkBeginCommandBuffer";
+ }
+ case OP_vkEndCommandBuffer:
+ {
+ return "OP_vkEndCommandBuffer";
+ }
+ case OP_vkResetCommandBuffer:
+ {
+ return "OP_vkResetCommandBuffer";
+ }
+ case OP_vkCmdBindPipeline:
+ {
+ return "OP_vkCmdBindPipeline";
+ }
+ case OP_vkCmdSetViewport:
+ {
+ return "OP_vkCmdSetViewport";
+ }
+ case OP_vkCmdSetScissor:
+ {
+ return "OP_vkCmdSetScissor";
+ }
+ case OP_vkCmdSetLineWidth:
+ {
+ return "OP_vkCmdSetLineWidth";
+ }
+ case OP_vkCmdSetDepthBias:
+ {
+ return "OP_vkCmdSetDepthBias";
+ }
+ case OP_vkCmdSetBlendConstants:
+ {
+ return "OP_vkCmdSetBlendConstants";
+ }
+ case OP_vkCmdSetDepthBounds:
+ {
+ return "OP_vkCmdSetDepthBounds";
+ }
+ case OP_vkCmdSetStencilCompareMask:
+ {
+ return "OP_vkCmdSetStencilCompareMask";
+ }
+ case OP_vkCmdSetStencilWriteMask:
+ {
+ return "OP_vkCmdSetStencilWriteMask";
+ }
+ case OP_vkCmdSetStencilReference:
+ {
+ return "OP_vkCmdSetStencilReference";
+ }
+ case OP_vkCmdBindDescriptorSets:
+ {
+ return "OP_vkCmdBindDescriptorSets";
+ }
+ case OP_vkCmdBindIndexBuffer:
+ {
+ return "OP_vkCmdBindIndexBuffer";
+ }
+ case OP_vkCmdBindVertexBuffers:
+ {
+ return "OP_vkCmdBindVertexBuffers";
+ }
+ case OP_vkCmdDraw:
+ {
+ return "OP_vkCmdDraw";
+ }
+ case OP_vkCmdDrawIndexed:
+ {
+ return "OP_vkCmdDrawIndexed";
+ }
+ case OP_vkCmdDrawIndirect:
+ {
+ return "OP_vkCmdDrawIndirect";
+ }
+ case OP_vkCmdDrawIndexedIndirect:
+ {
+ return "OP_vkCmdDrawIndexedIndirect";
+ }
+ case OP_vkCmdDispatch:
+ {
+ return "OP_vkCmdDispatch";
+ }
+ case OP_vkCmdDispatchIndirect:
+ {
+ return "OP_vkCmdDispatchIndirect";
+ }
+ case OP_vkCmdCopyBuffer:
+ {
+ return "OP_vkCmdCopyBuffer";
+ }
+ case OP_vkCmdCopyImage:
+ {
+ return "OP_vkCmdCopyImage";
+ }
+ case OP_vkCmdBlitImage:
+ {
+ return "OP_vkCmdBlitImage";
+ }
+ case OP_vkCmdCopyBufferToImage:
+ {
+ return "OP_vkCmdCopyBufferToImage";
+ }
+ case OP_vkCmdCopyImageToBuffer:
+ {
+ return "OP_vkCmdCopyImageToBuffer";
+ }
+ case OP_vkCmdUpdateBuffer:
+ {
+ return "OP_vkCmdUpdateBuffer";
+ }
+ case OP_vkCmdFillBuffer:
+ {
+ return "OP_vkCmdFillBuffer";
+ }
+ case OP_vkCmdClearColorImage:
+ {
+ return "OP_vkCmdClearColorImage";
+ }
+ case OP_vkCmdClearDepthStencilImage:
+ {
+ return "OP_vkCmdClearDepthStencilImage";
+ }
+ case OP_vkCmdClearAttachments:
+ {
+ return "OP_vkCmdClearAttachments";
+ }
+ case OP_vkCmdResolveImage:
+ {
+ return "OP_vkCmdResolveImage";
+ }
+ case OP_vkCmdSetEvent:
+ {
+ return "OP_vkCmdSetEvent";
+ }
+ case OP_vkCmdResetEvent:
+ {
+ return "OP_vkCmdResetEvent";
+ }
+ case OP_vkCmdWaitEvents:
+ {
+ return "OP_vkCmdWaitEvents";
+ }
+ case OP_vkCmdPipelineBarrier:
+ {
+ return "OP_vkCmdPipelineBarrier";
+ }
+ case OP_vkCmdBeginQuery:
+ {
+ return "OP_vkCmdBeginQuery";
+ }
+ case OP_vkCmdEndQuery:
+ {
+ return "OP_vkCmdEndQuery";
+ }
+ case OP_vkCmdResetQueryPool:
+ {
+ return "OP_vkCmdResetQueryPool";
+ }
+ case OP_vkCmdWriteTimestamp:
+ {
+ return "OP_vkCmdWriteTimestamp";
+ }
+ case OP_vkCmdCopyQueryPoolResults:
+ {
+ return "OP_vkCmdCopyQueryPoolResults";
+ }
+ case OP_vkCmdPushConstants:
+ {
+ return "OP_vkCmdPushConstants";
+ }
+ case OP_vkCmdBeginRenderPass:
+ {
+ return "OP_vkCmdBeginRenderPass";
+ }
+ case OP_vkCmdNextSubpass:
+ {
+ return "OP_vkCmdNextSubpass";
+ }
+ case OP_vkCmdEndRenderPass:
+ {
+ return "OP_vkCmdEndRenderPass";
+ }
+ case OP_vkCmdExecuteCommands:
+ {
+ return "OP_vkCmdExecuteCommands";
+ }
+#endif
+#ifdef VK_VERSION_1_1
+ case OP_vkEnumerateInstanceVersion:
+ {
+ return "OP_vkEnumerateInstanceVersion";
+ }
+ case OP_vkBindBufferMemory2:
+ {
+ return "OP_vkBindBufferMemory2";
+ }
+ case OP_vkBindImageMemory2:
+ {
+ return "OP_vkBindImageMemory2";
+ }
+ case OP_vkGetDeviceGroupPeerMemoryFeatures:
+ {
+ return "OP_vkGetDeviceGroupPeerMemoryFeatures";
+ }
+ case OP_vkCmdSetDeviceMask:
+ {
+ return "OP_vkCmdSetDeviceMask";
+ }
+ case OP_vkCmdDispatchBase:
+ {
+ return "OP_vkCmdDispatchBase";
+ }
+ case OP_vkEnumeratePhysicalDeviceGroups:
+ {
+ return "OP_vkEnumeratePhysicalDeviceGroups";
+ }
+ case OP_vkGetImageMemoryRequirements2:
+ {
+ return "OP_vkGetImageMemoryRequirements2";
+ }
+ case OP_vkGetBufferMemoryRequirements2:
+ {
+ return "OP_vkGetBufferMemoryRequirements2";
+ }
+ case OP_vkGetImageSparseMemoryRequirements2:
+ {
+ return "OP_vkGetImageSparseMemoryRequirements2";
+ }
+ case OP_vkGetPhysicalDeviceFeatures2:
+ {
+ return "OP_vkGetPhysicalDeviceFeatures2";
+ }
+ case OP_vkGetPhysicalDeviceProperties2:
+ {
+ return "OP_vkGetPhysicalDeviceProperties2";
+ }
+ case OP_vkGetPhysicalDeviceFormatProperties2:
+ {
+ return "OP_vkGetPhysicalDeviceFormatProperties2";
+ }
+ case OP_vkGetPhysicalDeviceImageFormatProperties2:
+ {
+ return "OP_vkGetPhysicalDeviceImageFormatProperties2";
+ }
+ case OP_vkGetPhysicalDeviceQueueFamilyProperties2:
+ {
+ return "OP_vkGetPhysicalDeviceQueueFamilyProperties2";
+ }
+ case OP_vkGetPhysicalDeviceMemoryProperties2:
+ {
+ return "OP_vkGetPhysicalDeviceMemoryProperties2";
+ }
+ case OP_vkGetPhysicalDeviceSparseImageFormatProperties2:
+ {
+ return "OP_vkGetPhysicalDeviceSparseImageFormatProperties2";
+ }
+ case OP_vkTrimCommandPool:
+ {
+ return "OP_vkTrimCommandPool";
+ }
+ case OP_vkGetDeviceQueue2:
+ {
+ return "OP_vkGetDeviceQueue2";
+ }
+ case OP_vkCreateSamplerYcbcrConversion:
+ {
+ return "OP_vkCreateSamplerYcbcrConversion";
+ }
+ case OP_vkDestroySamplerYcbcrConversion:
+ {
+ return "OP_vkDestroySamplerYcbcrConversion";
+ }
+ case OP_vkCreateDescriptorUpdateTemplate:
+ {
+ return "OP_vkCreateDescriptorUpdateTemplate";
+ }
+ case OP_vkDestroyDescriptorUpdateTemplate:
+ {
+ return "OP_vkDestroyDescriptorUpdateTemplate";
+ }
+ case OP_vkUpdateDescriptorSetWithTemplate:
+ {
+ return "OP_vkUpdateDescriptorSetWithTemplate";
+ }
+ case OP_vkGetPhysicalDeviceExternalBufferProperties:
+ {
+ return "OP_vkGetPhysicalDeviceExternalBufferProperties";
+ }
+ case OP_vkGetPhysicalDeviceExternalFenceProperties:
+ {
+ return "OP_vkGetPhysicalDeviceExternalFenceProperties";
+ }
+ case OP_vkGetPhysicalDeviceExternalSemaphoreProperties:
+ {
+ return "OP_vkGetPhysicalDeviceExternalSemaphoreProperties";
+ }
+ case OP_vkGetDescriptorSetLayoutSupport:
+ {
+ return "OP_vkGetDescriptorSetLayoutSupport";
+ }
+#endif
+#ifdef VK_KHR_surface
+ case OP_vkDestroySurfaceKHR:
+ {
+ return "OP_vkDestroySurfaceKHR";
+ }
+ case OP_vkGetPhysicalDeviceSurfaceSupportKHR:
+ {
+ return "OP_vkGetPhysicalDeviceSurfaceSupportKHR";
+ }
+ case OP_vkGetPhysicalDeviceSurfaceCapabilitiesKHR:
+ {
+ return "OP_vkGetPhysicalDeviceSurfaceCapabilitiesKHR";
+ }
+ case OP_vkGetPhysicalDeviceSurfaceFormatsKHR:
+ {
+ return "OP_vkGetPhysicalDeviceSurfaceFormatsKHR";
+ }
+ case OP_vkGetPhysicalDeviceSurfacePresentModesKHR:
+ {
+ return "OP_vkGetPhysicalDeviceSurfacePresentModesKHR";
+ }
+#endif
+#ifdef VK_KHR_swapchain
+ case OP_vkCreateSwapchainKHR:
+ {
+ return "OP_vkCreateSwapchainKHR";
+ }
+ case OP_vkDestroySwapchainKHR:
+ {
+ return "OP_vkDestroySwapchainKHR";
+ }
+ case OP_vkGetSwapchainImagesKHR:
+ {
+ return "OP_vkGetSwapchainImagesKHR";
+ }
+ case OP_vkAcquireNextImageKHR:
+ {
+ return "OP_vkAcquireNextImageKHR";
+ }
+ case OP_vkQueuePresentKHR:
+ {
+ return "OP_vkQueuePresentKHR";
+ }
+ case OP_vkGetDeviceGroupPresentCapabilitiesKHR:
+ {
+ return "OP_vkGetDeviceGroupPresentCapabilitiesKHR";
+ }
+ case OP_vkGetDeviceGroupSurfacePresentModesKHR:
+ {
+ return "OP_vkGetDeviceGroupSurfacePresentModesKHR";
+ }
+ case OP_vkGetPhysicalDevicePresentRectanglesKHR:
+ {
+ return "OP_vkGetPhysicalDevicePresentRectanglesKHR";
+ }
+ case OP_vkAcquireNextImage2KHR:
+ {
+ return "OP_vkAcquireNextImage2KHR";
+ }
+#endif
+#ifdef VK_KHR_display
+ case OP_vkGetPhysicalDeviceDisplayPropertiesKHR:
+ {
+ return "OP_vkGetPhysicalDeviceDisplayPropertiesKHR";
+ }
+ case OP_vkGetPhysicalDeviceDisplayPlanePropertiesKHR:
+ {
+ return "OP_vkGetPhysicalDeviceDisplayPlanePropertiesKHR";
+ }
+ case OP_vkGetDisplayPlaneSupportedDisplaysKHR:
+ {
+ return "OP_vkGetDisplayPlaneSupportedDisplaysKHR";
+ }
+ case OP_vkGetDisplayModePropertiesKHR:
+ {
+ return "OP_vkGetDisplayModePropertiesKHR";
+ }
+ case OP_vkCreateDisplayModeKHR:
+ {
+ return "OP_vkCreateDisplayModeKHR";
+ }
+ case OP_vkGetDisplayPlaneCapabilitiesKHR:
+ {
+ return "OP_vkGetDisplayPlaneCapabilitiesKHR";
+ }
+ case OP_vkCreateDisplayPlaneSurfaceKHR:
+ {
+ return "OP_vkCreateDisplayPlaneSurfaceKHR";
+ }
+#endif
+#ifdef VK_KHR_display_swapchain
+ case OP_vkCreateSharedSwapchainsKHR:
+ {
+ return "OP_vkCreateSharedSwapchainsKHR";
+ }
+#endif
+#ifdef VK_KHR_xlib_surface
+ case OP_vkCreateXlibSurfaceKHR:
+ {
+ return "OP_vkCreateXlibSurfaceKHR";
+ }
+ case OP_vkGetPhysicalDeviceXlibPresentationSupportKHR:
+ {
+ return "OP_vkGetPhysicalDeviceXlibPresentationSupportKHR";
+ }
+#endif
+#ifdef VK_KHR_xcb_surface
+ case OP_vkCreateXcbSurfaceKHR:
+ {
+ return "OP_vkCreateXcbSurfaceKHR";
+ }
+ case OP_vkGetPhysicalDeviceXcbPresentationSupportKHR:
+ {
+ return "OP_vkGetPhysicalDeviceXcbPresentationSupportKHR";
+ }
+#endif
+#ifdef VK_KHR_wayland_surface
+ case OP_vkCreateWaylandSurfaceKHR:
+ {
+ return "OP_vkCreateWaylandSurfaceKHR";
+ }
+ case OP_vkGetPhysicalDeviceWaylandPresentationSupportKHR:
+ {
+ return "OP_vkGetPhysicalDeviceWaylandPresentationSupportKHR";
+ }
+#endif
+#ifdef VK_KHR_mir_surface
+ case OP_vkCreateMirSurfaceKHR:
+ {
+ return "OP_vkCreateMirSurfaceKHR";
+ }
+ case OP_vkGetPhysicalDeviceMirPresentationSupportKHR:
+ {
+ return "OP_vkGetPhysicalDeviceMirPresentationSupportKHR";
+ }
+#endif
+#ifdef VK_KHR_android_surface
+ case OP_vkCreateAndroidSurfaceKHR:
+ {
+ return "OP_vkCreateAndroidSurfaceKHR";
+ }
+#endif
+#ifdef VK_KHR_win32_surface
+ case OP_vkCreateWin32SurfaceKHR:
+ {
+ return "OP_vkCreateWin32SurfaceKHR";
+ }
+ case OP_vkGetPhysicalDeviceWin32PresentationSupportKHR:
+ {
+ return "OP_vkGetPhysicalDeviceWin32PresentationSupportKHR";
+ }
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+ case OP_vkGetPhysicalDeviceFeatures2KHR:
+ {
+ return "OP_vkGetPhysicalDeviceFeatures2KHR";
+ }
+ case OP_vkGetPhysicalDeviceProperties2KHR:
+ {
+ return "OP_vkGetPhysicalDeviceProperties2KHR";
+ }
+ case OP_vkGetPhysicalDeviceFormatProperties2KHR:
+ {
+ return "OP_vkGetPhysicalDeviceFormatProperties2KHR";
+ }
+ case OP_vkGetPhysicalDeviceImageFormatProperties2KHR:
+ {
+ return "OP_vkGetPhysicalDeviceImageFormatProperties2KHR";
+ }
+ case OP_vkGetPhysicalDeviceQueueFamilyProperties2KHR:
+ {
+ return "OP_vkGetPhysicalDeviceQueueFamilyProperties2KHR";
+ }
+ case OP_vkGetPhysicalDeviceMemoryProperties2KHR:
+ {
+ return "OP_vkGetPhysicalDeviceMemoryProperties2KHR";
+ }
+ case OP_vkGetPhysicalDeviceSparseImageFormatProperties2KHR:
+ {
+ return "OP_vkGetPhysicalDeviceSparseImageFormatProperties2KHR";
+ }
+#endif
+#ifdef VK_KHR_device_group
+ case OP_vkGetDeviceGroupPeerMemoryFeaturesKHR:
+ {
+ return "OP_vkGetDeviceGroupPeerMemoryFeaturesKHR";
+ }
+ case OP_vkCmdSetDeviceMaskKHR:
+ {
+ return "OP_vkCmdSetDeviceMaskKHR";
+ }
+ case OP_vkCmdDispatchBaseKHR:
+ {
+ return "OP_vkCmdDispatchBaseKHR";
+ }
+#endif
+#ifdef VK_KHR_maintenance1
+ case OP_vkTrimCommandPoolKHR:
+ {
+ return "OP_vkTrimCommandPoolKHR";
+ }
+#endif
+#ifdef VK_KHR_device_group_creation
+ case OP_vkEnumeratePhysicalDeviceGroupsKHR:
+ {
+ return "OP_vkEnumeratePhysicalDeviceGroupsKHR";
+ }
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+ case OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR:
+ {
+ return "OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR";
+ }
+#endif
+#ifdef VK_KHR_external_memory_win32
+ case OP_vkGetMemoryWin32HandleKHR:
+ {
+ return "OP_vkGetMemoryWin32HandleKHR";
+ }
+ case OP_vkGetMemoryWin32HandlePropertiesKHR:
+ {
+ return "OP_vkGetMemoryWin32HandlePropertiesKHR";
+ }
+#endif
+#ifdef VK_KHR_external_memory_fd
+ case OP_vkGetMemoryFdKHR:
+ {
+ return "OP_vkGetMemoryFdKHR";
+ }
+ case OP_vkGetMemoryFdPropertiesKHR:
+ {
+ return "OP_vkGetMemoryFdPropertiesKHR";
+ }
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+ case OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR:
+ {
+ return "OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR";
+ }
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+ case OP_vkImportSemaphoreWin32HandleKHR:
+ {
+ return "OP_vkImportSemaphoreWin32HandleKHR";
+ }
+ case OP_vkGetSemaphoreWin32HandleKHR:
+ {
+ return "OP_vkGetSemaphoreWin32HandleKHR";
+ }
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+ case OP_vkImportSemaphoreFdKHR:
+ {
+ return "OP_vkImportSemaphoreFdKHR";
+ }
+ case OP_vkGetSemaphoreFdKHR:
+ {
+ return "OP_vkGetSemaphoreFdKHR";
+ }
+#endif
+#ifdef VK_KHR_push_descriptor
+ case OP_vkCmdPushDescriptorSetKHR:
+ {
+ return "OP_vkCmdPushDescriptorSetKHR";
+ }
+ case OP_vkCmdPushDescriptorSetWithTemplateKHR:
+ {
+ return "OP_vkCmdPushDescriptorSetWithTemplateKHR";
+ }
+#endif
+#ifdef VK_KHR_descriptor_update_template
+ case OP_vkCreateDescriptorUpdateTemplateKHR:
+ {
+ return "OP_vkCreateDescriptorUpdateTemplateKHR";
+ }
+ case OP_vkDestroyDescriptorUpdateTemplateKHR:
+ {
+ return "OP_vkDestroyDescriptorUpdateTemplateKHR";
+ }
+ case OP_vkUpdateDescriptorSetWithTemplateKHR:
+ {
+ return "OP_vkUpdateDescriptorSetWithTemplateKHR";
+ }
+#endif
+#ifdef VK_KHR_create_renderpass2
+ case OP_vkCreateRenderPass2KHR:
+ {
+ return "OP_vkCreateRenderPass2KHR";
+ }
+ case OP_vkCmdBeginRenderPass2KHR:
+ {
+ return "OP_vkCmdBeginRenderPass2KHR";
+ }
+ case OP_vkCmdNextSubpass2KHR:
+ {
+ return "OP_vkCmdNextSubpass2KHR";
+ }
+ case OP_vkCmdEndRenderPass2KHR:
+ {
+ return "OP_vkCmdEndRenderPass2KHR";
+ }
+#endif
+#ifdef VK_KHR_shared_presentable_image
+ case OP_vkGetSwapchainStatusKHR:
+ {
+ return "OP_vkGetSwapchainStatusKHR";
+ }
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+ case OP_vkGetPhysicalDeviceExternalFencePropertiesKHR:
+ {
+ return "OP_vkGetPhysicalDeviceExternalFencePropertiesKHR";
+ }
+#endif
+#ifdef VK_KHR_external_fence_win32
+ case OP_vkImportFenceWin32HandleKHR:
+ {
+ return "OP_vkImportFenceWin32HandleKHR";
+ }
+ case OP_vkGetFenceWin32HandleKHR:
+ {
+ return "OP_vkGetFenceWin32HandleKHR";
+ }
+#endif
+#ifdef VK_KHR_external_fence_fd
+ case OP_vkImportFenceFdKHR:
+ {
+ return "OP_vkImportFenceFdKHR";
+ }
+ case OP_vkGetFenceFdKHR:
+ {
+ return "OP_vkGetFenceFdKHR";
+ }
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+ case OP_vkGetPhysicalDeviceSurfaceCapabilities2KHR:
+ {
+ return "OP_vkGetPhysicalDeviceSurfaceCapabilities2KHR";
+ }
+ case OP_vkGetPhysicalDeviceSurfaceFormats2KHR:
+ {
+ return "OP_vkGetPhysicalDeviceSurfaceFormats2KHR";
+ }
+#endif
+#ifdef VK_KHR_get_display_properties2
+ case OP_vkGetPhysicalDeviceDisplayProperties2KHR:
+ {
+ return "OP_vkGetPhysicalDeviceDisplayProperties2KHR";
+ }
+ case OP_vkGetPhysicalDeviceDisplayPlaneProperties2KHR:
+ {
+ return "OP_vkGetPhysicalDeviceDisplayPlaneProperties2KHR";
+ }
+ case OP_vkGetDisplayModeProperties2KHR:
+ {
+ return "OP_vkGetDisplayModeProperties2KHR";
+ }
+ case OP_vkGetDisplayPlaneCapabilities2KHR:
+ {
+ return "OP_vkGetDisplayPlaneCapabilities2KHR";
+ }
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+ case OP_vkGetImageMemoryRequirements2KHR:
+ {
+ return "OP_vkGetImageMemoryRequirements2KHR";
+ }
+ case OP_vkGetBufferMemoryRequirements2KHR:
+ {
+ return "OP_vkGetBufferMemoryRequirements2KHR";
+ }
+ case OP_vkGetImageSparseMemoryRequirements2KHR:
+ {
+ return "OP_vkGetImageSparseMemoryRequirements2KHR";
+ }
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+ case OP_vkCreateSamplerYcbcrConversionKHR:
+ {
+ return "OP_vkCreateSamplerYcbcrConversionKHR";
+ }
+ case OP_vkDestroySamplerYcbcrConversionKHR:
+ {
+ return "OP_vkDestroySamplerYcbcrConversionKHR";
+ }
+#endif
+#ifdef VK_KHR_bind_memory2
+ case OP_vkBindBufferMemory2KHR:
+ {
+ return "OP_vkBindBufferMemory2KHR";
+ }
+ case OP_vkBindImageMemory2KHR:
+ {
+ return "OP_vkBindImageMemory2KHR";
+ }
+#endif
+#ifdef VK_KHR_maintenance3
+ case OP_vkGetDescriptorSetLayoutSupportKHR:
+ {
+ return "OP_vkGetDescriptorSetLayoutSupportKHR";
+ }
+#endif
+#ifdef VK_KHR_draw_indirect_count
+ case OP_vkCmdDrawIndirectCountKHR:
+ {
+ return "OP_vkCmdDrawIndirectCountKHR";
+ }
+ case OP_vkCmdDrawIndexedIndirectCountKHR:
+ {
+ return "OP_vkCmdDrawIndexedIndirectCountKHR";
+ }
+#endif
+#ifdef VK_ANDROID_native_buffer
+ case OP_vkGetSwapchainGrallocUsageANDROID:
+ {
+ return "OP_vkGetSwapchainGrallocUsageANDROID";
+ }
+ case OP_vkAcquireImageANDROID:
+ {
+ return "OP_vkAcquireImageANDROID";
+ }
+ case OP_vkQueueSignalReleaseImageANDROID:
+ {
+ return "OP_vkQueueSignalReleaseImageANDROID";
+ }
+#endif
+#ifdef VK_EXT_debug_report
+ case OP_vkCreateDebugReportCallbackEXT:
+ {
+ return "OP_vkCreateDebugReportCallbackEXT";
+ }
+ case OP_vkDestroyDebugReportCallbackEXT:
+ {
+ return "OP_vkDestroyDebugReportCallbackEXT";
+ }
+ case OP_vkDebugReportMessageEXT:
+ {
+ return "OP_vkDebugReportMessageEXT";
+ }
+#endif
+#ifdef VK_EXT_debug_marker
+ case OP_vkDebugMarkerSetObjectTagEXT:
+ {
+ return "OP_vkDebugMarkerSetObjectTagEXT";
+ }
+ case OP_vkDebugMarkerSetObjectNameEXT:
+ {
+ return "OP_vkDebugMarkerSetObjectNameEXT";
+ }
+ case OP_vkCmdDebugMarkerBeginEXT:
+ {
+ return "OP_vkCmdDebugMarkerBeginEXT";
+ }
+ case OP_vkCmdDebugMarkerEndEXT:
+ {
+ return "OP_vkCmdDebugMarkerEndEXT";
+ }
+ case OP_vkCmdDebugMarkerInsertEXT:
+ {
+ return "OP_vkCmdDebugMarkerInsertEXT";
+ }
+#endif
+#ifdef VK_AMD_draw_indirect_count
+ case OP_vkCmdDrawIndirectCountAMD:
+ {
+ return "OP_vkCmdDrawIndirectCountAMD";
+ }
+ case OP_vkCmdDrawIndexedIndirectCountAMD:
+ {
+ return "OP_vkCmdDrawIndexedIndirectCountAMD";
+ }
+#endif
+#ifdef VK_AMD_shader_info
+ case OP_vkGetShaderInfoAMD:
+ {
+ return "OP_vkGetShaderInfoAMD";
+ }
+#endif
+#ifdef VK_NV_external_memory_capabilities
+ case OP_vkGetPhysicalDeviceExternalImageFormatPropertiesNV:
+ {
+ return "OP_vkGetPhysicalDeviceExternalImageFormatPropertiesNV";
+ }
+#endif
+#ifdef VK_NV_external_memory_win32
+ case OP_vkGetMemoryWin32HandleNV:
+ {
+ return "OP_vkGetMemoryWin32HandleNV";
+ }
+#endif
+#ifdef VK_NN_vi_surface
+ case OP_vkCreateViSurfaceNN:
+ {
+ return "OP_vkCreateViSurfaceNN";
+ }
+#endif
+#ifdef VK_EXT_conditional_rendering
+ case OP_vkCmdBeginConditionalRenderingEXT:
+ {
+ return "OP_vkCmdBeginConditionalRenderingEXT";
+ }
+ case OP_vkCmdEndConditionalRenderingEXT:
+ {
+ return "OP_vkCmdEndConditionalRenderingEXT";
+ }
+#endif
+#ifdef VK_NVX_device_generated_commands
+ case OP_vkCmdProcessCommandsNVX:
+ {
+ return "OP_vkCmdProcessCommandsNVX";
+ }
+ case OP_vkCmdReserveSpaceForCommandsNVX:
+ {
+ return "OP_vkCmdReserveSpaceForCommandsNVX";
+ }
+ case OP_vkCreateIndirectCommandsLayoutNVX:
+ {
+ return "OP_vkCreateIndirectCommandsLayoutNVX";
+ }
+ case OP_vkDestroyIndirectCommandsLayoutNVX:
+ {
+ return "OP_vkDestroyIndirectCommandsLayoutNVX";
+ }
+ case OP_vkCreateObjectTableNVX:
+ {
+ return "OP_vkCreateObjectTableNVX";
+ }
+ case OP_vkDestroyObjectTableNVX:
+ {
+ return "OP_vkDestroyObjectTableNVX";
+ }
+ case OP_vkRegisterObjectsNVX:
+ {
+ return "OP_vkRegisterObjectsNVX";
+ }
+ case OP_vkUnregisterObjectsNVX:
+ {
+ return "OP_vkUnregisterObjectsNVX";
+ }
+ case OP_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX:
+ {
+ return "OP_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX";
+ }
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+ case OP_vkCmdSetViewportWScalingNV:
+ {
+ return "OP_vkCmdSetViewportWScalingNV";
+ }
+#endif
+#ifdef VK_EXT_direct_mode_display
+ case OP_vkReleaseDisplayEXT:
+ {
+ return "OP_vkReleaseDisplayEXT";
+ }
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+ case OP_vkAcquireXlibDisplayEXT:
+ {
+ return "OP_vkAcquireXlibDisplayEXT";
+ }
+ case OP_vkGetRandROutputDisplayEXT:
+ {
+ return "OP_vkGetRandROutputDisplayEXT";
+ }
+#endif
+#ifdef VK_EXT_display_surface_counter
+ case OP_vkGetPhysicalDeviceSurfaceCapabilities2EXT:
+ {
+ return "OP_vkGetPhysicalDeviceSurfaceCapabilities2EXT";
+ }
+#endif
+#ifdef VK_EXT_display_control
+ case OP_vkDisplayPowerControlEXT:
+ {
+ return "OP_vkDisplayPowerControlEXT";
+ }
+ case OP_vkRegisterDeviceEventEXT:
+ {
+ return "OP_vkRegisterDeviceEventEXT";
+ }
+ case OP_vkRegisterDisplayEventEXT:
+ {
+ return "OP_vkRegisterDisplayEventEXT";
+ }
+ case OP_vkGetSwapchainCounterEXT:
+ {
+ return "OP_vkGetSwapchainCounterEXT";
+ }
+#endif
+#ifdef VK_GOOGLE_display_timing
+ case OP_vkGetRefreshCycleDurationGOOGLE:
+ {
+ return "OP_vkGetRefreshCycleDurationGOOGLE";
+ }
+ case OP_vkGetPastPresentationTimingGOOGLE:
+ {
+ return "OP_vkGetPastPresentationTimingGOOGLE";
+ }
+#endif
+#ifdef VK_EXT_discard_rectangles
+ case OP_vkCmdSetDiscardRectangleEXT:
+ {
+ return "OP_vkCmdSetDiscardRectangleEXT";
+ }
+#endif
+#ifdef VK_EXT_hdr_metadata
+ case OP_vkSetHdrMetadataEXT:
+ {
+ return "OP_vkSetHdrMetadataEXT";
+ }
+#endif
+#ifdef VK_MVK_ios_surface
+ case OP_vkCreateIOSSurfaceMVK:
+ {
+ return "OP_vkCreateIOSSurfaceMVK";
+ }
+#endif
+#ifdef VK_MVK_macos_surface
+ case OP_vkCreateMacOSSurfaceMVK:
+ {
+ return "OP_vkCreateMacOSSurfaceMVK";
+ }
+#endif
+#ifdef VK_EXT_debug_utils
+ case OP_vkSetDebugUtilsObjectNameEXT:
+ {
+ return "OP_vkSetDebugUtilsObjectNameEXT";
+ }
+ case OP_vkSetDebugUtilsObjectTagEXT:
+ {
+ return "OP_vkSetDebugUtilsObjectTagEXT";
+ }
+ case OP_vkQueueBeginDebugUtilsLabelEXT:
+ {
+ return "OP_vkQueueBeginDebugUtilsLabelEXT";
+ }
+ case OP_vkQueueEndDebugUtilsLabelEXT:
+ {
+ return "OP_vkQueueEndDebugUtilsLabelEXT";
+ }
+ case OP_vkQueueInsertDebugUtilsLabelEXT:
+ {
+ return "OP_vkQueueInsertDebugUtilsLabelEXT";
+ }
+ case OP_vkCmdBeginDebugUtilsLabelEXT:
+ {
+ return "OP_vkCmdBeginDebugUtilsLabelEXT";
+ }
+ case OP_vkCmdEndDebugUtilsLabelEXT:
+ {
+ return "OP_vkCmdEndDebugUtilsLabelEXT";
+ }
+ case OP_vkCmdInsertDebugUtilsLabelEXT:
+ {
+ return "OP_vkCmdInsertDebugUtilsLabelEXT";
+ }
+ case OP_vkCreateDebugUtilsMessengerEXT:
+ {
+ return "OP_vkCreateDebugUtilsMessengerEXT";
+ }
+ case OP_vkDestroyDebugUtilsMessengerEXT:
+ {
+ return "OP_vkDestroyDebugUtilsMessengerEXT";
+ }
+ case OP_vkSubmitDebugUtilsMessageEXT:
+ {
+ return "OP_vkSubmitDebugUtilsMessageEXT";
+ }
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+ case OP_vkGetAndroidHardwareBufferPropertiesANDROID:
+ {
+ return "OP_vkGetAndroidHardwareBufferPropertiesANDROID";
+ }
+ case OP_vkGetMemoryAndroidHardwareBufferANDROID:
+ {
+ return "OP_vkGetMemoryAndroidHardwareBufferANDROID";
+ }
+#endif
+#ifdef VK_EXT_sample_locations
+ case OP_vkCmdSetSampleLocationsEXT:
+ {
+ return "OP_vkCmdSetSampleLocationsEXT";
+ }
+ case OP_vkGetPhysicalDeviceMultisamplePropertiesEXT:
+ {
+ return "OP_vkGetPhysicalDeviceMultisamplePropertiesEXT";
+ }
+#endif
+#ifdef VK_EXT_validation_cache
+ case OP_vkCreateValidationCacheEXT:
+ {
+ return "OP_vkCreateValidationCacheEXT";
+ }
+ case OP_vkDestroyValidationCacheEXT:
+ {
+ return "OP_vkDestroyValidationCacheEXT";
+ }
+ case OP_vkMergeValidationCachesEXT:
+ {
+ return "OP_vkMergeValidationCachesEXT";
+ }
+ case OP_vkGetValidationCacheDataEXT:
+ {
+ return "OP_vkGetValidationCacheDataEXT";
+ }
+#endif
+#ifdef VK_EXT_external_memory_host
+ case OP_vkGetMemoryHostPointerPropertiesEXT:
+ {
+ return "OP_vkGetMemoryHostPointerPropertiesEXT";
+ }
+#endif
+#ifdef VK_AMD_buffer_marker
+ case OP_vkCmdWriteBufferMarkerAMD:
+ {
+ return "OP_vkCmdWriteBufferMarkerAMD";
+ }
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+ case OP_vkCmdSetCheckpointNV:
+ {
+ return "OP_vkCmdSetCheckpointNV";
+ }
+ case OP_vkGetQueueCheckpointDataNV:
+ {
+ return "OP_vkGetQueueCheckpointDataNV";
+ }
+#endif
+#ifdef VK_GOOGLE_address_space
+ case OP_vkMapMemoryIntoAddressSpaceGOOGLE:
+ {
+ return "OP_vkMapMemoryIntoAddressSpaceGOOGLE";
+ }
+#endif
+#ifdef VK_GOOGLE_color_buffer
+ case OP_vkRegisterImageColorBufferGOOGLE:
+ {
+ return "OP_vkRegisterImageColorBufferGOOGLE";
+ }
+ case OP_vkRegisterBufferColorBufferGOOGLE:
+ {
+ return "OP_vkRegisterBufferColorBufferGOOGLE";
+ }
+#endif
+#ifdef VK_GOOGLE_sized_descriptor_update_template
+ case OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE:
+ {
+ return "OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE";
+ }
+#endif
+#ifdef VK_GOOGLE_async_command_buffers
+ case OP_vkBeginCommandBufferAsyncGOOGLE:
+ {
+ return "OP_vkBeginCommandBufferAsyncGOOGLE";
+ }
+ case OP_vkEndCommandBufferAsyncGOOGLE:
+ {
+ return "OP_vkEndCommandBufferAsyncGOOGLE";
+ }
+ case OP_vkResetCommandBufferAsyncGOOGLE:
+ {
+ return "OP_vkResetCommandBufferAsyncGOOGLE";
+ }
+ case OP_vkCommandBufferHostSyncGOOGLE:
+ {
+ return "OP_vkCommandBufferHostSyncGOOGLE";
+ }
+#endif
+#ifdef VK_GOOGLE_create_resources_with_requirements
+ case OP_vkCreateImageWithRequirementsGOOGLE:
+ {
+ return "OP_vkCreateImageWithRequirementsGOOGLE";
+ }
+ case OP_vkCreateBufferWithRequirementsGOOGLE:
+ {
+ return "OP_vkCreateBufferWithRequirementsGOOGLE";
+ }
+#endif
+ default:
+ {
+ return "OP_UNKNOWN_API_CALL";
+ }
+ }
+}
+
} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.h b/system/vulkan_enc/goldfish_vk_marshaling_guest.h
index 283e0ad..ad7f8f3 100644
--- a/system/vulkan_enc/goldfish_vk_marshaling_guest.h
+++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.h
@@ -3388,6 +3388,14 @@
#define OP_vkBeginCommandBufferAsyncGOOGLE 20321
#define OP_vkEndCommandBufferAsyncGOOGLE 20322
#define OP_vkResetCommandBufferAsyncGOOGLE 20323
+#define OP_vkCommandBufferHostSyncGOOGLE 20324
#endif
+#ifdef VK_GOOGLE_create_resources_with_requirements
+#define OP_vkCreateImageWithRequirementsGOOGLE 20325
+#define OP_vkCreateBufferWithRequirementsGOOGLE 20326
+#endif
+const char* api_opcode_to_string(
+ const uint32_t opcode);
+
} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_private_defs.h b/system/vulkan_enc/goldfish_vk_private_defs.h
index 35d4425..21eb730 100644
--- a/system/vulkan_enc/goldfish_vk_private_defs.h
+++ b/system/vulkan_enc/goldfish_vk_private_defs.h
@@ -424,6 +424,15 @@
typedef void (VKAPI_PTR *PFN_vkResetCommandBufferAsyncGOOGLE)(
VkCommandBuffer commandBuffer,
VkCommandBufferResetFlags flags);
+typedef void (VKAPI_PTR *PFN_vkCommandBufferHostSyncGOOGLE)(
+ VkCommandBuffer commandBuffer,
+ uint32_t needHostSync,
+ uint32_t sequenceNumber);
+
+#define VK_GOOGLE_create_resources_with_requirements 1
+
+typedef void (VKAPI_PTR *PFN_vkCreateImageWithRequirementsGOOGLE)(
+ VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage, VkMemoryRequirements* pMemoryRequirements);
#ifndef VK_FUCHSIA_buffer_collection
#define VK_FUCHSIA_buffer_collection 1
@@ -523,6 +532,11 @@
((VkExternalSemaphoreHandleTypeFlagBits)0x00100000)
#endif // VK_FUCHSIA_external_semaphore
+// VulkanStream features
+#define VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT (1 << 0)
+
+#define VK_YCBCR_CONVERSION_DO_NOTHING ((VkSamplerYcbcrConversion)0x1111111111111111)
+
#ifdef __cplusplus
} // extern "C"
#endif
diff --git a/system/vulkan_enc/goldfish_vk_transform_guest.cpp b/system/vulkan_enc/goldfish_vk_transform_guest.cpp
index aa42af7..d06135e 100644
--- a/system/vulkan_enc/goldfish_vk_transform_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_transform_guest.cpp
@@ -8945,6 +8945,8 @@
#endif
#ifdef VK_GOOGLE_async_command_buffers
#endif
+#ifdef VK_GOOGLE_create_resources_with_requirements
+#endif
void transform_tohost_extension_struct(
ResourceTracker* resourceTracker,
void* structExtension_out)
diff --git a/system/vulkan_enc/goldfish_vk_transform_guest.h b/system/vulkan_enc/goldfish_vk_transform_guest.h
index 754c033..217284e 100644
--- a/system/vulkan_enc/goldfish_vk_transform_guest.h
+++ b/system/vulkan_enc/goldfish_vk_transform_guest.h
@@ -3067,5 +3067,7 @@
#endif
#ifdef VK_GOOGLE_async_command_buffers
#endif
+#ifdef VK_GOOGLE_create_resources_with_requirements
+#endif
} // namespace goldfish_vk
diff --git a/system/vulkan_enc/vk_struct_id.h b/system/vulkan_enc/vk_struct_id.h
index 561b430..9721900 100644
--- a/system/vulkan_enc/vk_struct_id.h
+++ b/system/vulkan_enc/vk_struct_id.h
@@ -46,5 +46,7 @@
REGISTER_VK_STRUCT_ID(VkImportMemoryBufferCollectionFUCHSIA, VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA);
REGISTER_VK_STRUCT_ID(VkImportMemoryZirconHandleInfoFUCHSIA, VK_STRUCTURE_TYPE_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA);
REGISTER_VK_STRUCT_ID(VkBufferCollectionImageCreateInfoFUCHSIA, VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA);
+REGISTER_VK_STRUCT_ID(VkSamplerCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);
+REGISTER_VK_STRUCT_ID(VkSamplerYcbcrConversionInfo, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO);
#undef REGISTER_VK_STRUCT_ID
