Merge "Remove no-op transform*MemoryTypeBits*() functions"
diff --git a/OWNERS b/OWNERS
index f2fc3cd..ec67e03 100644
--- a/OWNERS
+++ b/OWNERS
@@ -5,6 +5,7 @@
kaiyili@google.com
lfy@google.com
liyl@google.com
+msandy@google.com
natsu@google.com
rkir@google.com
tutankhamen@google.com
diff --git a/meson.build b/meson.build
index 05ef561..8e2c9a6 100644
--- a/meson.build
+++ b/meson.build
@@ -60,6 +60,7 @@
# Subdirectories #
#================#
+subdir('third-party')
subdir('fuchsia')
subdir('platform')
subdir('android-emu/aemu/base')
diff --git a/platform/include/VirtGpu.h b/platform/include/VirtGpu.h
index 6bf976d..bfa3f37 100644
--- a/platform/include/VirtGpu.h
+++ b/platform/include/VirtGpu.h
@@ -19,6 +19,8 @@
#include <cstdint>
#include <memory>
+#include "virtgpu_gfxstream_protocol.h"
+
enum VirtGpuParamId {
kParam3D,
kParamCapsetFix,
@@ -157,6 +159,7 @@
static VirtGpuDevice mInstance;
int64_t mDeviceHandle;
struct VirtGpuParam mParams[kParamMax];
+ struct gfxstreamCapset mGfxstreamCapset;
};
// HACK: We can use android::base::EnumFlags, but we'll have to do more guest
diff --git a/platform/include/virtgpu_gfxstream_protocol.h b/platform/include/virtgpu_gfxstream_protocol.h
index 6bf26a2..325fa9c 100644
--- a/platform/include/virtgpu_gfxstream_protocol.h
+++ b/platform/include/virtgpu_gfxstream_protocol.h
@@ -65,4 +65,14 @@
uint32_t imageHandleHi;
};
+struct gfxstreamCapset {
+ uint32_t protocolVersion;
+
+ // ASG Ring Parameters
+ uint32_t ringSize;
+ uint32_t bufferSize;
+
+ uint32_t pad;
+};
+
#endif
diff --git a/platform/linux/VirtGpuDevice.cpp b/platform/linux/VirtGpuDevice.cpp
index 6f4f86c..8faece4 100644
--- a/platform/linux/VirtGpuDevice.cpp
+++ b/platform/linux/VirtGpuDevice.cpp
@@ -25,6 +25,7 @@
#include "VirtGpu.h"
#include "virtgpu_drm.h"
+#include "virtgpu_gfxstream_protocol.h"
#define PARAM(x) \
(struct VirtGpuParam) { x, #x, 0 }
@@ -48,6 +49,7 @@
};
int ret;
+ struct drm_virtgpu_get_caps get_caps = {0};
struct drm_virtgpu_context_init init = {0};
struct drm_virtgpu_context_set_param ctx_set_params[2] = {{0}};
@@ -62,7 +64,7 @@
get_param.param = params[i].param;
get_param.value = (uint64_t)(uintptr_t)¶ms[i].value;
- int ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_GETPARAM, &get_param);
+ ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_GETPARAM, &get_param);
if (ret) {
ALOGE("virtgpu backend not enabling %s", params[i].name);
}
@@ -70,6 +72,19 @@
mParams[i] = params[i];
}
+ get_caps.cap_set_id = static_cast<uint32_t>(capset);
+ if (capset == kCapsetGfxStream) {
+ get_caps.size = sizeof(struct gfxstreamCapset);
+ get_caps.addr = (unsigned long long)&mGfxstreamCapset;
+ }
+
+ ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_GET_CAPS, &get_caps);
+ if (ret) {
+ // Don't fail get capabilities just yet, AEMU doesn't use this API
+ // yet (b/272121235);
+ ALOGE("DRM_IOCTL_VIRTGPU_GET_CAPS failed with %s", strerror(errno));
+ }
+
ctx_set_params[0].param = VIRTGPU_CONTEXT_PARAM_NUM_RINGS;
ctx_set_params[0].value = 1;
diff --git a/system/GLESv2_enc/IOStream2.cpp b/system/GLESv2_enc/IOStream2.cpp
index cf292ea..2a704b7 100644
--- a/system/GLESv2_enc/IOStream2.cpp
+++ b/system/GLESv2_enc/IOStream2.cpp
@@ -51,7 +51,7 @@
char* start = (char*)pixels + startOffset;
for (int i = 0; i < height; i++) {
- if (pixelRowSize != width * bpp) {
+ if (pixelRowSize > width * bpp) {
size_t rowSlack = pixelRowSize - width * bpp;
std::vector<char> rowSlackToDiscard(rowSlack, 0);
readback(start, width * bpp);
@@ -111,7 +111,7 @@
char* start = (char*)pixels + startOffset;
for (int i = 0; i < height; i++) {
- if (pixelRowSize != width * bpp) {
+ if (pixelRowSize > width * bpp) {
size_t rowSlack = pixelRowSize - width * bpp;
std::vector<char> rowSlackToDiscard(rowSlack, 0);
writeFully(start, width * bpp);
@@ -174,15 +174,14 @@
char* start = (char*)pixels + startOffset;
- size_t rowSlack = pixelRowSize - width * bpp;
- std::vector<char> rowSlackToDiscard(rowSlack, 0);
-
size_t imageSlack = totalImageSize - pixelImageSize;
std::vector<char> imageSlackToDiscard(imageSlack, 0);
for (int k = 0; k < depth; ++k) {
for (int i = 0; i < height; i++) {
- if (pixelRowSize != width * bpp) {
+ if (pixelRowSize > width * bpp) {
+ size_t rowSlack = pixelRowSize - width * bpp;
+ std::vector<char> rowSlackToDiscard(rowSlack, 0);
writeFully(start, width * bpp);
writeFully(&rowSlackToDiscard[0], rowSlack);
writeFully(&paddingToDiscard[0], paddingSize);
diff --git a/system/codecs/omx/avcdec/GoldfishAVCDec.cpp b/system/codecs/omx/avcdec/GoldfishAVCDec.cpp
index d90241d..02c0dc1 100644
--- a/system/codecs/omx/avcdec/GoldfishAVCDec.cpp
+++ b/system/codecs/omx/avcdec/GoldfishAVCDec.cpp
@@ -360,7 +360,6 @@
}
{
- nsecs_t timeDelay, timeTaken;
if (!setDecodeArgs(inHeader, outHeader)) {
ALOGE("Decoder arg setup failed");
@@ -369,11 +368,6 @@
return;
}
- mTimeStart = systemTime();
- /* Compute time elapsed between end of previous decode()
- * to start of current decode() */
- timeDelay = mTimeStart - mTimeEnd;
-
// TODO: We also need to send the timestamp
h264_result_t h264Res = {(int)MediaH264Decoder::Err::NoErr, 0};
if (inHeader != nullptr) {
@@ -417,10 +411,6 @@
getVUIParams(img);
}
- mTimeEnd = systemTime();
- /* Compute time taken for decode() */
- timeTaken = mTimeEnd - mTimeStart;
-
if (inHeader) {
DDD("input time stamp %lld flag %d", inHeader->nTimeStamp, (int)(inHeader->nFlags));
diff --git a/system/magma/magma.cpp b/system/magma/magma.cpp
new file mode 100644
index 0000000..65a5a6c
--- /dev/null
+++ b/system/magma/magma.cpp
@@ -0,0 +1,351 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <assert.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <virtgpu_drm.h>
+#include <xf86drm.h>
+
+#include <limits>
+#include <mutex>
+#include <thread>
+
+#include "AddressSpaceStream.h"
+#include "EncoderDebug.h"
+#include "magma_enc.h"
+
+static uint64_t get_ns_monotonic(bool raw) {
+ struct timespec time;
+ int ret = clock_gettime(raw ? CLOCK_MONOTONIC_RAW : CLOCK_MONOTONIC, &time);
+ if (ret < 0) return 0;
+ return static_cast<uint64_t>(time.tv_sec) * 1000000000ULL + time.tv_nsec;
+}
+
+class MagmaClientContext : public magma_encoder_context_t {
+ public:
+ MagmaClientContext(AddressSpaceStream* stream);
+
+ AddressSpaceStream* stream() {
+ return reinterpret_cast<AddressSpaceStream*>(magma_encoder_context_t::m_stream);
+ }
+
+ magma_status_t get_fd_for_buffer(magma_buffer_t buffer, int* fd_out);
+
+ std::mutex& mutex() { return m_mutex_; }
+
+ static magma_status_t magma_device_import(void* self, magma_handle_t device_channel,
+ magma_device_t* device_out);
+ static magma_status_t magma_device_query(void* self, magma_device_t device, uint64_t id,
+ magma_handle_t* handle_out, uint64_t* value_out);
+ static magma_status_t magma_connection_export_buffer(void* self, magma_connection_t connection,
+ magma_buffer_t buffer,
+ magma_handle_t* handle_out);
+ static magma_status_t magma_poll(void* self, magma_poll_item_t* items, uint32_t count,
+ uint64_t timeout_ns);
+
+ static void set_thread_local_context_lock(std::unique_lock<std::mutex>* lock) { t_lock = lock; }
+
+ static std::unique_lock<std::mutex>* get_thread_local_context_lock() { return t_lock; }
+
+ magma_device_import_client_proc_t magma_device_import_enc_;
+ magma_device_query_client_proc_t magma_device_query_enc_;
+ magma_poll_client_proc_t magma_poll_enc_;
+
+ int render_node_fd_;
+
+ std::mutex m_mutex_;
+ static thread_local std::unique_lock<std::mutex>* t_lock;
+};
+
+// This makes the mutex lock available to decoding methods that can take time
+// (eg magma_poll), to prevent one thread from locking out others.
+class ContextLock {
+ public:
+ ContextLock(MagmaClientContext* context) : m_context_(context), m_lock_(context->mutex()) {
+ m_context_->set_thread_local_context_lock(&m_lock_);
+ }
+
+ ~ContextLock() { m_context_->set_thread_local_context_lock(nullptr); }
+
+ private:
+ MagmaClientContext* m_context_;
+ std::unique_lock<std::mutex> m_lock_;
+};
+
+// static
+thread_local std::unique_lock<std::mutex>* MagmaClientContext::t_lock;
+
+MagmaClientContext::MagmaClientContext(AddressSpaceStream* stream)
+ : magma_encoder_context_t(stream, new ChecksumCalculator) {
+ magma_device_import_enc_ = magma_client_context_t::magma_device_import;
+ magma_device_query_enc_ = magma_client_context_t::magma_device_query;
+ magma_poll_enc_ = magma_client_context_t::magma_poll;
+
+ magma_client_context_t::magma_device_import = &MagmaClientContext::magma_device_import;
+ magma_client_context_t::magma_device_query = &MagmaClientContext::magma_device_query;
+ magma_client_context_t::magma_connection_export_buffer =
+ &MagmaClientContext::magma_connection_export_buffer;
+ magma_client_context_t::magma_poll = &MagmaClientContext::magma_poll;
+}
+
+// static
+magma_status_t MagmaClientContext::magma_device_import(void* self, magma_handle_t device_channel,
+ magma_device_t* device_out) {
+ auto context = reinterpret_cast<MagmaClientContext*>(self);
+
+ magma_handle_t placeholder = 0xacbd1234; // not used
+
+ magma_status_t status = context->magma_device_import_enc_(self, placeholder, device_out);
+
+ // The local fd isn't needed, just close it.
+ int fd = device_channel;
+ close(fd);
+
+ return status;
+}
+
+magma_status_t MagmaClientContext::get_fd_for_buffer(magma_buffer_t buffer, int* fd_out) {
+ // TODO(b/272555972): remove deprecated magma API use
+ uint64_t id = magma_buffer_get_id(this, buffer);
+ if (id == 0) {
+ ALOGE("%s: magma_get_buffer_id failed\n", __func__);
+ return MAGMA_STATUS_INVALID_ARGS;
+ }
+
+ uint64_t size = magma_buffer_get_size(this, buffer);
+ if (size == 0) {
+ ALOGE("%s: magma_get_buffer_size failed\n", __func__);
+ return MAGMA_STATUS_INVALID_ARGS;
+ }
+
+ // TODO(fxbug.dev/122604): Evaluate deferred guest resource creation.
+ auto blob = VirtGpuDevice::getInstance(VirtGpuCapset::kCapsetGfxStream)
+ .createBlob({.size = size,
+ .flags = kBlobFlagMappable | kBlobFlagShareable,
+ .blobMem = kBlobMemHost3d,
+ .blobId = id});
+ if (!blob) {
+ return MAGMA_STATUS_INTERNAL_ERROR;
+ }
+
+ VirtGpuExternalHandle handle{};
+ int result = blob->exportBlob(handle);
+ if (result != 0 || handle.osHandle < 0) {
+ return MAGMA_STATUS_INTERNAL_ERROR;
+ }
+
+ *fd_out = handle.osHandle;
+
+ return MAGMA_STATUS_OK;
+}
+
+magma_status_t MagmaClientContext::magma_device_query(void* self, magma_device_t device,
+ uint64_t id, magma_handle_t* handle_out,
+ uint64_t* value_out) {
+ auto context = reinterpret_cast<MagmaClientContext*>(self);
+
+ magma_buffer_t buffer = 0;
+ uint64_t value = 0;
+ {
+ magma_handle_t handle;
+ magma_status_t status = context->magma_device_query_enc_(self, device, id, &handle, &value);
+ if (status != MAGMA_STATUS_OK) {
+ ALOGE("magma_device_query_enc failed: %d\n", status);
+ return status;
+ }
+ // magma_buffer_t and magma_handle_t are both gem_handles on the server.
+ buffer = handle;
+ }
+
+ if (!buffer) {
+ if (!value_out) return MAGMA_STATUS_INVALID_ARGS;
+
+ *value_out = value;
+
+ if (handle_out) {
+ *handle_out = -1;
+ }
+
+ return MAGMA_STATUS_OK;
+ }
+
+ if (!handle_out) return MAGMA_STATUS_INVALID_ARGS;
+
+ int fd;
+ magma_status_t status = context->get_fd_for_buffer(buffer, &fd);
+ if (status != MAGMA_STATUS_OK) return status;
+
+ *handle_out = fd;
+
+ return MAGMA_STATUS_OK;
+}
+
+magma_status_t MagmaClientContext::magma_connection_export_buffer(void* self,
+ magma_connection_t connection,
+ magma_buffer_t buffer,
+ magma_handle_t* handle_out) {
+ auto context = reinterpret_cast<MagmaClientContext*>(self);
+
+ int fd;
+ magma_status_t status = context->get_fd_for_buffer(buffer, &fd);
+ if (status != MAGMA_STATUS_OK) return status;
+
+ *handle_out = fd;
+
+ return MAGMA_STATUS_OK;
+}
+
+// We can't pass a non-zero timeout to the server, as that would block the server from handling
+// requests from other threads. So we busy wait here, which isn't ideal; however if the server did
+// block, gfxstream would busy wait for the response anyway.
+magma_status_t MagmaClientContext::magma_poll(void* self, magma_poll_item_t* items, uint32_t count,
+ uint64_t timeout_ns) {
+ auto context = reinterpret_cast<MagmaClientContext*>(self);
+
+ int64_t time_start = static_cast<int64_t>(get_ns_monotonic(false));
+
+ int64_t abs_timeout_ns = time_start + timeout_ns;
+
+ if (abs_timeout_ns < time_start) {
+ abs_timeout_ns = std::numeric_limits<int64_t>::max();
+ }
+
+ bool warned_for_long_poll = false;
+
+ while (true) {
+ magma_status_t status = context->magma_poll_enc_(self, items, count, 0);
+
+ if (status != MAGMA_STATUS_TIMED_OUT) return status;
+
+ // Not ready, allow other threads to work in with us
+ get_thread_local_context_lock()->unlock();
+
+ std::this_thread::yield();
+
+ int64_t time_now = static_cast<int64_t>(get_ns_monotonic(false));
+
+ // TODO(fxb/122604): Add back-off to the busy loop, ideally based on recent sleep
+ // patterns (e.g. start polling shortly before next expected burst).
+ if (!warned_for_long_poll && time_now - time_start > 5000000000) {
+ ALOGE("magma_poll: long poll detected (%lu us)", (time_now - time_start) / 1000);
+ warned_for_long_poll = true;
+ }
+
+ if (time_now >= abs_timeout_ns) break;
+
+ get_thread_local_context_lock()->lock();
+ }
+
+ return MAGMA_STATUS_TIMED_OUT;
+}
+
+template <typename T, typename U>
+static T SafeCast(const U& value) {
+ if (value > std::numeric_limits<T>::max() || value < std::numeric_limits<T>::min()) {
+ abort();
+ }
+ return static_cast<T>(value);
+}
+
+// We have a singleton client context for all threads. We want all client
+// threads served by a single server RenderThread.
+MagmaClientContext* GetMagmaContext() {
+ static MagmaClientContext* s_context;
+ static std::once_flag once_flag;
+
+ std::call_once(once_flag, []() {
+ auto stream = createVirtioGpuAddressSpaceStream(nullptr);
+ assert(stream);
+
+ // RenderThread expects flags: send zero 'clientFlags' to the host.
+ {
+ auto pClientFlags =
+ reinterpret_cast<unsigned int*>(stream->allocBuffer(sizeof(unsigned int)));
+ *pClientFlags = 0;
+ stream->commitBuffer(sizeof(unsigned int));
+ }
+
+ s_context = new MagmaClientContext(stream);
+ auto render_node_fd =
+ VirtGpuDevice::getInstance(VirtGpuCapset::kCapsetGfxStream).getDeviceHandle();
+ s_context->render_node_fd_ = SafeCast<int>(render_node_fd);
+
+ ALOGE("Created new context\n");
+ fflush(stdout);
+ });
+
+ return s_context;
+}
+
+// Used in magma_entry.cpp
+// Always lock around the encoding methods because we have a singleton context.
+#define GET_CONTEXT \
+ MagmaClientContext* ctx = GetMagmaContext(); \
+ ContextLock lock(ctx)
+
+#include "magma_entry.cpp"
+
+// Stubs
+extern "C" {
+
+magma_status_t magma_execute_immediate_commands2(
+ magma_connection_t connection, uint32_t context_id, uint64_t command_count,
+ struct magma_inline_command_buffer* command_buffers) {
+ return MAGMA_STATUS_UNIMPLEMENTED;
+}
+
+magma_status_t magma_export(magma_connection_t connection, magma_buffer_t buffer,
+ magma_handle_t* buffer_handle_out) {
+ return MAGMA_STATUS_UNIMPLEMENTED;
+}
+
+magma_status_t magma_import(magma_connection_t connection, magma_handle_t buffer_handle,
+ magma_buffer_t* buffer_out) {
+ return MAGMA_STATUS_UNIMPLEMENTED;
+}
+
+magma_status_t magma_export_semaphore(magma_connection_t connection, magma_semaphore_t semaphore,
+ magma_handle_t* semaphore_handle_out) {
+ return MAGMA_STATUS_UNIMPLEMENTED;
+}
+
+magma_status_t magma_import_semaphore(magma_connection_t connection,
+ magma_handle_t semaphore_handle,
+ magma_semaphore_t* semaphore_out) {
+ return MAGMA_STATUS_UNIMPLEMENTED;
+}
+
+magma_status_t magma_virt_create_image(magma_connection_t connection,
+ magma_image_create_info_t* create_info,
+ magma_buffer_t* image_out) {
+ return MAGMA_STATUS_UNIMPLEMENTED;
+}
+
+magma_status_t magma_virt_get_image_info(magma_connection_t connection, magma_buffer_t image,
+ magma_image_info_t* image_info_out) {
+ return MAGMA_STATUS_UNIMPLEMENTED;
+}
+
+magma_status_t magma_buffer_range_op(magma_connection_t connection, magma_buffer_t buffer,
+ uint32_t options, uint64_t start_offset, uint64_t length) {
+ return MAGMA_STATUS_UNIMPLEMENTED;
+}
+
+magma_status_t magma_flush(magma_connection_t connection) { return MAGMA_STATUS_UNIMPLEMENTED; }
+}
diff --git a/system/magma/magma_enc/magma_client_context.cpp b/system/magma/magma_enc/magma_client_context.cpp
new file mode 100644
index 0000000..80ca212
--- /dev/null
+++ b/system/magma/magma_enc/magma_client_context.cpp
@@ -0,0 +1,64 @@
+// Generated Code - DO NOT EDIT !!
+// generated by 'emugen'
+
+
+#include <string.h>
+#include "magma_client_context.h"
+
+
+#include <stdio.h>
+
+int magma_client_context_t::initDispatchByName(void *(*getProc)(const char *, void *userData), void *userData)
+{
+ magma_device_import = (magma_device_import_client_proc_t) getProc("magma_device_import", userData);
+ magma_device_release = (magma_device_release_client_proc_t) getProc("magma_device_release", userData);
+ magma_device_query = (magma_device_query_client_proc_t) getProc("magma_device_query", userData);
+ magma_device_create_connection = (magma_device_create_connection_client_proc_t) getProc("magma_device_create_connection", userData);
+ magma_connection_release = (magma_connection_release_client_proc_t) getProc("magma_connection_release", userData);
+ magma_connection_get_error = (magma_connection_get_error_client_proc_t) getProc("magma_connection_get_error", userData);
+ magma_connection_create_context = (magma_connection_create_context_client_proc_t) getProc("magma_connection_create_context", userData);
+ magma_connection_release_context = (magma_connection_release_context_client_proc_t) getProc("magma_connection_release_context", userData);
+ magma_connection_create_buffer = (magma_connection_create_buffer_client_proc_t) getProc("magma_connection_create_buffer", userData);
+ magma_connection_release_buffer = (magma_connection_release_buffer_client_proc_t) getProc("magma_connection_release_buffer", userData);
+ magma_connection_export_buffer = (magma_connection_export_buffer_client_proc_t) getProc("magma_connection_export_buffer", userData);
+ magma_connection_import_buffer = (magma_connection_import_buffer_client_proc_t) getProc("magma_connection_import_buffer", userData);
+ magma_connection_create_semaphore = (magma_connection_create_semaphore_client_proc_t) getProc("magma_connection_create_semaphore", userData);
+ magma_connection_release_semaphore = (magma_connection_release_semaphore_client_proc_t) getProc("magma_connection_release_semaphore", userData);
+ magma_connection_export_semaphore = (magma_connection_export_semaphore_client_proc_t) getProc("magma_connection_export_semaphore", userData);
+ magma_connection_import_semaphore = (magma_connection_import_semaphore_client_proc_t) getProc("magma_connection_import_semaphore", userData);
+ magma_connection_buffer_range_op = (magma_connection_buffer_range_op_client_proc_t) getProc("magma_connection_buffer_range_op", userData);
+ magma_connection_map_buffer = (magma_connection_map_buffer_client_proc_t) getProc("magma_connection_map_buffer", userData);
+ magma_connection_unmap_buffer = (magma_connection_unmap_buffer_client_proc_t) getProc("magma_connection_unmap_buffer", userData);
+ magma_connection_execute_command = (magma_connection_execute_command_client_proc_t) getProc("magma_connection_execute_command", userData);
+ magma_connection_execute_immediate_commands = (magma_connection_execute_immediate_commands_client_proc_t) getProc("magma_connection_execute_immediate_commands", userData);
+ magma_connection_flush = (magma_connection_flush_client_proc_t) getProc("magma_connection_flush", userData);
+ magma_connection_get_notification_channel_handle = (magma_connection_get_notification_channel_handle_client_proc_t) getProc("magma_connection_get_notification_channel_handle", userData);
+ magma_connection_read_notification_channel = (magma_connection_read_notification_channel_client_proc_t) getProc("magma_connection_read_notification_channel", userData);
+ magma_buffer_get_id = (magma_buffer_get_id_client_proc_t) getProc("magma_buffer_get_id", userData);
+ magma_buffer_get_size = (magma_buffer_get_size_client_proc_t) getProc("magma_buffer_get_size", userData);
+ magma_buffer_clean_cache = (magma_buffer_clean_cache_client_proc_t) getProc("magma_buffer_clean_cache", userData);
+ magma_buffer_set_cache_policy = (magma_buffer_set_cache_policy_client_proc_t) getProc("magma_buffer_set_cache_policy", userData);
+ magma_buffer_get_cache_policy = (magma_buffer_get_cache_policy_client_proc_t) getProc("magma_buffer_get_cache_policy", userData);
+ magma_buffer_set_name = (magma_buffer_set_name_client_proc_t) getProc("magma_buffer_set_name", userData);
+ magma_buffer_get_info = (magma_buffer_get_info_client_proc_t) getProc("magma_buffer_get_info", userData);
+ magma_buffer_get_handle = (magma_buffer_get_handle_client_proc_t) getProc("magma_buffer_get_handle", userData);
+ magma_semaphore_get_id = (magma_semaphore_get_id_client_proc_t) getProc("magma_semaphore_get_id", userData);
+ magma_semaphore_signal = (magma_semaphore_signal_client_proc_t) getProc("magma_semaphore_signal", userData);
+ magma_semaphore_reset = (magma_semaphore_reset_client_proc_t) getProc("magma_semaphore_reset", userData);
+ magma_poll = (magma_poll_client_proc_t) getProc("magma_poll", userData);
+ magma_initialize_tracing = (magma_initialize_tracing_client_proc_t) getProc("magma_initialize_tracing", userData);
+ magma_initialize_logging = (magma_initialize_logging_client_proc_t) getProc("magma_initialize_logging", userData);
+ magma_connection_enable_performance_counter_access = (magma_connection_enable_performance_counter_access_client_proc_t) getProc("magma_connection_enable_performance_counter_access", userData);
+ magma_connection_enable_performance_counters = (magma_connection_enable_performance_counters_client_proc_t) getProc("magma_connection_enable_performance_counters", userData);
+ magma_connection_create_performance_counter_buffer_pool = (magma_connection_create_performance_counter_buffer_pool_client_proc_t) getProc("magma_connection_create_performance_counter_buffer_pool", userData);
+ magma_connection_release_performance_counter_buffer_pool = (magma_connection_release_performance_counter_buffer_pool_client_proc_t) getProc("magma_connection_release_performance_counter_buffer_pool", userData);
+ magma_connection_add_performance_counter_buffer_offsets_to_pool = (magma_connection_add_performance_counter_buffer_offsets_to_pool_client_proc_t) getProc("magma_connection_add_performance_counter_buffer_offsets_to_pool", userData);
+ magma_connection_remove_performance_counter_buffer_from_pool = (magma_connection_remove_performance_counter_buffer_from_pool_client_proc_t) getProc("magma_connection_remove_performance_counter_buffer_from_pool", userData);
+ magma_connection_dump_performance_counters = (magma_connection_dump_performance_counters_client_proc_t) getProc("magma_connection_dump_performance_counters", userData);
+ magma_connection_clear_performance_counters = (magma_connection_clear_performance_counters_client_proc_t) getProc("magma_connection_clear_performance_counters", userData);
+ magma_connection_read_performance_counter_completion = (magma_connection_read_performance_counter_completion_client_proc_t) getProc("magma_connection_read_performance_counter_completion", userData);
+ magma_virt_connection_create_image = (magma_virt_connection_create_image_client_proc_t) getProc("magma_virt_connection_create_image", userData);
+ magma_virt_connection_get_image_info = (magma_virt_connection_get_image_info_client_proc_t) getProc("magma_virt_connection_get_image_info", userData);
+ return 0;
+}
+
diff --git a/system/magma/magma_enc/magma_client_context.h b/system/magma/magma_enc/magma_client_context.h
new file mode 100644
index 0000000..a7cf69b
--- /dev/null
+++ b/system/magma/magma_enc/magma_client_context.h
@@ -0,0 +1,71 @@
+// Generated Code - DO NOT EDIT !!
+// generated by 'emugen'
+#ifndef __magma_client_context_t_h
+#define __magma_client_context_t_h
+
+#include "magma_client_proc.h"
+
+#include "magma_types.h"
+
+
+struct magma_client_context_t {
+
+ magma_device_import_client_proc_t magma_device_import;
+ magma_device_release_client_proc_t magma_device_release;
+ magma_device_query_client_proc_t magma_device_query;
+ magma_device_create_connection_client_proc_t magma_device_create_connection;
+ magma_connection_release_client_proc_t magma_connection_release;
+ magma_connection_get_error_client_proc_t magma_connection_get_error;
+ magma_connection_create_context_client_proc_t magma_connection_create_context;
+ magma_connection_release_context_client_proc_t magma_connection_release_context;
+ magma_connection_create_buffer_client_proc_t magma_connection_create_buffer;
+ magma_connection_release_buffer_client_proc_t magma_connection_release_buffer;
+ magma_connection_export_buffer_client_proc_t magma_connection_export_buffer;
+ magma_connection_import_buffer_client_proc_t magma_connection_import_buffer;
+ magma_connection_create_semaphore_client_proc_t magma_connection_create_semaphore;
+ magma_connection_release_semaphore_client_proc_t magma_connection_release_semaphore;
+ magma_connection_export_semaphore_client_proc_t magma_connection_export_semaphore;
+ magma_connection_import_semaphore_client_proc_t magma_connection_import_semaphore;
+ magma_connection_buffer_range_op_client_proc_t magma_connection_buffer_range_op;
+ magma_connection_map_buffer_client_proc_t magma_connection_map_buffer;
+ magma_connection_unmap_buffer_client_proc_t magma_connection_unmap_buffer;
+ magma_connection_execute_command_client_proc_t magma_connection_execute_command;
+ magma_connection_execute_immediate_commands_client_proc_t magma_connection_execute_immediate_commands;
+ magma_connection_flush_client_proc_t magma_connection_flush;
+ magma_connection_get_notification_channel_handle_client_proc_t magma_connection_get_notification_channel_handle;
+ magma_connection_read_notification_channel_client_proc_t magma_connection_read_notification_channel;
+ magma_buffer_get_id_client_proc_t magma_buffer_get_id;
+ magma_buffer_get_size_client_proc_t magma_buffer_get_size;
+ magma_buffer_clean_cache_client_proc_t magma_buffer_clean_cache;
+ magma_buffer_set_cache_policy_client_proc_t magma_buffer_set_cache_policy;
+ magma_buffer_get_cache_policy_client_proc_t magma_buffer_get_cache_policy;
+ magma_buffer_set_name_client_proc_t magma_buffer_set_name;
+ magma_buffer_get_info_client_proc_t magma_buffer_get_info;
+ magma_buffer_get_handle_client_proc_t magma_buffer_get_handle;
+ magma_semaphore_get_id_client_proc_t magma_semaphore_get_id;
+ magma_semaphore_signal_client_proc_t magma_semaphore_signal;
+ magma_semaphore_reset_client_proc_t magma_semaphore_reset;
+ magma_poll_client_proc_t magma_poll;
+ magma_initialize_tracing_client_proc_t magma_initialize_tracing;
+ magma_initialize_logging_client_proc_t magma_initialize_logging;
+ magma_connection_enable_performance_counter_access_client_proc_t magma_connection_enable_performance_counter_access;
+ magma_connection_enable_performance_counters_client_proc_t magma_connection_enable_performance_counters;
+ magma_connection_create_performance_counter_buffer_pool_client_proc_t magma_connection_create_performance_counter_buffer_pool;
+ magma_connection_release_performance_counter_buffer_pool_client_proc_t magma_connection_release_performance_counter_buffer_pool;
+ magma_connection_add_performance_counter_buffer_offsets_to_pool_client_proc_t magma_connection_add_performance_counter_buffer_offsets_to_pool;
+ magma_connection_remove_performance_counter_buffer_from_pool_client_proc_t magma_connection_remove_performance_counter_buffer_from_pool;
+ magma_connection_dump_performance_counters_client_proc_t magma_connection_dump_performance_counters;
+ magma_connection_clear_performance_counters_client_proc_t magma_connection_clear_performance_counters;
+ magma_connection_read_performance_counter_completion_client_proc_t magma_connection_read_performance_counter_completion;
+ magma_virt_connection_create_image_client_proc_t magma_virt_connection_create_image;
+ magma_virt_connection_get_image_info_client_proc_t magma_virt_connection_get_image_info;
+ virtual ~magma_client_context_t() {}
+
+ typedef magma_client_context_t *CONTEXT_ACCESSOR_TYPE(void);
+ static void setContextAccessor(CONTEXT_ACCESSOR_TYPE *f);
+ int initDispatchByName( void *(*getProc)(const char *name, void *userData), void *userData);
+ virtual void setError(unsigned int error){ (void)error; }
+ virtual unsigned int getError(){ return 0; }
+};
+
+#endif
diff --git a/system/magma/magma_enc/magma_client_proc.h b/system/magma/magma_enc/magma_client_proc.h
new file mode 100644
index 0000000..08f05d9
--- /dev/null
+++ b/system/magma/magma_enc/magma_client_proc.h
@@ -0,0 +1,66 @@
+// Generated Code - DO NOT EDIT !!
+// generated by 'emugen'
+#ifndef __magma_client_proc_t_h
+#define __magma_client_proc_t_h
+
+
+
+#include "magma_types.h"
+#ifdef _MSC_VER
+#include <stdint.h>
+#endif
+#ifndef magma_APIENTRY
+#define magma_APIENTRY
+#endif
+typedef magma_status_t (magma_APIENTRY *magma_device_import_client_proc_t) (void * ctx, magma_handle_t, magma_device_t*);
+typedef void (magma_APIENTRY *magma_device_release_client_proc_t) (void * ctx, magma_device_t);
+typedef magma_status_t (magma_APIENTRY *magma_device_query_client_proc_t) (void * ctx, magma_device_t, uint64_t, magma_handle_t*, uint64_t*);
+typedef magma_status_t (magma_APIENTRY *magma_device_create_connection_client_proc_t) (void * ctx, magma_device_t, magma_connection_t*);
+typedef void (magma_APIENTRY *magma_connection_release_client_proc_t) (void * ctx, magma_connection_t);
+typedef magma_status_t (magma_APIENTRY *magma_connection_get_error_client_proc_t) (void * ctx, magma_connection_t);
+typedef magma_status_t (magma_APIENTRY *magma_connection_create_context_client_proc_t) (void * ctx, magma_connection_t, uint32_t*);
+typedef void (magma_APIENTRY *magma_connection_release_context_client_proc_t) (void * ctx, magma_connection_t, uint32_t);
+typedef magma_status_t (magma_APIENTRY *magma_connection_create_buffer_client_proc_t) (void * ctx, magma_connection_t, uint64_t, uint64_t*, magma_buffer_t*);
+typedef void (magma_APIENTRY *magma_connection_release_buffer_client_proc_t) (void * ctx, magma_connection_t, magma_buffer_t);
+typedef magma_status_t (magma_APIENTRY *magma_connection_export_buffer_client_proc_t) (void * ctx, magma_connection_t, magma_buffer_t, magma_handle_t*);
+typedef magma_status_t (magma_APIENTRY *magma_connection_import_buffer_client_proc_t) (void * ctx, magma_connection_t, magma_handle_t, magma_buffer_t*);
+typedef magma_status_t (magma_APIENTRY *magma_connection_create_semaphore_client_proc_t) (void * ctx, magma_connection_t, magma_semaphore_t*);
+typedef void (magma_APIENTRY *magma_connection_release_semaphore_client_proc_t) (void * ctx, magma_connection_t, magma_semaphore_t);
+typedef magma_status_t (magma_APIENTRY *magma_connection_export_semaphore_client_proc_t) (void * ctx, magma_connection_t, magma_semaphore_t, magma_handle_t*);
+typedef magma_status_t (magma_APIENTRY *magma_connection_import_semaphore_client_proc_t) (void * ctx, magma_connection_t, magma_handle_t, magma_semaphore_t*);
+typedef magma_status_t (magma_APIENTRY *magma_connection_buffer_range_op_client_proc_t) (void * ctx, magma_connection_t, magma_buffer_t, uint32_t, uint64_t, uint64_t);
+typedef magma_status_t (magma_APIENTRY *magma_connection_map_buffer_client_proc_t) (void * ctx, magma_connection_t, uint64_t, magma_buffer_t, uint64_t, uint64_t, uint64_t);
+typedef void (magma_APIENTRY *magma_connection_unmap_buffer_client_proc_t) (void * ctx, magma_connection_t, uint64_t, magma_buffer_t);
+typedef magma_status_t (magma_APIENTRY *magma_connection_execute_command_client_proc_t) (void * ctx, uint64_t*, uint64_t);
+typedef magma_status_t (magma_APIENTRY *magma_connection_execute_immediate_commands_client_proc_t) (void * ctx, uint64_t*, uint64_t);
+typedef magma_status_t (magma_APIENTRY *magma_connection_flush_client_proc_t) (void * ctx, magma_connection_t);
+typedef magma_handle_t (magma_APIENTRY *magma_connection_get_notification_channel_handle_client_proc_t) (void * ctx, magma_connection_t);
+typedef magma_status_t (magma_APIENTRY *magma_connection_read_notification_channel_client_proc_t) (void * ctx, magma_connection_t, void*, uint64_t, uint64_t*, magma_bool_t*);
+typedef uint64_t (magma_APIENTRY *magma_buffer_get_id_client_proc_t) (void * ctx, magma_buffer_t);
+typedef uint64_t (magma_APIENTRY *magma_buffer_get_size_client_proc_t) (void * ctx, magma_buffer_t);
+typedef magma_status_t (magma_APIENTRY *magma_buffer_clean_cache_client_proc_t) (void * ctx, magma_buffer_t, uint64_t, uint64_t, magma_cache_operation_t);
+typedef magma_status_t (magma_APIENTRY *magma_buffer_set_cache_policy_client_proc_t) (void * ctx, magma_buffer_t, magma_cache_policy_t);
+typedef magma_status_t (magma_APIENTRY *magma_buffer_get_cache_policy_client_proc_t) (void * ctx, magma_buffer_t, magma_cache_policy_t*);
+typedef magma_status_t (magma_APIENTRY *magma_buffer_set_name_client_proc_t) (void * ctx, magma_buffer_t, void*, uint64_t);
+typedef magma_status_t (magma_APIENTRY *magma_buffer_get_info_client_proc_t) (void * ctx, uint64_t*, uint64_t);
+typedef magma_status_t (magma_APIENTRY *magma_buffer_get_handle_client_proc_t) (void * ctx, magma_buffer_t, magma_handle_t*);
+typedef uint64_t (magma_APIENTRY *magma_semaphore_get_id_client_proc_t) (void * ctx, magma_semaphore_t);
+typedef void (magma_APIENTRY *magma_semaphore_signal_client_proc_t) (void * ctx, magma_semaphore_t);
+typedef void (magma_APIENTRY *magma_semaphore_reset_client_proc_t) (void * ctx, magma_semaphore_t);
+typedef magma_status_t (magma_APIENTRY *magma_poll_client_proc_t) (void * ctx, magma_poll_item_t*, uint32_t, uint64_t);
+typedef magma_status_t (magma_APIENTRY *magma_initialize_tracing_client_proc_t) (void * ctx, magma_handle_t);
+typedef magma_status_t (magma_APIENTRY *magma_initialize_logging_client_proc_t) (void * ctx, magma_handle_t);
+typedef magma_status_t (magma_APIENTRY *magma_connection_enable_performance_counter_access_client_proc_t) (void * ctx, magma_connection_t, magma_handle_t);
+typedef magma_status_t (magma_APIENTRY *magma_connection_enable_performance_counters_client_proc_t) (void * ctx, magma_connection_t, uint64_t*, uint64_t);
+typedef magma_status_t (magma_APIENTRY *magma_connection_create_performance_counter_buffer_pool_client_proc_t) (void * ctx, magma_connection_t, magma_perf_count_pool_t*, magma_handle_t*);
+typedef magma_status_t (magma_APIENTRY *magma_connection_release_performance_counter_buffer_pool_client_proc_t) (void * ctx, magma_connection_t, magma_perf_count_pool_t);
+typedef magma_status_t (magma_APIENTRY *magma_connection_add_performance_counter_buffer_offsets_to_pool_client_proc_t) (void * ctx, uint64_t*, uint64_t);
+typedef magma_status_t (magma_APIENTRY *magma_connection_remove_performance_counter_buffer_from_pool_client_proc_t) (void * ctx, magma_connection_t, magma_perf_count_pool_t, magma_buffer_t);
+typedef magma_status_t (magma_APIENTRY *magma_connection_dump_performance_counters_client_proc_t) (void * ctx, magma_connection_t, magma_perf_count_pool_t, uint32_t);
+typedef magma_status_t (magma_APIENTRY *magma_connection_clear_performance_counters_client_proc_t) (void * ctx, magma_connection_t, uint64_t*, uint64_t);
+typedef magma_status_t (magma_APIENTRY *magma_connection_read_performance_counter_completion_client_proc_t) (void * ctx, magma_connection_t, magma_perf_count_pool_t, uint32_t*, uint64_t*, uint32_t*, uint64_t*, uint32_t*);
+typedef magma_status_t (magma_APIENTRY *magma_virt_connection_create_image_client_proc_t) (void * ctx, uint64_t*, uint64_t);
+typedef magma_status_t (magma_APIENTRY *magma_virt_connection_get_image_info_client_proc_t) (void * ctx, uint64_t*, uint64_t);
+
+
+#endif
diff --git a/system/magma/magma_enc/magma_enc.cpp b/system/magma/magma_enc/magma_enc.cpp
new file mode 100644
index 0000000..153d708
--- /dev/null
+++ b/system/magma/magma_enc/magma_enc.cpp
@@ -0,0 +1,2199 @@
+// Generated Code - DO NOT EDIT !!
+// generated by 'emugen'
+
+
+#include <string.h>
+#include "magma_opcodes.h"
+
+#include "magma_enc.h"
+
+
+#include <vector>
+
+#include <stdio.h>
+
+// TODO(fxbug.dev/122605): Why is modification needed for these two includes?
+#include "aemu/base/Tracing.h"
+#include "cutils/log.h"
+
+#include "EncoderDebug.h"
+
+namespace {
+
+void enc_unsupported()
+{
+ ALOGE("Function is unsupported\n");
+}
+
+magma_status_t magma_device_import_enc(void *self , magma_handle_t device_channel, magma_device_t* device_out)
+{
+ ENCODER_DEBUG_LOG("magma_device_import(device_channel:0x%x, device_out:%p)", device_channel, device_out);
+ AEMU_SCOPED_TRACE("magma_device_import encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_device_out = sizeof(magma_device_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_device_import;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &device_channel, 4); ptr += 4;
+ memcpy(ptr, &__size_device_out, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(device_out, __size_device_out);
+ if (useChecksum) checksumCalculator->addBuffer(device_out, __size_device_out);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_device_import: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+void magma_device_release_enc(void *self , magma_device_t device)
+{
+ ENCODER_DEBUG_LOG("magma_device_release(device:%lu)", device);
+ AEMU_SCOPED_TRACE("magma_device_release encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_device_release;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &device, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+magma_status_t magma_device_query_enc(void *self , magma_device_t device, uint64_t id, magma_handle_t* result_buffer_out, uint64_t* result_out)
+{
+ ENCODER_DEBUG_LOG("magma_device_query(device:%lu, id:%lu, result_buffer_out:%p, result_out:%p)", device, id, result_buffer_out, result_out);
+ AEMU_SCOPED_TRACE("magma_device_query encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_result_buffer_out = sizeof(magma_handle_t);
+ const unsigned int __size_result_out = sizeof(uint64_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 8 + 0 + 0 + 2*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_device_query;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &device, 8); ptr += 8;
+ memcpy(ptr, &id, 8); ptr += 8;
+ memcpy(ptr, &__size_result_buffer_out, 4); ptr += 4;
+ memcpy(ptr, &__size_result_out, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(result_buffer_out, __size_result_buffer_out);
+ if (useChecksum) checksumCalculator->addBuffer(result_buffer_out, __size_result_buffer_out);
+ stream->readback(result_out, __size_result_out);
+ if (useChecksum) checksumCalculator->addBuffer(result_out, __size_result_out);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_device_query: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_device_create_connection_enc(void *self , magma_device_t device, magma_connection_t* connection_out)
+{
+ ENCODER_DEBUG_LOG("magma_device_create_connection(device:%lu, connection_out:%p)", device, connection_out);
+ AEMU_SCOPED_TRACE("magma_device_create_connection encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_connection_out = sizeof(magma_connection_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 0 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_device_create_connection;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &device, 8); ptr += 8;
+ memcpy(ptr, &__size_connection_out, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(connection_out, __size_connection_out);
+ if (useChecksum) checksumCalculator->addBuffer(connection_out, __size_connection_out);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_device_create_connection: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+void magma_connection_release_enc(void *self , magma_connection_t connection)
+{
+ ENCODER_DEBUG_LOG("magma_connection_release(connection:%lu)", connection);
+ AEMU_SCOPED_TRACE("magma_connection_release encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_release;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+magma_status_t magma_connection_get_error_enc(void *self , magma_connection_t connection)
+{
+ ENCODER_DEBUG_LOG("magma_connection_get_error(connection:%lu)", connection);
+ AEMU_SCOPED_TRACE("magma_connection_get_error encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_get_error;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_get_error: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_connection_create_context_enc(void *self , magma_connection_t connection, uint32_t* context_id_out)
+{
+ ENCODER_DEBUG_LOG("magma_connection_create_context(connection:%lu, context_id_out:%p)", connection, context_id_out);
+ AEMU_SCOPED_TRACE("magma_connection_create_context encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_context_id_out = sizeof(uint32_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 0 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_create_context;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &__size_context_id_out, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(context_id_out, __size_context_id_out);
+ if (useChecksum) checksumCalculator->addBuffer(context_id_out, __size_context_id_out);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_create_context: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+void magma_connection_release_context_enc(void *self , magma_connection_t connection, uint32_t context_id)
+{
+ ENCODER_DEBUG_LOG("magma_connection_release_context(connection:%lu, context_id:%u)", connection, context_id);
+ AEMU_SCOPED_TRACE("magma_connection_release_context encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_release_context;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &context_id, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+magma_status_t magma_connection_create_buffer_enc(void *self , magma_connection_t connection, uint64_t size, uint64_t* size_out, magma_buffer_t* buffer_out)
+{
+ ENCODER_DEBUG_LOG("magma_connection_create_buffer(connection:%lu, size:%lu, size_out:%p, buffer_out:%p)", connection, size, size_out, buffer_out);
+ AEMU_SCOPED_TRACE("magma_connection_create_buffer encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_size_out = sizeof(uint64_t);
+ const unsigned int __size_buffer_out = sizeof(magma_buffer_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 8 + 0 + 0 + 2*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_create_buffer;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &size, 8); ptr += 8;
+ memcpy(ptr, &__size_size_out, 4); ptr += 4;
+ memcpy(ptr, &__size_buffer_out, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(size_out, __size_size_out);
+ if (useChecksum) checksumCalculator->addBuffer(size_out, __size_size_out);
+ stream->readback(buffer_out, __size_buffer_out);
+ if (useChecksum) checksumCalculator->addBuffer(buffer_out, __size_buffer_out);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_create_buffer: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+void magma_connection_release_buffer_enc(void *self , magma_connection_t connection, magma_buffer_t buffer)
+{
+ ENCODER_DEBUG_LOG("magma_connection_release_buffer(connection:%lu, buffer:%lu)", connection, buffer);
+ AEMU_SCOPED_TRACE("magma_connection_release_buffer encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 8;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_release_buffer;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &buffer, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+magma_status_t magma_connection_export_buffer_enc(void *self , magma_connection_t connection, magma_buffer_t buffer, magma_handle_t* buffer_handle_out)
+{
+ ENCODER_DEBUG_LOG("magma_connection_export_buffer(connection:%lu, buffer:%lu, buffer_handle_out:%p)", connection, buffer, buffer_handle_out);
+ AEMU_SCOPED_TRACE("magma_connection_export_buffer encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_buffer_handle_out = sizeof(magma_handle_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 8 + 0 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_export_buffer;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &buffer, 8); ptr += 8;
+ memcpy(ptr, &__size_buffer_handle_out, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(buffer_handle_out, __size_buffer_handle_out);
+ if (useChecksum) checksumCalculator->addBuffer(buffer_handle_out, __size_buffer_handle_out);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_export_buffer: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_connection_import_buffer_enc(void *self , magma_connection_t connection, magma_handle_t buffer_handle, magma_buffer_t* buffer_out)
+{
+ ENCODER_DEBUG_LOG("magma_connection_import_buffer(connection:%lu, buffer_handle:0x%x, buffer_out:%p)", connection, buffer_handle, buffer_out);
+ AEMU_SCOPED_TRACE("magma_connection_import_buffer encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_buffer_out = sizeof(magma_buffer_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 4 + 0 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_import_buffer;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &buffer_handle, 4); ptr += 4;
+ memcpy(ptr, &__size_buffer_out, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(buffer_out, __size_buffer_out);
+ if (useChecksum) checksumCalculator->addBuffer(buffer_out, __size_buffer_out);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_import_buffer: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_connection_create_semaphore_enc(void *self , magma_connection_t connection, magma_semaphore_t* semaphore_out)
+{
+ ENCODER_DEBUG_LOG("magma_connection_create_semaphore(connection:%lu, semaphore_out:%p)", connection, semaphore_out);
+ AEMU_SCOPED_TRACE("magma_connection_create_semaphore encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_semaphore_out = sizeof(magma_semaphore_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 0 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_create_semaphore;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &__size_semaphore_out, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(semaphore_out, __size_semaphore_out);
+ if (useChecksum) checksumCalculator->addBuffer(semaphore_out, __size_semaphore_out);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_create_semaphore: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+void magma_connection_release_semaphore_enc(void *self , magma_connection_t connection, magma_semaphore_t semaphore)
+{
+ ENCODER_DEBUG_LOG("magma_connection_release_semaphore(connection:%lu, semaphore:%lu)", connection, semaphore);
+ AEMU_SCOPED_TRACE("magma_connection_release_semaphore encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 8;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_release_semaphore;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &semaphore, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+magma_status_t magma_connection_export_semaphore_enc(void *self , magma_connection_t connection, magma_semaphore_t semaphore, magma_handle_t* semaphore_handle_out)
+{
+ ENCODER_DEBUG_LOG("magma_connection_export_semaphore(connection:%lu, semaphore:%lu, semaphore_handle_out:%p)", connection, semaphore, semaphore_handle_out);
+ AEMU_SCOPED_TRACE("magma_connection_export_semaphore encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_semaphore_handle_out = sizeof(magma_handle_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 8 + 0 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_export_semaphore;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &semaphore, 8); ptr += 8;
+ memcpy(ptr, &__size_semaphore_handle_out, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(semaphore_handle_out, __size_semaphore_handle_out);
+ if (useChecksum) checksumCalculator->addBuffer(semaphore_handle_out, __size_semaphore_handle_out);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_export_semaphore: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_connection_import_semaphore_enc(void *self , magma_connection_t connection, magma_handle_t semaphore_handle, magma_semaphore_t* semaphore_out)
+{
+ ENCODER_DEBUG_LOG("magma_connection_import_semaphore(connection:%lu, semaphore_handle:0x%x, semaphore_out:%p)", connection, semaphore_handle, semaphore_out);
+ AEMU_SCOPED_TRACE("magma_connection_import_semaphore encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_semaphore_out = sizeof(magma_semaphore_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 4 + 0 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_import_semaphore;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &semaphore_handle, 4); ptr += 4;
+ memcpy(ptr, &__size_semaphore_out, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(semaphore_out, __size_semaphore_out);
+ if (useChecksum) checksumCalculator->addBuffer(semaphore_out, __size_semaphore_out);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_import_semaphore: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_connection_buffer_range_op_enc(void *self , magma_connection_t connection, magma_buffer_t buffer, uint32_t options, uint64_t start_offset, uint64_t length)
+{
+ ENCODER_DEBUG_LOG("magma_connection_buffer_range_op(connection:%lu, buffer:%lu, options:%u, start_offset:%lu, length:%lu)", connection, buffer, options, start_offset, length);
+ AEMU_SCOPED_TRACE("magma_connection_buffer_range_op encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 8 + 4 + 8 + 8;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_buffer_range_op;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &buffer, 8); ptr += 8;
+ memcpy(ptr, &options, 4); ptr += 4;
+ memcpy(ptr, &start_offset, 8); ptr += 8;
+ memcpy(ptr, &length, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_buffer_range_op: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_connection_map_buffer_enc(void *self , magma_connection_t connection, uint64_t hw_va, magma_buffer_t buffer, uint64_t offset, uint64_t length, uint64_t map_flags)
+{
+ ENCODER_DEBUG_LOG("magma_connection_map_buffer(connection:%lu, hw_va:%lu, buffer:%lu, offset:%lu, length:%lu, map_flags:%lu)", connection, hw_va, buffer, offset, length, map_flags);
+ AEMU_SCOPED_TRACE("magma_connection_map_buffer encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 8 + 8 + 8 + 8 + 8;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_map_buffer;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &hw_va, 8); ptr += 8;
+ memcpy(ptr, &buffer, 8); ptr += 8;
+ memcpy(ptr, &offset, 8); ptr += 8;
+ memcpy(ptr, &length, 8); ptr += 8;
+ memcpy(ptr, &map_flags, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_map_buffer: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+void magma_connection_unmap_buffer_enc(void *self , magma_connection_t connection, uint64_t hw_va, magma_buffer_t buffer)
+{
+ ENCODER_DEBUG_LOG("magma_connection_unmap_buffer(connection:%lu, hw_va:%lu, buffer:%lu)", connection, hw_va, buffer);
+ AEMU_SCOPED_TRACE("magma_connection_unmap_buffer encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 8 + 8;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_unmap_buffer;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &hw_va, 8); ptr += 8;
+ memcpy(ptr, &buffer, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+magma_status_t magma_connection_execute_command_enc(void *self , uint64_t* parameters, uint64_t parameter_count)
+{
+ ENCODER_DEBUG_LOG("magma_connection_execute_command(parameters:%p, parameter_count:%lu)", parameters, parameter_count);
+ AEMU_SCOPED_TRACE("magma_connection_execute_command encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_parameters = parameter_count * sizeof(uint64_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + __size_parameters + 8 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_execute_command;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &__size_parameters, 4); ptr += 4;
+ memcpy(ptr, parameters, __size_parameters);ptr += __size_parameters;
+ memcpy(ptr, ¶meter_count, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(parameters, __size_parameters);
+ if (useChecksum) checksumCalculator->addBuffer(parameters, __size_parameters);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_execute_command: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_connection_execute_immediate_commands_enc(void *self , uint64_t* parameters, uint64_t parameter_count)
+{
+ ENCODER_DEBUG_LOG("magma_connection_execute_immediate_commands(parameters:%p, parameter_count:%lu)", parameters, parameter_count);
+ AEMU_SCOPED_TRACE("magma_connection_execute_immediate_commands encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_parameters = parameter_count * sizeof(uint64_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + __size_parameters + 8 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_execute_immediate_commands;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &__size_parameters, 4); ptr += 4;
+ memcpy(ptr, parameters, __size_parameters);ptr += __size_parameters;
+ memcpy(ptr, ¶meter_count, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(parameters, __size_parameters);
+ if (useChecksum) checksumCalculator->addBuffer(parameters, __size_parameters);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_execute_immediate_commands: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_connection_flush_enc(void *self , magma_connection_t connection)
+{
+ ENCODER_DEBUG_LOG("magma_connection_flush(connection:%lu)", connection);
+ AEMU_SCOPED_TRACE("magma_connection_flush encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_flush;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_flush: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_handle_t magma_connection_get_notification_channel_handle_enc(void *self , magma_connection_t connection)
+{
+ ENCODER_DEBUG_LOG("magma_connection_get_notification_channel_handle(connection:%lu)", connection);
+ AEMU_SCOPED_TRACE("magma_connection_get_notification_channel_handle encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_get_notification_channel_handle;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ magma_handle_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_get_notification_channel_handle: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_connection_read_notification_channel_enc(void *self , magma_connection_t connection, void* buffer, uint64_t buffer_size, uint64_t* buffer_size_out, magma_bool_t* more_data_out)
+{
+ ENCODER_DEBUG_LOG("magma_connection_read_notification_channel(connection:%lu, buffer:%p, buffer_size:%lu, buffer_size_out:%p, more_data_out:%p)", connection, buffer, buffer_size, buffer_size_out, more_data_out);
+ AEMU_SCOPED_TRACE("magma_connection_read_notification_channel encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_buffer = buffer_size;
+ const unsigned int __size_buffer_size_out = sizeof(uint64_t);
+ const unsigned int __size_more_data_out = sizeof(magma_bool_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 0 + 8 + 0 + 0 + 3*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_read_notification_channel;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &__size_buffer, 4); ptr += 4;
+ memcpy(ptr, &buffer_size, 8); ptr += 8;
+ memcpy(ptr, &__size_buffer_size_out, 4); ptr += 4;
+ memcpy(ptr, &__size_more_data_out, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(buffer, __size_buffer);
+ if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer);
+ stream->readback(buffer_size_out, __size_buffer_size_out);
+ if (useChecksum) checksumCalculator->addBuffer(buffer_size_out, __size_buffer_size_out);
+ stream->readback(more_data_out, __size_more_data_out);
+ if (useChecksum) checksumCalculator->addBuffer(more_data_out, __size_more_data_out);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_read_notification_channel: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+uint64_t magma_buffer_get_id_enc(void *self , magma_buffer_t buffer)
+{
+ ENCODER_DEBUG_LOG("magma_buffer_get_id(buffer:%lu)", buffer);
+ AEMU_SCOPED_TRACE("magma_buffer_get_id encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_buffer_get_id;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &buffer, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ uint64_t retval;
+ stream->readback(&retval, 8);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 8);
+ 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("magma_buffer_get_id: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+uint64_t magma_buffer_get_size_enc(void *self , magma_buffer_t buffer)
+{
+ ENCODER_DEBUG_LOG("magma_buffer_get_size(buffer:%lu)", buffer);
+ AEMU_SCOPED_TRACE("magma_buffer_get_size encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_buffer_get_size;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &buffer, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ uint64_t retval;
+ stream->readback(&retval, 8);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 8);
+ 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("magma_buffer_get_size: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_buffer_clean_cache_enc(void *self , magma_buffer_t buffer, uint64_t offset, uint64_t size, magma_cache_operation_t operation)
+{
+ ENCODER_DEBUG_LOG("magma_buffer_clean_cache(buffer:%lu, offset:%lu, size:%lu, operation:%d)", buffer, offset, size, operation);
+ AEMU_SCOPED_TRACE("magma_buffer_clean_cache encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 8 + 8 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_buffer_clean_cache;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &buffer, 8); ptr += 8;
+ memcpy(ptr, &offset, 8); ptr += 8;
+ memcpy(ptr, &size, 8); ptr += 8;
+ memcpy(ptr, &operation, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_buffer_clean_cache: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_buffer_set_cache_policy_enc(void *self , magma_buffer_t buffer, magma_cache_policy_t policy)
+{
+ ENCODER_DEBUG_LOG("magma_buffer_set_cache_policy(buffer:%lu, policy:%d)", buffer, policy);
+ AEMU_SCOPED_TRACE("magma_buffer_set_cache_policy encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_buffer_set_cache_policy;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &buffer, 8); ptr += 8;
+ memcpy(ptr, &policy, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_buffer_set_cache_policy: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_buffer_get_cache_policy_enc(void *self , magma_buffer_t buffer, magma_cache_policy_t* cache_policy_out)
+{
+ ENCODER_DEBUG_LOG("magma_buffer_get_cache_policy(buffer:%lu, cache_policy_out:%p)", buffer, cache_policy_out);
+ AEMU_SCOPED_TRACE("magma_buffer_get_cache_policy encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_cache_policy_out = sizeof(magma_cache_policy_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 0 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_buffer_get_cache_policy;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &buffer, 8); ptr += 8;
+ memcpy(ptr, &__size_cache_policy_out, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(cache_policy_out, __size_cache_policy_out);
+ if (useChecksum) checksumCalculator->addBuffer(cache_policy_out, __size_cache_policy_out);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_buffer_get_cache_policy: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_buffer_set_name_enc(void *self , magma_buffer_t buffer, void* name, uint64_t name_size)
+{
+ ENCODER_DEBUG_LOG("magma_buffer_set_name(buffer:%lu, name:%p, name_size:%lu)", buffer, name, name_size);
+ AEMU_SCOPED_TRACE("magma_buffer_set_name encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_name = name_size;
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + __size_name + 8 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_buffer_set_name;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &buffer, 8); ptr += 8;
+ memcpy(ptr, &__size_name, 4); ptr += 4;
+ memcpy(ptr, name, __size_name);ptr += __size_name;
+ memcpy(ptr, &name_size, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_buffer_set_name: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_buffer_get_info_enc(void *self , uint64_t* parameters, uint64_t parameter_count)
+{
+ ENCODER_DEBUG_LOG("magma_buffer_get_info(parameters:%p, parameter_count:%lu)", parameters, parameter_count);
+ AEMU_SCOPED_TRACE("magma_buffer_get_info encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_parameters = parameter_count * sizeof(uint64_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + __size_parameters + 8 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_buffer_get_info;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &__size_parameters, 4); ptr += 4;
+ memcpy(ptr, parameters, __size_parameters);ptr += __size_parameters;
+ memcpy(ptr, ¶meter_count, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(parameters, __size_parameters);
+ if (useChecksum) checksumCalculator->addBuffer(parameters, __size_parameters);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_buffer_get_info: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_buffer_get_handle_enc(void *self , magma_buffer_t buffer, magma_handle_t* handle_out)
+{
+ ENCODER_DEBUG_LOG("magma_buffer_get_handle(buffer:%lu, handle_out:%p)", buffer, handle_out);
+ AEMU_SCOPED_TRACE("magma_buffer_get_handle encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_handle_out = sizeof(magma_handle_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 0 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_buffer_get_handle;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &buffer, 8); ptr += 8;
+ memcpy(ptr, &__size_handle_out, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(handle_out, __size_handle_out);
+ if (useChecksum) checksumCalculator->addBuffer(handle_out, __size_handle_out);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_buffer_get_handle: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+uint64_t magma_semaphore_get_id_enc(void *self , magma_semaphore_t semaphore)
+{
+ ENCODER_DEBUG_LOG("magma_semaphore_get_id(semaphore:%lu)", semaphore);
+ AEMU_SCOPED_TRACE("magma_semaphore_get_id encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_semaphore_get_id;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &semaphore, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ uint64_t retval;
+ stream->readback(&retval, 8);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 8);
+ 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("magma_semaphore_get_id: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+void magma_semaphore_signal_enc(void *self , magma_semaphore_t semaphore)
+{
+ ENCODER_DEBUG_LOG("magma_semaphore_signal(semaphore:%lu)", semaphore);
+ AEMU_SCOPED_TRACE("magma_semaphore_signal encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_semaphore_signal;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &semaphore, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+void magma_semaphore_reset_enc(void *self , magma_semaphore_t semaphore)
+{
+ ENCODER_DEBUG_LOG("magma_semaphore_reset(semaphore:%lu)", semaphore);
+ AEMU_SCOPED_TRACE("magma_semaphore_reset encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_semaphore_reset;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &semaphore, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+magma_status_t magma_poll_enc(void *self , magma_poll_item_t* items, uint32_t count, uint64_t timeout_ns)
+{
+ ENCODER_DEBUG_LOG("magma_poll(items:%p, count:%u, timeout_ns:%lu)", items, count, timeout_ns);
+ AEMU_SCOPED_TRACE("magma_poll encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_items = count * sizeof(magma_poll_item_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + __size_items + 4 + 8 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_poll;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &__size_items, 4); ptr += 4;
+ memcpy(ptr, items, __size_items);ptr += __size_items;
+ memcpy(ptr, &count, 4); ptr += 4;
+ memcpy(ptr, &timeout_ns, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(items, __size_items);
+ if (useChecksum) checksumCalculator->addBuffer(items, __size_items);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_poll: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_initialize_tracing_enc(void *self , magma_handle_t channel)
+{
+ ENCODER_DEBUG_LOG("magma_initialize_tracing(channel:0x%x)", channel);
+ AEMU_SCOPED_TRACE("magma_initialize_tracing encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_initialize_tracing;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &channel, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_initialize_tracing: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_initialize_logging_enc(void *self , magma_handle_t channel)
+{
+ ENCODER_DEBUG_LOG("magma_initialize_logging(channel:0x%x)", channel);
+ AEMU_SCOPED_TRACE("magma_initialize_logging encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_initialize_logging;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &channel, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_initialize_logging: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_connection_enable_performance_counter_access_enc(void *self , magma_connection_t connection, magma_handle_t channel)
+{
+ ENCODER_DEBUG_LOG("magma_connection_enable_performance_counter_access(connection:%lu, channel:0x%x)", connection, channel);
+ AEMU_SCOPED_TRACE("magma_connection_enable_performance_counter_access encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_enable_performance_counter_access;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &channel, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_enable_performance_counter_access: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_connection_enable_performance_counters_enc(void *self , magma_connection_t connection, uint64_t* counters, uint64_t counters_count)
+{
+ ENCODER_DEBUG_LOG("magma_connection_enable_performance_counters(connection:%lu, counters:%p, counters_count:%lu)", connection, counters, counters_count);
+ AEMU_SCOPED_TRACE("magma_connection_enable_performance_counters encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_counters = counters_count * sizeof(uint64_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + __size_counters + 8 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_enable_performance_counters;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &__size_counters, 4); ptr += 4;
+ memcpy(ptr, counters, __size_counters);ptr += __size_counters;
+ memcpy(ptr, &counters_count, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_enable_performance_counters: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_connection_create_performance_counter_buffer_pool_enc(void *self , magma_connection_t connection, magma_perf_count_pool_t* pool_id_out, magma_handle_t* notification_handle_out)
+{
+ ENCODER_DEBUG_LOG("magma_connection_create_performance_counter_buffer_pool(connection:%lu, pool_id_out:%p, notification_handle_out:%p)", connection, pool_id_out, notification_handle_out);
+ AEMU_SCOPED_TRACE("magma_connection_create_performance_counter_buffer_pool encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_pool_id_out = sizeof(magma_perf_count_pool_t);
+ const unsigned int __size_notification_handle_out = sizeof(magma_handle_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 0 + 0 + 2*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_create_performance_counter_buffer_pool;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &__size_pool_id_out, 4); ptr += 4;
+ memcpy(ptr, &__size_notification_handle_out, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(pool_id_out, __size_pool_id_out);
+ if (useChecksum) checksumCalculator->addBuffer(pool_id_out, __size_pool_id_out);
+ stream->readback(notification_handle_out, __size_notification_handle_out);
+ if (useChecksum) checksumCalculator->addBuffer(notification_handle_out, __size_notification_handle_out);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_create_performance_counter_buffer_pool: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_connection_release_performance_counter_buffer_pool_enc(void *self , magma_connection_t connection, magma_perf_count_pool_t pool_id)
+{
+ ENCODER_DEBUG_LOG("magma_connection_release_performance_counter_buffer_pool(connection:%lu, pool_id:%lu)", connection, pool_id);
+ AEMU_SCOPED_TRACE("magma_connection_release_performance_counter_buffer_pool encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 8;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_release_performance_counter_buffer_pool;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &pool_id, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_release_performance_counter_buffer_pool: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_connection_add_performance_counter_buffer_offsets_to_pool_enc(void *self , uint64_t* parameters, uint64_t parameter_count)
+{
+ ENCODER_DEBUG_LOG("magma_connection_add_performance_counter_buffer_offsets_to_pool(parameters:%p, parameter_count:%lu)", parameters, parameter_count);
+ AEMU_SCOPED_TRACE("magma_connection_add_performance_counter_buffer_offsets_to_pool encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_parameters = parameter_count * sizeof(uint64_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + __size_parameters + 8 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_add_performance_counter_buffer_offsets_to_pool;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &__size_parameters, 4); ptr += 4;
+ memcpy(ptr, parameters, __size_parameters);ptr += __size_parameters;
+ memcpy(ptr, ¶meter_count, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(parameters, __size_parameters);
+ if (useChecksum) checksumCalculator->addBuffer(parameters, __size_parameters);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_add_performance_counter_buffer_offsets_to_pool: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_connection_remove_performance_counter_buffer_from_pool_enc(void *self , magma_connection_t connection, magma_perf_count_pool_t pool_id, magma_buffer_t buffer)
+{
+ ENCODER_DEBUG_LOG("magma_connection_remove_performance_counter_buffer_from_pool(connection:%lu, pool_id:%lu, buffer:%lu)", connection, pool_id, buffer);
+ AEMU_SCOPED_TRACE("magma_connection_remove_performance_counter_buffer_from_pool encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 8 + 8;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_remove_performance_counter_buffer_from_pool;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &pool_id, 8); ptr += 8;
+ memcpy(ptr, &buffer, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_remove_performance_counter_buffer_from_pool: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_connection_dump_performance_counters_enc(void *self , magma_connection_t connection, magma_perf_count_pool_t pool_id, uint32_t trigger_id)
+{
+ ENCODER_DEBUG_LOG("magma_connection_dump_performance_counters(connection:%lu, pool_id:%lu, trigger_id:%u)", connection, pool_id, trigger_id);
+ AEMU_SCOPED_TRACE("magma_connection_dump_performance_counters encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 8 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_dump_performance_counters;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &pool_id, 8); ptr += 8;
+ memcpy(ptr, &trigger_id, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_dump_performance_counters: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_connection_clear_performance_counters_enc(void *self , magma_connection_t connection, uint64_t* counters, uint64_t counters_count)
+{
+ ENCODER_DEBUG_LOG("magma_connection_clear_performance_counters(connection:%lu, counters:%p, counters_count:%lu)", connection, counters, counters_count);
+ AEMU_SCOPED_TRACE("magma_connection_clear_performance_counters encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_counters = counters_count * sizeof(uint64_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + __size_counters + 8 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_clear_performance_counters;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &__size_counters, 4); ptr += 4;
+ memcpy(ptr, counters, __size_counters);ptr += __size_counters;
+ memcpy(ptr, &counters_count, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_clear_performance_counters: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_connection_read_performance_counter_completion_enc(void *self , magma_connection_t connection, magma_perf_count_pool_t pool_id, uint32_t* trigger_id_out, uint64_t* buffer_id_out, uint32_t* buffer_offset_out, uint64_t* time_out, uint32_t* result_flags_out)
+{
+ ENCODER_DEBUG_LOG("magma_connection_read_performance_counter_completion(connection:%lu, pool_id:%lu, trigger_id_out:%p, buffer_id_out:%p, buffer_offset_out:%p, time_out:%p, result_flags_out:%p)", connection, pool_id, trigger_id_out, buffer_id_out, buffer_offset_out, time_out, result_flags_out);
+ AEMU_SCOPED_TRACE("magma_connection_read_performance_counter_completion encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_trigger_id_out = sizeof(uint32_t);
+ const unsigned int __size_buffer_id_out = sizeof(uint64_t);
+ const unsigned int __size_buffer_offset_out = sizeof(uint32_t);
+ const unsigned int __size_time_out = sizeof(uint64_t);
+ const unsigned int __size_result_flags_out = sizeof(uint32_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 8 + 8 + 0 + 0 + 0 + 0 + 0 + 5*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_connection_read_performance_counter_completion;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &connection, 8); ptr += 8;
+ memcpy(ptr, &pool_id, 8); ptr += 8;
+ memcpy(ptr, &__size_trigger_id_out, 4); ptr += 4;
+ memcpy(ptr, &__size_buffer_id_out, 4); ptr += 4;
+ memcpy(ptr, &__size_buffer_offset_out, 4); ptr += 4;
+ memcpy(ptr, &__size_time_out, 4); ptr += 4;
+ memcpy(ptr, &__size_result_flags_out, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(trigger_id_out, __size_trigger_id_out);
+ if (useChecksum) checksumCalculator->addBuffer(trigger_id_out, __size_trigger_id_out);
+ stream->readback(buffer_id_out, __size_buffer_id_out);
+ if (useChecksum) checksumCalculator->addBuffer(buffer_id_out, __size_buffer_id_out);
+ stream->readback(buffer_offset_out, __size_buffer_offset_out);
+ if (useChecksum) checksumCalculator->addBuffer(buffer_offset_out, __size_buffer_offset_out);
+ stream->readback(time_out, __size_time_out);
+ if (useChecksum) checksumCalculator->addBuffer(time_out, __size_time_out);
+ stream->readback(result_flags_out, __size_result_flags_out);
+ if (useChecksum) checksumCalculator->addBuffer(result_flags_out, __size_result_flags_out);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_connection_read_performance_counter_completion: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_virt_connection_create_image_enc(void *self , uint64_t* parameters, uint64_t parameter_count)
+{
+ ENCODER_DEBUG_LOG("magma_virt_connection_create_image(parameters:%p, parameter_count:%lu)", parameters, parameter_count);
+ AEMU_SCOPED_TRACE("magma_virt_connection_create_image encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_parameters = parameter_count * sizeof(uint64_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + __size_parameters + 8 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_virt_connection_create_image;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &__size_parameters, 4); ptr += 4;
+ memcpy(ptr, parameters, __size_parameters);ptr += __size_parameters;
+ memcpy(ptr, ¶meter_count, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(parameters, __size_parameters);
+ if (useChecksum) checksumCalculator->addBuffer(parameters, __size_parameters);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_virt_connection_create_image: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+magma_status_t magma_virt_connection_get_image_info_enc(void *self , uint64_t* parameters, uint64_t parameter_count)
+{
+ ENCODER_DEBUG_LOG("magma_virt_connection_get_image_info(parameters:%p, parameter_count:%lu)", parameters, parameter_count);
+ AEMU_SCOPED_TRACE("magma_virt_connection_get_image_info encode");
+
+ magma_encoder_context_t *ctx = (magma_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_parameters = parameter_count * sizeof(uint64_t);
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + __size_parameters + 8 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_magma_virt_connection_get_image_info;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &__size_parameters, 4); ptr += 4;
+ memcpy(ptr, parameters, __size_parameters);ptr += __size_parameters;
+ memcpy(ptr, ¶meter_count, 8); ptr += 8;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(parameters, __size_parameters);
+ if (useChecksum) checksumCalculator->addBuffer(parameters, __size_parameters);
+
+ magma_status_t retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ 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("magma_virt_connection_get_image_info: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
+} // namespace
+
+magma_encoder_context_t::magma_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator)
+{
+ m_stream = stream;
+ m_checksumCalculator = checksumCalculator;
+
+ this->magma_device_import = &magma_device_import_enc;
+ this->magma_device_release = &magma_device_release_enc;
+ this->magma_device_query = &magma_device_query_enc;
+ this->magma_device_create_connection = &magma_device_create_connection_enc;
+ this->magma_connection_release = &magma_connection_release_enc;
+ this->magma_connection_get_error = &magma_connection_get_error_enc;
+ this->magma_connection_create_context = &magma_connection_create_context_enc;
+ this->magma_connection_release_context = &magma_connection_release_context_enc;
+ this->magma_connection_create_buffer = &magma_connection_create_buffer_enc;
+ this->magma_connection_release_buffer = &magma_connection_release_buffer_enc;
+ this->magma_connection_export_buffer = &magma_connection_export_buffer_enc;
+ this->magma_connection_import_buffer = &magma_connection_import_buffer_enc;
+ this->magma_connection_create_semaphore = &magma_connection_create_semaphore_enc;
+ this->magma_connection_release_semaphore = &magma_connection_release_semaphore_enc;
+ this->magma_connection_export_semaphore = &magma_connection_export_semaphore_enc;
+ this->magma_connection_import_semaphore = &magma_connection_import_semaphore_enc;
+ this->magma_connection_buffer_range_op = &magma_connection_buffer_range_op_enc;
+ this->magma_connection_map_buffer = &magma_connection_map_buffer_enc;
+ this->magma_connection_unmap_buffer = &magma_connection_unmap_buffer_enc;
+ this->magma_connection_execute_command = &magma_connection_execute_command_enc;
+ this->magma_connection_execute_immediate_commands = &magma_connection_execute_immediate_commands_enc;
+ this->magma_connection_flush = &magma_connection_flush_enc;
+ this->magma_connection_get_notification_channel_handle = &magma_connection_get_notification_channel_handle_enc;
+ this->magma_connection_read_notification_channel = &magma_connection_read_notification_channel_enc;
+ this->magma_buffer_get_id = &magma_buffer_get_id_enc;
+ this->magma_buffer_get_size = &magma_buffer_get_size_enc;
+ this->magma_buffer_clean_cache = &magma_buffer_clean_cache_enc;
+ this->magma_buffer_set_cache_policy = &magma_buffer_set_cache_policy_enc;
+ this->magma_buffer_get_cache_policy = &magma_buffer_get_cache_policy_enc;
+ this->magma_buffer_set_name = &magma_buffer_set_name_enc;
+ this->magma_buffer_get_info = &magma_buffer_get_info_enc;
+ this->magma_buffer_get_handle = &magma_buffer_get_handle_enc;
+ this->magma_semaphore_get_id = &magma_semaphore_get_id_enc;
+ this->magma_semaphore_signal = &magma_semaphore_signal_enc;
+ this->magma_semaphore_reset = &magma_semaphore_reset_enc;
+ this->magma_poll = &magma_poll_enc;
+ this->magma_initialize_tracing = &magma_initialize_tracing_enc;
+ this->magma_initialize_logging = &magma_initialize_logging_enc;
+ this->magma_connection_enable_performance_counter_access = &magma_connection_enable_performance_counter_access_enc;
+ this->magma_connection_enable_performance_counters = &magma_connection_enable_performance_counters_enc;
+ this->magma_connection_create_performance_counter_buffer_pool = &magma_connection_create_performance_counter_buffer_pool_enc;
+ this->magma_connection_release_performance_counter_buffer_pool = &magma_connection_release_performance_counter_buffer_pool_enc;
+ this->magma_connection_add_performance_counter_buffer_offsets_to_pool = &magma_connection_add_performance_counter_buffer_offsets_to_pool_enc;
+ this->magma_connection_remove_performance_counter_buffer_from_pool = &magma_connection_remove_performance_counter_buffer_from_pool_enc;
+ this->magma_connection_dump_performance_counters = &magma_connection_dump_performance_counters_enc;
+ this->magma_connection_clear_performance_counters = &magma_connection_clear_performance_counters_enc;
+ this->magma_connection_read_performance_counter_completion = &magma_connection_read_performance_counter_completion_enc;
+ this->magma_virt_connection_create_image = &magma_virt_connection_create_image_enc;
+ this->magma_virt_connection_get_image_info = &magma_virt_connection_get_image_info_enc;
+}
+
diff --git a/system/magma/magma_enc/magma_enc.h b/system/magma/magma_enc/magma_enc.h
new file mode 100644
index 0000000..c4a6df5
--- /dev/null
+++ b/system/magma/magma_enc/magma_enc.h
@@ -0,0 +1,23 @@
+// Generated Code - DO NOT EDIT !!
+// generated by 'emugen'
+
+#ifndef GUARD_magma_encoder_context_t
+#define GUARD_magma_encoder_context_t
+
+#include "IOStream.h"
+#include "ChecksumCalculator.h"
+#include "magma_client_context.h"
+
+
+#include <stdint.h>
+
+struct magma_encoder_context_t : public magma_client_context_t {
+
+ IOStream *m_stream;
+ ChecksumCalculator *m_checksumCalculator;
+
+ magma_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator);
+ virtual uint64_t lockAndWriteDma(void*, uint32_t) { return 0; }
+};
+
+#endif // GUARD_magma_encoder_context_t
diff --git a/system/magma/magma_enc/magma_entry.cpp b/system/magma/magma_enc/magma_entry.cpp
new file mode 100644
index 0000000..b099440
--- /dev/null
+++ b/system/magma/magma_enc/magma_entry.cpp
@@ -0,0 +1,358 @@
+// Generated Code - DO NOT EDIT !!
+// generated by 'emugen'
+#include <stdio.h>
+#include <stdlib.h>
+#include "magma_client_context.h"
+
+extern "C" {
+ magma_status_t magma_device_import(magma_handle_t device_channel, magma_device_t* device_out);
+ void magma_device_release(magma_device_t device);
+ magma_status_t magma_device_query(magma_device_t device, uint64_t id, magma_handle_t* result_buffer_out, uint64_t* result_out);
+ magma_status_t magma_device_create_connection(magma_device_t device, magma_connection_t* connection_out);
+ void magma_connection_release(magma_connection_t connection);
+ magma_status_t magma_connection_get_error(magma_connection_t connection);
+ magma_status_t magma_connection_create_context(magma_connection_t connection, uint32_t* context_id_out);
+ void magma_connection_release_context(magma_connection_t connection, uint32_t context_id);
+ magma_status_t magma_connection_create_buffer(magma_connection_t connection, uint64_t size, uint64_t* size_out, magma_buffer_t* buffer_out);
+ void magma_connection_release_buffer(magma_connection_t connection, magma_buffer_t buffer);
+ magma_status_t magma_connection_export_buffer(magma_connection_t connection, magma_buffer_t buffer, magma_handle_t* buffer_handle_out);
+ magma_status_t magma_connection_import_buffer(magma_connection_t connection, magma_handle_t buffer_handle, magma_buffer_t* buffer_out);
+ magma_status_t magma_connection_create_semaphore(magma_connection_t connection, magma_semaphore_t* semaphore_out);
+ void magma_connection_release_semaphore(magma_connection_t connection, magma_semaphore_t semaphore);
+ magma_status_t magma_connection_export_semaphore(magma_connection_t connection, magma_semaphore_t semaphore, magma_handle_t* semaphore_handle_out);
+ magma_status_t magma_connection_import_semaphore(magma_connection_t connection, magma_handle_t semaphore_handle, magma_semaphore_t* semaphore_out);
+ magma_status_t magma_connection_buffer_range_op(magma_connection_t connection, magma_buffer_t buffer, uint32_t options, uint64_t start_offset, uint64_t length);
+ magma_status_t magma_connection_map_buffer(magma_connection_t connection, uint64_t hw_va, magma_buffer_t buffer, uint64_t offset, uint64_t length, uint64_t map_flags);
+ void magma_connection_unmap_buffer(magma_connection_t connection, uint64_t hw_va, magma_buffer_t buffer);
+ magma_status_t magma_connection_execute_command(uint64_t* parameters, uint64_t parameter_count);
+ magma_status_t magma_connection_execute_immediate_commands(uint64_t* parameters, uint64_t parameter_count);
+ magma_status_t magma_connection_flush(magma_connection_t connection);
+ magma_handle_t magma_connection_get_notification_channel_handle(magma_connection_t connection);
+ magma_status_t magma_connection_read_notification_channel(magma_connection_t connection, void* buffer, uint64_t buffer_size, uint64_t* buffer_size_out, magma_bool_t* more_data_out);
+ uint64_t magma_buffer_get_id(magma_buffer_t buffer);
+ uint64_t magma_buffer_get_size(magma_buffer_t buffer);
+ magma_status_t magma_buffer_clean_cache(magma_buffer_t buffer, uint64_t offset, uint64_t size, magma_cache_operation_t operation);
+ magma_status_t magma_buffer_set_cache_policy(magma_buffer_t buffer, magma_cache_policy_t policy);
+ magma_status_t magma_buffer_get_cache_policy(magma_buffer_t buffer, magma_cache_policy_t* cache_policy_out);
+ magma_status_t magma_buffer_set_name(magma_buffer_t buffer, void* name, uint64_t name_size);
+ magma_status_t magma_buffer_get_info(uint64_t* parameters, uint64_t parameter_count);
+ magma_status_t magma_buffer_get_handle(magma_buffer_t buffer, magma_handle_t* handle_out);
+ uint64_t magma_semaphore_get_id(magma_semaphore_t semaphore);
+ void magma_semaphore_signal(magma_semaphore_t semaphore);
+ void magma_semaphore_reset(magma_semaphore_t semaphore);
+ magma_status_t magma_poll(magma_poll_item_t* items, uint32_t count, uint64_t timeout_ns);
+ magma_status_t magma_initialize_tracing(magma_handle_t channel);
+ magma_status_t magma_initialize_logging(magma_handle_t channel);
+ magma_status_t magma_connection_enable_performance_counter_access(magma_connection_t connection, magma_handle_t channel);
+ magma_status_t magma_connection_enable_performance_counters(magma_connection_t connection, uint64_t* counters, uint64_t counters_count);
+ magma_status_t magma_connection_create_performance_counter_buffer_pool(magma_connection_t connection, magma_perf_count_pool_t* pool_id_out, magma_handle_t* notification_handle_out);
+ magma_status_t magma_connection_release_performance_counter_buffer_pool(magma_connection_t connection, magma_perf_count_pool_t pool_id);
+ magma_status_t magma_connection_add_performance_counter_buffer_offsets_to_pool(uint64_t* parameters, uint64_t parameter_count);
+ magma_status_t magma_connection_remove_performance_counter_buffer_from_pool(magma_connection_t connection, magma_perf_count_pool_t pool_id, magma_buffer_t buffer);
+ magma_status_t magma_connection_dump_performance_counters(magma_connection_t connection, magma_perf_count_pool_t pool_id, uint32_t trigger_id);
+ magma_status_t magma_connection_clear_performance_counters(magma_connection_t connection, uint64_t* counters, uint64_t counters_count);
+ magma_status_t magma_connection_read_performance_counter_completion(magma_connection_t connection, magma_perf_count_pool_t pool_id, uint32_t* trigger_id_out, uint64_t* buffer_id_out, uint32_t* buffer_offset_out, uint64_t* time_out, uint32_t* result_flags_out);
+ magma_status_t magma_virt_connection_create_image(uint64_t* parameters, uint64_t parameter_count);
+ magma_status_t magma_virt_connection_get_image_info(uint64_t* parameters, uint64_t parameter_count);
+};
+
+#ifndef GET_CONTEXT
+static magma_client_context_t::CONTEXT_ACCESSOR_TYPE *getCurrentContext = NULL;
+void magma_client_context_t::setContextAccessor(CONTEXT_ACCESSOR_TYPE *f) { getCurrentContext = f; }
+#define GET_CONTEXT magma_client_context_t * ctx = getCurrentContext()
+#endif
+
+magma_status_t magma_device_import(magma_handle_t device_channel, magma_device_t* device_out)
+{
+ GET_CONTEXT;
+ return ctx->magma_device_import(ctx, device_channel, device_out);
+}
+
+void magma_device_release(magma_device_t device)
+{
+ GET_CONTEXT;
+ ctx->magma_device_release(ctx, device);
+}
+
+magma_status_t magma_device_query(magma_device_t device, uint64_t id, magma_handle_t* result_buffer_out, uint64_t* result_out)
+{
+ GET_CONTEXT;
+ return ctx->magma_device_query(ctx, device, id, result_buffer_out, result_out);
+}
+
+magma_status_t magma_device_create_connection(magma_device_t device, magma_connection_t* connection_out)
+{
+ GET_CONTEXT;
+ return ctx->magma_device_create_connection(ctx, device, connection_out);
+}
+
+void magma_connection_release(magma_connection_t connection)
+{
+ GET_CONTEXT;
+ ctx->magma_connection_release(ctx, connection);
+}
+
+magma_status_t magma_connection_get_error(magma_connection_t connection)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_get_error(ctx, connection);
+}
+
+magma_status_t magma_connection_create_context(magma_connection_t connection, uint32_t* context_id_out)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_create_context(ctx, connection, context_id_out);
+}
+
+void magma_connection_release_context(magma_connection_t connection, uint32_t context_id)
+{
+ GET_CONTEXT;
+ ctx->magma_connection_release_context(ctx, connection, context_id);
+}
+
+magma_status_t magma_connection_create_buffer(magma_connection_t connection, uint64_t size, uint64_t* size_out, magma_buffer_t* buffer_out)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_create_buffer(ctx, connection, size, size_out, buffer_out);
+}
+
+void magma_connection_release_buffer(magma_connection_t connection, magma_buffer_t buffer)
+{
+ GET_CONTEXT;
+ ctx->magma_connection_release_buffer(ctx, connection, buffer);
+}
+
+magma_status_t magma_connection_export_buffer(magma_connection_t connection, magma_buffer_t buffer, magma_handle_t* buffer_handle_out)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_export_buffer(ctx, connection, buffer, buffer_handle_out);
+}
+
+magma_status_t magma_connection_import_buffer(magma_connection_t connection, magma_handle_t buffer_handle, magma_buffer_t* buffer_out)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_import_buffer(ctx, connection, buffer_handle, buffer_out);
+}
+
+magma_status_t magma_connection_create_semaphore(magma_connection_t connection, magma_semaphore_t* semaphore_out)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_create_semaphore(ctx, connection, semaphore_out);
+}
+
+void magma_connection_release_semaphore(magma_connection_t connection, magma_semaphore_t semaphore)
+{
+ GET_CONTEXT;
+ ctx->magma_connection_release_semaphore(ctx, connection, semaphore);
+}
+
+magma_status_t magma_connection_export_semaphore(magma_connection_t connection, magma_semaphore_t semaphore, magma_handle_t* semaphore_handle_out)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_export_semaphore(ctx, connection, semaphore, semaphore_handle_out);
+}
+
+magma_status_t magma_connection_import_semaphore(magma_connection_t connection, magma_handle_t semaphore_handle, magma_semaphore_t* semaphore_out)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_import_semaphore(ctx, connection, semaphore_handle, semaphore_out);
+}
+
+magma_status_t magma_connection_buffer_range_op(magma_connection_t connection, magma_buffer_t buffer, uint32_t options, uint64_t start_offset, uint64_t length)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_buffer_range_op(ctx, connection, buffer, options, start_offset, length);
+}
+
+magma_status_t magma_connection_map_buffer(magma_connection_t connection, uint64_t hw_va, magma_buffer_t buffer, uint64_t offset, uint64_t length, uint64_t map_flags)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_map_buffer(ctx, connection, hw_va, buffer, offset, length, map_flags);
+}
+
+void magma_connection_unmap_buffer(magma_connection_t connection, uint64_t hw_va, magma_buffer_t buffer)
+{
+ GET_CONTEXT;
+ ctx->magma_connection_unmap_buffer(ctx, connection, hw_va, buffer);
+}
+
+magma_status_t magma_connection_execute_command(uint64_t* parameters, uint64_t parameter_count)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_execute_command(ctx, parameters, parameter_count);
+}
+
+magma_status_t magma_connection_execute_immediate_commands(uint64_t* parameters, uint64_t parameter_count)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_execute_immediate_commands(ctx, parameters, parameter_count);
+}
+
+magma_status_t magma_connection_flush(magma_connection_t connection)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_flush(ctx, connection);
+}
+
+magma_handle_t magma_connection_get_notification_channel_handle(magma_connection_t connection)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_get_notification_channel_handle(ctx, connection);
+}
+
+magma_status_t magma_connection_read_notification_channel(magma_connection_t connection, void* buffer, uint64_t buffer_size, uint64_t* buffer_size_out, magma_bool_t* more_data_out)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_read_notification_channel(ctx, connection, buffer, buffer_size, buffer_size_out, more_data_out);
+}
+
+uint64_t magma_buffer_get_id(magma_buffer_t buffer)
+{
+ GET_CONTEXT;
+ return ctx->magma_buffer_get_id(ctx, buffer);
+}
+
+uint64_t magma_buffer_get_size(magma_buffer_t buffer)
+{
+ GET_CONTEXT;
+ return ctx->magma_buffer_get_size(ctx, buffer);
+}
+
+magma_status_t magma_buffer_clean_cache(magma_buffer_t buffer, uint64_t offset, uint64_t size, magma_cache_operation_t operation)
+{
+ GET_CONTEXT;
+ return ctx->magma_buffer_clean_cache(ctx, buffer, offset, size, operation);
+}
+
+magma_status_t magma_buffer_set_cache_policy(magma_buffer_t buffer, magma_cache_policy_t policy)
+{
+ GET_CONTEXT;
+ return ctx->magma_buffer_set_cache_policy(ctx, buffer, policy);
+}
+
+magma_status_t magma_buffer_get_cache_policy(magma_buffer_t buffer, magma_cache_policy_t* cache_policy_out)
+{
+ GET_CONTEXT;
+ return ctx->magma_buffer_get_cache_policy(ctx, buffer, cache_policy_out);
+}
+
+magma_status_t magma_buffer_set_name(magma_buffer_t buffer, void* name, uint64_t name_size)
+{
+ GET_CONTEXT;
+ return ctx->magma_buffer_set_name(ctx, buffer, name, name_size);
+}
+
+magma_status_t magma_buffer_get_info(uint64_t* parameters, uint64_t parameter_count)
+{
+ GET_CONTEXT;
+ return ctx->magma_buffer_get_info(ctx, parameters, parameter_count);
+}
+
+magma_status_t magma_buffer_get_handle(magma_buffer_t buffer, magma_handle_t* handle_out)
+{
+ GET_CONTEXT;
+ return ctx->magma_buffer_get_handle(ctx, buffer, handle_out);
+}
+
+uint64_t magma_semaphore_get_id(magma_semaphore_t semaphore)
+{
+ GET_CONTEXT;
+ return ctx->magma_semaphore_get_id(ctx, semaphore);
+}
+
+void magma_semaphore_signal(magma_semaphore_t semaphore)
+{
+ GET_CONTEXT;
+ ctx->magma_semaphore_signal(ctx, semaphore);
+}
+
+void magma_semaphore_reset(magma_semaphore_t semaphore)
+{
+ GET_CONTEXT;
+ ctx->magma_semaphore_reset(ctx, semaphore);
+}
+
+magma_status_t magma_poll(magma_poll_item_t* items, uint32_t count, uint64_t timeout_ns)
+{
+ GET_CONTEXT;
+ return ctx->magma_poll(ctx, items, count, timeout_ns);
+}
+
+magma_status_t magma_initialize_tracing(magma_handle_t channel)
+{
+ GET_CONTEXT;
+ return ctx->magma_initialize_tracing(ctx, channel);
+}
+
+magma_status_t magma_initialize_logging(magma_handle_t channel)
+{
+ GET_CONTEXT;
+ return ctx->magma_initialize_logging(ctx, channel);
+}
+
+magma_status_t magma_connection_enable_performance_counter_access(magma_connection_t connection, magma_handle_t channel)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_enable_performance_counter_access(ctx, connection, channel);
+}
+
+magma_status_t magma_connection_enable_performance_counters(magma_connection_t connection, uint64_t* counters, uint64_t counters_count)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_enable_performance_counters(ctx, connection, counters, counters_count);
+}
+
+magma_status_t magma_connection_create_performance_counter_buffer_pool(magma_connection_t connection, magma_perf_count_pool_t* pool_id_out, magma_handle_t* notification_handle_out)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_create_performance_counter_buffer_pool(ctx, connection, pool_id_out, notification_handle_out);
+}
+
+magma_status_t magma_connection_release_performance_counter_buffer_pool(magma_connection_t connection, magma_perf_count_pool_t pool_id)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_release_performance_counter_buffer_pool(ctx, connection, pool_id);
+}
+
+magma_status_t magma_connection_add_performance_counter_buffer_offsets_to_pool(uint64_t* parameters, uint64_t parameter_count)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_add_performance_counter_buffer_offsets_to_pool(ctx, parameters, parameter_count);
+}
+
+magma_status_t magma_connection_remove_performance_counter_buffer_from_pool(magma_connection_t connection, magma_perf_count_pool_t pool_id, magma_buffer_t buffer)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_remove_performance_counter_buffer_from_pool(ctx, connection, pool_id, buffer);
+}
+
+magma_status_t magma_connection_dump_performance_counters(magma_connection_t connection, magma_perf_count_pool_t pool_id, uint32_t trigger_id)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_dump_performance_counters(ctx, connection, pool_id, trigger_id);
+}
+
+magma_status_t magma_connection_clear_performance_counters(magma_connection_t connection, uint64_t* counters, uint64_t counters_count)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_clear_performance_counters(ctx, connection, counters, counters_count);
+}
+
+magma_status_t magma_connection_read_performance_counter_completion(magma_connection_t connection, magma_perf_count_pool_t pool_id, uint32_t* trigger_id_out, uint64_t* buffer_id_out, uint32_t* buffer_offset_out, uint64_t* time_out, uint32_t* result_flags_out)
+{
+ GET_CONTEXT;
+ return ctx->magma_connection_read_performance_counter_completion(ctx, connection, pool_id, trigger_id_out, buffer_id_out, buffer_offset_out, time_out, result_flags_out);
+}
+
+magma_status_t magma_virt_connection_create_image(uint64_t* parameters, uint64_t parameter_count)
+{
+ GET_CONTEXT;
+ return ctx->magma_virt_connection_create_image(ctx, parameters, parameter_count);
+}
+
+magma_status_t magma_virt_connection_get_image_info(uint64_t* parameters, uint64_t parameter_count)
+{
+ GET_CONTEXT;
+ return ctx->magma_virt_connection_get_image_info(ctx, parameters, parameter_count);
+}
+
diff --git a/system/magma/magma_enc/magma_ftable.h b/system/magma/magma_enc/magma_ftable.h
new file mode 100644
index 0000000..34cc962
--- /dev/null
+++ b/system/magma/magma_enc/magma_ftable.h
@@ -0,0 +1,64 @@
+// Generated Code - DO NOT EDIT !!
+// generated by 'emugen'
+#ifndef __magma_client_ftable_t_h
+#define __magma_client_ftable_t_h
+
+
+static const struct _magma_funcs_by_name {
+ const char *name;
+ void *proc;
+} magma_funcs_by_name[] = {
+ {"magma_device_import", (void*)magma_device_import},
+ {"magma_device_release", (void*)magma_device_release},
+ {"magma_device_query", (void*)magma_device_query},
+ {"magma_device_create_connection", (void*)magma_device_create_connection},
+ {"magma_connection_release", (void*)magma_connection_release},
+ {"magma_connection_get_error", (void*)magma_connection_get_error},
+ {"magma_connection_create_context", (void*)magma_connection_create_context},
+ {"magma_connection_release_context", (void*)magma_connection_release_context},
+ {"magma_connection_create_buffer", (void*)magma_connection_create_buffer},
+ {"magma_connection_release_buffer", (void*)magma_connection_release_buffer},
+ {"magma_connection_export_buffer", (void*)magma_connection_export_buffer},
+ {"magma_connection_import_buffer", (void*)magma_connection_import_buffer},
+ {"magma_connection_create_semaphore", (void*)magma_connection_create_semaphore},
+ {"magma_connection_release_semaphore", (void*)magma_connection_release_semaphore},
+ {"magma_connection_export_semaphore", (void*)magma_connection_export_semaphore},
+ {"magma_connection_import_semaphore", (void*)magma_connection_import_semaphore},
+ {"magma_connection_buffer_range_op", (void*)magma_connection_buffer_range_op},
+ {"magma_connection_map_buffer", (void*)magma_connection_map_buffer},
+ {"magma_connection_unmap_buffer", (void*)magma_connection_unmap_buffer},
+ {"magma_connection_execute_command", (void*)magma_connection_execute_command},
+ {"magma_connection_execute_immediate_commands", (void*)magma_connection_execute_immediate_commands},
+ {"magma_connection_flush", (void*)magma_connection_flush},
+ {"magma_connection_get_notification_channel_handle", (void*)magma_connection_get_notification_channel_handle},
+ {"magma_connection_read_notification_channel", (void*)magma_connection_read_notification_channel},
+ {"magma_buffer_get_id", (void*)magma_buffer_get_id},
+ {"magma_buffer_get_size", (void*)magma_buffer_get_size},
+ {"magma_buffer_clean_cache", (void*)magma_buffer_clean_cache},
+ {"magma_buffer_set_cache_policy", (void*)magma_buffer_set_cache_policy},
+ {"magma_buffer_get_cache_policy", (void*)magma_buffer_get_cache_policy},
+ {"magma_buffer_set_name", (void*)magma_buffer_set_name},
+ {"magma_buffer_get_info", (void*)magma_buffer_get_info},
+ {"magma_buffer_get_handle", (void*)magma_buffer_get_handle},
+ {"magma_semaphore_get_id", (void*)magma_semaphore_get_id},
+ {"magma_semaphore_signal", (void*)magma_semaphore_signal},
+ {"magma_semaphore_reset", (void*)magma_semaphore_reset},
+ {"magma_poll", (void*)magma_poll},
+ {"magma_initialize_tracing", (void*)magma_initialize_tracing},
+ {"magma_initialize_logging", (void*)magma_initialize_logging},
+ {"magma_connection_enable_performance_counter_access", (void*)magma_connection_enable_performance_counter_access},
+ {"magma_connection_enable_performance_counters", (void*)magma_connection_enable_performance_counters},
+ {"magma_connection_create_performance_counter_buffer_pool", (void*)magma_connection_create_performance_counter_buffer_pool},
+ {"magma_connection_release_performance_counter_buffer_pool", (void*)magma_connection_release_performance_counter_buffer_pool},
+ {"magma_connection_add_performance_counter_buffer_offsets_to_pool", (void*)magma_connection_add_performance_counter_buffer_offsets_to_pool},
+ {"magma_connection_remove_performance_counter_buffer_from_pool", (void*)magma_connection_remove_performance_counter_buffer_from_pool},
+ {"magma_connection_dump_performance_counters", (void*)magma_connection_dump_performance_counters},
+ {"magma_connection_clear_performance_counters", (void*)magma_connection_clear_performance_counters},
+ {"magma_connection_read_performance_counter_completion", (void*)magma_connection_read_performance_counter_completion},
+ {"magma_virt_connection_create_image", (void*)magma_virt_connection_create_image},
+ {"magma_virt_connection_get_image_info", (void*)magma_virt_connection_get_image_info},
+};
+static const int magma_num_funcs = sizeof(magma_funcs_by_name) / sizeof(struct _magma_funcs_by_name);
+
+
+#endif
diff --git a/system/magma/magma_enc/magma_opcodes.h b/system/magma/magma_enc/magma_opcodes.h
new file mode 100644
index 0000000..8b2d2a2
--- /dev/null
+++ b/system/magma/magma_enc/magma_opcodes.h
@@ -0,0 +1,58 @@
+// Generated Code - DO NOT EDIT !!
+// generated by 'emugen'
+#ifndef __GUARD_magma_opcodes_h_
+#define __GUARD_magma_opcodes_h_
+
+#define OP_magma_device_import 100000
+#define OP_magma_device_release 100001
+#define OP_magma_device_query 100002
+#define OP_magma_device_create_connection 100003
+#define OP_magma_connection_release 100004
+#define OP_magma_connection_get_error 100005
+#define OP_magma_connection_create_context 100006
+#define OP_magma_connection_release_context 100007
+#define OP_magma_connection_create_buffer 100008
+#define OP_magma_connection_release_buffer 100009
+#define OP_magma_connection_export_buffer 100010
+#define OP_magma_connection_import_buffer 100011
+#define OP_magma_connection_create_semaphore 100012
+#define OP_magma_connection_release_semaphore 100013
+#define OP_magma_connection_export_semaphore 100014
+#define OP_magma_connection_import_semaphore 100015
+#define OP_magma_connection_buffer_range_op 100016
+#define OP_magma_connection_map_buffer 100017
+#define OP_magma_connection_unmap_buffer 100018
+#define OP_magma_connection_execute_command 100019
+#define OP_magma_connection_execute_immediate_commands 100020
+#define OP_magma_connection_flush 100021
+#define OP_magma_connection_get_notification_channel_handle 100022
+#define OP_magma_connection_read_notification_channel 100023
+#define OP_magma_buffer_get_id 100024
+#define OP_magma_buffer_get_size 100025
+#define OP_magma_buffer_clean_cache 100026
+#define OP_magma_buffer_set_cache_policy 100027
+#define OP_magma_buffer_get_cache_policy 100028
+#define OP_magma_buffer_set_name 100029
+#define OP_magma_buffer_get_info 100030
+#define OP_magma_buffer_get_handle 100031
+#define OP_magma_semaphore_get_id 100032
+#define OP_magma_semaphore_signal 100033
+#define OP_magma_semaphore_reset 100034
+#define OP_magma_poll 100035
+#define OP_magma_initialize_tracing 100036
+#define OP_magma_initialize_logging 100037
+#define OP_magma_connection_enable_performance_counter_access 100038
+#define OP_magma_connection_enable_performance_counters 100039
+#define OP_magma_connection_create_performance_counter_buffer_pool 100040
+#define OP_magma_connection_release_performance_counter_buffer_pool 100041
+#define OP_magma_connection_add_performance_counter_buffer_offsets_to_pool 100042
+#define OP_magma_connection_remove_performance_counter_buffer_from_pool 100043
+#define OP_magma_connection_dump_performance_counters 100044
+#define OP_magma_connection_clear_performance_counters 100045
+#define OP_magma_connection_read_performance_counter_completion 100046
+#define OP_magma_virt_connection_create_image 100047
+#define OP_magma_virt_connection_get_image_info 100048
+#define OP_last 100049
+
+
+#endif
diff --git a/system/magma/magma_enc_util.cpp b/system/magma/magma_enc_util.cpp
new file mode 100644
index 0000000..2980625
--- /dev/null
+++ b/system/magma/magma_enc_util.cpp
@@ -0,0 +1,58 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "magma_enc_util.h"
+
+#include <cstring>
+
+namespace magma_enc_util {
+
+size_t size_command_descriptor(magma_command_descriptor* descriptor) {
+ uint64_t size = sizeof(magma_command_descriptor);
+ size += sizeof(magma_exec_resource) * descriptor->resource_count;
+ size += sizeof(magma_exec_command_buffer) * descriptor->command_buffer_count;
+ size +=
+ sizeof(uint64_t) * (descriptor->wait_semaphore_count + descriptor->signal_semaphore_count);
+ return size;
+}
+
+void pack_command_descriptor(void* void_ptr, magma_connection_t connection, uint32_t context_id,
+ magma_command_descriptor* descriptor) {
+ magma_exec_resource* resources = descriptor->resources;
+ magma_exec_command_buffer* command_buffers = descriptor->command_buffers;
+ uint64_t* semaphore_ids = descriptor->semaphore_ids;
+
+ magma_command_descriptor desc_copy = *descriptor;
+ desc_copy.resources = 0;
+ desc_copy.command_buffers = 0;
+ desc_copy.semaphore_ids = 0;
+
+ auto ptr = reinterpret_cast<uint8_t*>(void_ptr);
+
+ memcpy(ptr, &desc_copy, sizeof(magma_command_descriptor));
+ ptr += sizeof(magma_command_descriptor);
+
+ memcpy(ptr, resources, sizeof(magma_exec_resource) * descriptor->resource_count);
+ ptr += sizeof(magma_exec_resource) * descriptor->resource_count;
+
+ memcpy(ptr, command_buffers,
+ sizeof(magma_exec_command_buffer) * descriptor->command_buffer_count);
+ ptr += sizeof(magma_exec_command_buffer) * descriptor->command_buffer_count;
+
+ memcpy(
+ ptr, semaphore_ids,
+ sizeof(uint64_t) * (descriptor->wait_semaphore_count + descriptor->signal_semaphore_count));
+}
+
+} // namespace magma_enc_util
diff --git a/system/magma/magma_enc_util.h b/system/magma/magma_enc_util.h
new file mode 100644
index 0000000..8d67a10
--- /dev/null
+++ b/system/magma/magma_enc_util.h
@@ -0,0 +1,27 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <log/log.h>
+#include <magma/magma_common_defs.h>
+#include <stddef.h>
+
+namespace magma_enc_util {
+
+size_t size_command_descriptor(magma_command_descriptor* descriptor);
+void pack_command_descriptor(void* ptr, magma_connection_t connection, uint32_t context_id,
+ magma_command_descriptor* descriptor);
+
+} // namespace magma_enc_util
diff --git a/system/magma/magma_types.h b/system/magma/magma_types.h
new file mode 100644
index 0000000..9b13cce
--- /dev/null
+++ b/system/magma/magma_types.h
@@ -0,0 +1,15 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <magma/magma_common_defs.h>
diff --git a/system/magma/meson.build b/system/magma/meson.build
new file mode 100644
index 0000000..2c9681e
--- /dev/null
+++ b/system/magma/meson.build
@@ -0,0 +1,40 @@
+# Copyright 2023 Android Open Source Project
+# SPDX-License-Identifier: MIT
+
+files_lib_magma_enc = files(
+ 'magma.cpp',
+ 'magma_enc_util.cpp',
+ 'magma_enc/magma_enc.cpp',
+ 'magma_enc/magma_entry.cpp',
+ 'magma_enc/magma_client_context.cpp',
+ )
+
+inc_magma_enc = include_directories('magma_enc')
+
+lib_magma_enc = static_library(
+ 'magma',
+ files_lib_magma_enc,
+ cpp_args: cpp_args + [
+ '-Wno-misleading-indentation',
+ '-Wno-unused-function',
+ ],
+ include_directories: [inc_magma, inc_magma_enc, inc_android_emu, inc_host, inc_android_compat,
+ inc_opengl_codec, inc_opengl_system, inc_render_enc, inc_system,
+ inc_goldfish_address_space, inc_platform],
+ link_with: [
+ lib_platform,
+ lib_stream, # for ASG
+ lib_codec_common, # for checksums
+ lib_emu_android_base, # for tracing
+ lib_android_compat # for logging
+ ],
+ dependencies: [
+ fuchsia_magma_dep,
+ dependency('libdrm')
+ ],
+)
+
+lib_magma_gfxstream_dep = declare_dependency(
+ include_directories: [inc_magma, inc_magma_enc],
+ link_with: [lib_magma_enc],
+)
diff --git a/system/meson.build b/system/meson.build
index 53ab876..af8f8e9 100644
--- a/system/meson.build
+++ b/system/meson.build
@@ -1,6 +1,7 @@
# Copyright 2022 Android Open Source Project
# SPDX-License-Identifier: MIT
+inc_magma = include_directories('magma')
inc_opengl_system = include_directories('OpenglSystemCommon')
inc_render_enc = include_directories('renderControl_enc')
inc_vulkan_enc = include_directories('vulkan_enc')
@@ -9,3 +10,4 @@
subdir('renderControl_enc')
subdir('OpenglSystemCommon')
subdir('vulkan')
+subdir('magma')
diff --git a/system/vulkan_enc/VkEncoder.cpp b/system/vulkan_enc/VkEncoder.cpp
index ccdccfd..6f70fb0 100644
--- a/system/vulkan_enc/VkEncoder.cpp
+++ b/system/vulkan_enc/VkEncoder.cpp
@@ -16,7 +16,7 @@
// Autogenerated module VkEncoder
//
// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -58353,204 +58353,6 @@
#endif
#ifdef VK_GOOGLE_gfxstream
-VkResult VkEncoder::vkRegisterImageColorBufferGOOGLE(VkDevice device, VkImage image,
- uint32_t colorBuffer, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkRegisterImageColorBufferGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
- ENCODER_DEBUG_LOG("vkRegisterImageColorBufferGOOGLE(device:%p, image:%p, colorBuffer:%d)",
- device, image, colorBuffer);
- (void)doLock;
- bool queueSubmitWithCommandsEnabled =
- sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
- if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
- auto stream = mImpl->stream();
- auto pool = mImpl->pool();
- VkDevice local_device;
- VkImage local_image;
- uint32_t local_colorBuffer;
- local_device = device;
- local_image = image;
- local_colorBuffer = colorBuffer;
- size_t count = 0;
- size_t* countPtr = &count;
- {
- uint64_t cgen_var_0;
- *countPtr += 1 * 8;
- uint64_t cgen_var_1;
- *countPtr += 1 * 8;
- *countPtr += sizeof(uint32_t);
- }
- uint32_t packetSize_vkRegisterImageColorBufferGOOGLE =
- 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkRegisterImageColorBufferGOOGLE);
- uint8_t* streamPtr = stream->reserve(packetSize_vkRegisterImageColorBufferGOOGLE);
- uint8_t* packetBeginPtr = streamPtr;
- uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkRegisterImageColorBufferGOOGLE = OP_vkRegisterImageColorBufferGOOGLE;
- uint32_t seqno;
- if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
- memcpy(streamPtr, &opcode_vkRegisterImageColorBufferGOOGLE, sizeof(uint32_t));
- streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkRegisterImageColorBufferGOOGLE, sizeof(uint32_t));
- streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) {
- memcpy(streamPtr, &seqno, sizeof(uint32_t));
- streamPtr += sizeof(uint32_t);
- }
- uint64_t cgen_var_0;
- *&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
- memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
- *streamPtrPtr += 1 * 8;
- uint64_t cgen_var_1;
- *&cgen_var_1 = get_host_u64_VkImage((*&local_image));
- memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
- *streamPtrPtr += 1 * 8;
- memcpy(*streamPtrPtr, (uint32_t*)&local_colorBuffer, sizeof(uint32_t));
- *streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkRegisterImageColorBufferGOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
- VkResult vkRegisterImageColorBufferGOOGLE_VkResult_return = (VkResult)0;
- stream->read(&vkRegisterImageColorBufferGOOGLE_VkResult_return, sizeof(VkResult));
- ++encodeCount;
- ;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
- pool->freeAll();
- stream->clearPool();
- }
- if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
- return vkRegisterImageColorBufferGOOGLE_VkResult_return;
-}
-
-VkResult VkEncoder::vkRegisterBufferColorBufferGOOGLE(VkDevice device, VkBuffer buffer,
- uint32_t colorBuffer, uint32_t doLock) {
- std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
- std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
- std::vector<uint8_t> healthMonitorAnnotation_packetContents;
-
- auto watchdog =
- WATCHDOG_BUILDER(mHealthMonitor, "vkRegisterBufferColorBufferGOOGLE in VkEncoder")
- .setOnHangCallback([&]() {
- auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
- if (healthMonitorAnnotation_seqno) {
- annotations->insert(
- {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
- }
- if (healthMonitorAnnotation_packetSize) {
- annotations->insert(
- {{"packetSize",
- std::to_string(healthMonitorAnnotation_packetSize.value())}});
- }
- if (!healthMonitorAnnotation_packetContents.empty()) {
- annotations->insert(
- {{"packetContents",
- getPacketContents(&healthMonitorAnnotation_packetContents[0],
- healthMonitorAnnotation_packetContents.size())}});
- }
- return std::move(annotations);
- })
- .build();
-
- ENCODER_DEBUG_LOG("vkRegisterBufferColorBufferGOOGLE(device:%p, buffer:%p, colorBuffer:%d)",
- device, buffer, colorBuffer);
- (void)doLock;
- bool queueSubmitWithCommandsEnabled =
- sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
- if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
- auto stream = mImpl->stream();
- auto pool = mImpl->pool();
- VkDevice local_device;
- VkBuffer local_buffer;
- uint32_t local_colorBuffer;
- local_device = device;
- local_buffer = buffer;
- local_colorBuffer = colorBuffer;
- size_t count = 0;
- size_t* countPtr = &count;
- {
- uint64_t cgen_var_0;
- *countPtr += 1 * 8;
- uint64_t cgen_var_1;
- *countPtr += 1 * 8;
- *countPtr += sizeof(uint32_t);
- }
- uint32_t packetSize_vkRegisterBufferColorBufferGOOGLE =
- 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- healthMonitorAnnotation_packetSize =
- std::make_optional(packetSize_vkRegisterBufferColorBufferGOOGLE);
- uint8_t* streamPtr = stream->reserve(packetSize_vkRegisterBufferColorBufferGOOGLE);
- uint8_t* packetBeginPtr = streamPtr;
- uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkRegisterBufferColorBufferGOOGLE = OP_vkRegisterBufferColorBufferGOOGLE;
- uint32_t seqno;
- if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- healthMonitorAnnotation_seqno = std::make_optional(seqno);
- memcpy(streamPtr, &opcode_vkRegisterBufferColorBufferGOOGLE, sizeof(uint32_t));
- streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkRegisterBufferColorBufferGOOGLE, sizeof(uint32_t));
- streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) {
- memcpy(streamPtr, &seqno, sizeof(uint32_t));
- streamPtr += sizeof(uint32_t);
- }
- uint64_t cgen_var_0;
- *&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
- memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
- *streamPtrPtr += 1 * 8;
- uint64_t cgen_var_1;
- *&cgen_var_1 = get_host_u64_VkBuffer((*&local_buffer));
- memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
- *streamPtrPtr += 1 * 8;
- memcpy(*streamPtrPtr, (uint32_t*)&local_colorBuffer, sizeof(uint32_t));
- *streamPtrPtr += sizeof(uint32_t);
- if (watchdog) {
- size_t watchdogBufSize = std::min<size_t>(
- static_cast<size_t>(packetSize_vkRegisterBufferColorBufferGOOGLE), kWatchdogBufferMax);
- healthMonitorAnnotation_packetContents.resize(watchdogBufSize);
- memcpy(&healthMonitorAnnotation_packetContents[0], packetBeginPtr, watchdogBufSize);
- }
- VkResult vkRegisterBufferColorBufferGOOGLE_VkResult_return = (VkResult)0;
- stream->read(&vkRegisterBufferColorBufferGOOGLE_VkResult_return, sizeof(VkResult));
- ++encodeCount;
- ;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
- pool->freeAll();
- stream->clearPool();
- }
- if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
- return vkRegisterBufferColorBufferGOOGLE_VkResult_return;
-}
-
VkResult VkEncoder::vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device, VkDeviceMemory memory,
uint64_t* pAddress, uint32_t doLock) {
std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
diff --git a/system/vulkan_enc/VkEncoder.h b/system/vulkan_enc/VkEncoder.h
index 46878e2..e5a66db 100644
--- a/system/vulkan_enc/VkEncoder.h
+++ b/system/vulkan_enc/VkEncoder.h
@@ -16,7 +16,7 @@
// Autogenerated module VkEncoder
//
// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// cereal -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -1963,10 +1963,6 @@
const VkBool32* pColorWriteEnables, uint32_t doLock);
#endif
#ifdef VK_GOOGLE_gfxstream
- VkResult vkRegisterImageColorBufferGOOGLE(VkDevice device, VkImage image, uint32_t colorBuffer,
- uint32_t doLock);
- VkResult vkRegisterBufferColorBufferGOOGLE(VkDevice device, VkBuffer buffer,
- uint32_t colorBuffer, uint32_t doLock);
VkResult vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device, VkDeviceMemory memory,
uint64_t* pAddress, uint32_t doLock);
void vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
diff --git a/system/vulkan_enc/func_table.cpp b/system/vulkan_enc/func_table.cpp
index af9f673..7b5a27c 100644
--- a/system/vulkan_enc/func_table.cpp
+++ b/system/vulkan_enc/func_table.cpp
@@ -16,7 +16,7 @@
// Autogenerated module func_table
//
// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -8128,51 +8128,6 @@
}
#endif
#ifdef VK_GOOGLE_gfxstream
-static VkResult entry_vkRegisterImageColorBufferGOOGLE(VkDevice device, VkImage image,
- uint32_t colorBuffer) {
- AEMU_SCOPED_TRACE("vkRegisterImageColorBufferGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkRegisterImageColorBufferGOOGLE_VkResult_return = (VkResult)0;
- vkRegisterImageColorBufferGOOGLE_VkResult_return =
- vkEnc->vkRegisterImageColorBufferGOOGLE(device, image, colorBuffer, true /* do lock */);
- return vkRegisterImageColorBufferGOOGLE_VkResult_return;
-}
-static VkResult dynCheck_entry_vkRegisterImageColorBufferGOOGLE(VkDevice device, VkImage image,
- uint32_t colorBuffer) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkRegisterImageColorBufferGOOGLE", "VK_GOOGLE_gfxstream");
- }
- AEMU_SCOPED_TRACE("vkRegisterImageColorBufferGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkRegisterImageColorBufferGOOGLE_VkResult_return = (VkResult)0;
- vkRegisterImageColorBufferGOOGLE_VkResult_return =
- vkEnc->vkRegisterImageColorBufferGOOGLE(device, image, colorBuffer, true /* do lock */);
- return vkRegisterImageColorBufferGOOGLE_VkResult_return;
-}
-static VkResult entry_vkRegisterBufferColorBufferGOOGLE(VkDevice device, VkBuffer buffer,
- uint32_t colorBuffer) {
- AEMU_SCOPED_TRACE("vkRegisterBufferColorBufferGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkRegisterBufferColorBufferGOOGLE_VkResult_return = (VkResult)0;
- vkRegisterBufferColorBufferGOOGLE_VkResult_return =
- vkEnc->vkRegisterBufferColorBufferGOOGLE(device, buffer, colorBuffer, true /* do lock */);
- return vkRegisterBufferColorBufferGOOGLE_VkResult_return;
-}
-static VkResult dynCheck_entry_vkRegisterBufferColorBufferGOOGLE(VkDevice device, VkBuffer buffer,
- uint32_t colorBuffer) {
- auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
- sOnInvalidDynamicallyCheckedCall("vkRegisterBufferColorBufferGOOGLE",
- "VK_GOOGLE_gfxstream");
- }
- AEMU_SCOPED_TRACE("vkRegisterBufferColorBufferGOOGLE");
- auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkRegisterBufferColorBufferGOOGLE_VkResult_return = (VkResult)0;
- vkRegisterBufferColorBufferGOOGLE_VkResult_return =
- vkEnc->vkRegisterBufferColorBufferGOOGLE(device, buffer, colorBuffer, true /* do lock */);
- return vkRegisterBufferColorBufferGOOGLE_VkResult_return;
-}
static VkResult entry_vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device, VkDeviceMemory memory,
uint64_t* pAddress) {
AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE");
@@ -10819,12 +10774,6 @@
}
#endif
#ifdef VK_GOOGLE_gfxstream
- if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE")) {
- return nullptr;
- }
- if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE")) {
- return nullptr;
- }
if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) {
return nullptr;
}
@@ -13006,14 +12955,6 @@
}
#endif
#ifdef VK_GOOGLE_gfxstream
- if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkRegisterImageColorBufferGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE")) {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)dynCheck_entry_vkRegisterBufferColorBufferGOOGLE : nullptr;
- }
if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)dynCheck_entry_vkMapMemoryIntoAddressSpaceGOOGLE : nullptr;
@@ -15260,14 +15201,6 @@
}
#endif
#ifdef VK_GOOGLE_gfxstream
- if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkRegisterImageColorBufferGOOGLE : nullptr;
- }
- if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE")) {
- bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
- return hasExt ? (void*)entry_vkRegisterBufferColorBufferGOOGLE : nullptr;
- }
if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkMapMemoryIntoAddressSpaceGOOGLE : nullptr;
diff --git a/system/vulkan_enc/func_table.h b/system/vulkan_enc/func_table.h
index bda48a8..a7b7b66 100644
--- a/system/vulkan_enc/func_table.h
+++ b/system/vulkan_enc/func_table.h
@@ -16,7 +16,7 @@
// Autogenerated module func_table
//
// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// cereal -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
diff --git a/system/vulkan_enc/goldfish_vk_counting_guest.cpp b/system/vulkan_enc/goldfish_vk_counting_guest.cpp
index f359126..2a023a7 100644
--- a/system/vulkan_enc/goldfish_vk_counting_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_counting_guest.cpp
@@ -16,7 +16,7 @@
// Autogenerated module goldfish_vk_counting_guest
//
// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -13755,25 +13755,6 @@
*count += sizeof(uint32_t);
}
-void count_VkImportPhysicalAddressGOOGLE(uint32_t featureBits, VkStructureType rootType,
- const VkImportPhysicalAddressGOOGLE* toCount,
- size_t* count) {
- (void)featureBits;
- (void)rootType;
- (void)toCount;
- (void)count;
- *count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = toCount->sType;
- }
- count_extension_struct(featureBits, rootType, toCount->pNext, count);
- *count += sizeof(uint64_t);
- *count += sizeof(VkDeviceSize);
- *count += sizeof(VkFormat);
- *count += sizeof(VkImageTiling);
- *count += sizeof(uint32_t);
-}
-
#endif
#ifdef VK_EXT_global_priority_query
void count_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
@@ -16480,13 +16461,6 @@
count);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
- count_VkImportPhysicalAddressGOOGLE(
- featureBits, rootType,
- reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension),
- count);
- break;
- }
default: {
count_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
featureBits, rootType,
@@ -17284,12 +17258,6 @@
reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
- count_VkImportPhysicalAddressGOOGLE(
- featureBits, rootType,
- reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension), count);
- break;
- }
#endif
#ifdef VK_EXT_global_priority_query
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
diff --git a/system/vulkan_enc/goldfish_vk_counting_guest.h b/system/vulkan_enc/goldfish_vk_counting_guest.h
index 6e959ad..2e29028 100644
--- a/system/vulkan_enc/goldfish_vk_counting_guest.h
+++ b/system/vulkan_enc/goldfish_vk_counting_guest.h
@@ -16,7 +16,7 @@
// Autogenerated module goldfish_vk_counting_guest
//
// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// cereal -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -3415,10 +3415,6 @@
void count_VkImportBufferGOOGLE(uint32_t featureBits, VkStructureType rootType,
const VkImportBufferGOOGLE* toCount, size_t* count);
-void count_VkImportPhysicalAddressGOOGLE(uint32_t featureBits, VkStructureType rootType,
- const VkImportPhysicalAddressGOOGLE* toCount,
- size_t* count);
-
#endif
#ifdef VK_EXT_global_priority_query
void count_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
index c88a3cf..8d30be3 100644
--- a/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
@@ -16,7 +16,7 @@
// Autogenerated module goldfish_vk_deepcopy_guest
//
// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -17024,28 +17024,6 @@
}
}
-void deepcopy_VkImportPhysicalAddressGOOGLE(Allocator* alloc, VkStructureType rootType,
- const VkImportPhysicalAddressGOOGLE* from,
- VkImportPhysicalAddressGOOGLE* to) {
- (void)alloc;
- (void)rootType;
- *to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = from->sType;
- }
- const void* from_pNext = from;
- size_t pNext_size = 0u;
- while (!pNext_size && from_pNext) {
- from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
- pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
- }
- to->pNext = nullptr;
- if (pNext_size) {
- to->pNext = (void*)alloc->alloc(pNext_size);
- deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
- }
-}
-
#endif
#ifdef VK_EXT_global_priority_query
void deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
@@ -20054,13 +20032,6 @@
structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
- deepcopy_VkImportPhysicalAddressGOOGLE(
- alloc, rootType,
- reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension),
- reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
- break;
- }
default: {
deepcopy_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
alloc, rootType,
@@ -20920,13 +20891,6 @@
reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
- deepcopy_VkImportPhysicalAddressGOOGLE(
- alloc, rootType,
- reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension),
- reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
- break;
- }
#endif
#ifdef VK_EXT_global_priority_query
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.h b/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
index 2c59e5b..679ddf0 100644
--- a/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
+++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
@@ -16,7 +16,7 @@
// Autogenerated module goldfish_vk_deepcopy_guest
//
// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// cereal -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -3774,10 +3774,6 @@
void deepcopy_VkImportBufferGOOGLE(Allocator* alloc, VkStructureType rootType,
const VkImportBufferGOOGLE* from, VkImportBufferGOOGLE* to);
-void deepcopy_VkImportPhysicalAddressGOOGLE(Allocator* alloc, VkStructureType rootType,
- const VkImportPhysicalAddressGOOGLE* from,
- VkImportPhysicalAddressGOOGLE* to);
-
#endif
#ifdef VK_EXT_global_priority_query
void deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
diff --git a/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp b/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
index d2c499f..aef23e9 100644
--- a/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
@@ -16,7 +16,7 @@
// Autogenerated module goldfish_vk_extension_structs_guest
//
// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -1553,10 +1553,6 @@
return sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
- return sizeof(VkImportPhysicalAddressGOOGLE);
- break;
- }
default: {
return sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT);
break;
@@ -1943,9 +1939,6 @@
case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE: {
return sizeof(VkImportBufferGOOGLE);
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
- return sizeof(VkImportPhysicalAddressGOOGLE);
- }
#endif
#ifdef VK_EXT_global_priority_query
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
@@ -2985,10 +2978,6 @@
return sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
- return sizeof(VkImportPhysicalAddressGOOGLE);
- break;
- }
default: {
return sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT);
break;
@@ -3375,9 +3364,6 @@
case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE: {
return sizeof(VkImportBufferGOOGLE);
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
- return sizeof(VkImportPhysicalAddressGOOGLE);
- }
#endif
#ifdef VK_EXT_global_priority_query
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
diff --git a/system/vulkan_enc/goldfish_vk_extension_structs_guest.h b/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
index ae0e5df..67d83d7 100644
--- a/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
+++ b/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
@@ -16,7 +16,7 @@
// Autogenerated module goldfish_vk_extension_structs_guest
//
// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// cereal -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
diff --git a/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp b/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
index 2759863..21eee10 100644
--- a/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
@@ -16,7 +16,7 @@
// Autogenerated module goldfish_vk_handlemap_guest
//
// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -7794,15 +7794,6 @@
}
}
-void handlemap_VkImportPhysicalAddressGOOGLE(VulkanHandleMapping* handlemap,
- VkImportPhysicalAddressGOOGLE* toMap) {
- (void)handlemap;
- (void)toMap;
- if (toMap->pNext) {
- handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
- }
-}
-
#endif
#ifdef VK_EXT_global_priority_query
void handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
@@ -10484,11 +10475,6 @@
handlemap, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
- handlemap_VkImportPhysicalAddressGOOGLE(
- handlemap, reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
- break;
- }
#endif
#ifdef VK_EXT_global_priority_query
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
diff --git a/system/vulkan_enc/goldfish_vk_handlemap_guest.h b/system/vulkan_enc/goldfish_vk_handlemap_guest.h
index 6e4c295..a37c141 100644
--- a/system/vulkan_enc/goldfish_vk_handlemap_guest.h
+++ b/system/vulkan_enc/goldfish_vk_handlemap_guest.h
@@ -16,7 +16,7 @@
// Autogenerated module goldfish_vk_handlemap_guest
//
// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// cereal -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -2883,9 +2883,6 @@
void handlemap_VkImportBufferGOOGLE(VulkanHandleMapping* handlemap, VkImportBufferGOOGLE* toMap);
-void handlemap_VkImportPhysicalAddressGOOGLE(VulkanHandleMapping* handlemap,
- VkImportPhysicalAddressGOOGLE* toMap);
-
#endif
#ifdef VK_EXT_global_priority_query
void handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
index c6a3cc5..3fb53d2 100644
--- a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
@@ -16,7 +16,7 @@
// Autogenerated module goldfish_vk_marshaling_guest
//
// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -24876,37 +24876,6 @@
vkStream->read((uint32_t*)&forUnmarshaling->buffer, sizeof(uint32_t));
}
-void marshal_VkImportPhysicalAddressGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkImportPhysicalAddressGOOGLE* forMarshaling) {
- (void)rootType;
- vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((uint64_t*)&forMarshaling->physicalAddress, sizeof(uint64_t));
- vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
- vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
- vkStream->write((VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
- vkStream->write((uint32_t*)&forMarshaling->tilingParameter, sizeof(uint32_t));
-}
-
-void unmarshal_VkImportPhysicalAddressGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkImportPhysicalAddressGOOGLE* forUnmarshaling) {
- (void)rootType;
- vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- forUnmarshaling->sType = VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forUnmarshaling->sType;
- }
- unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((uint64_t*)&forUnmarshaling->physicalAddress, sizeof(uint64_t));
- vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
- vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
- vkStream->read((VkImageTiling*)&forUnmarshaling->tiling, sizeof(VkImageTiling));
- vkStream->read((uint32_t*)&forUnmarshaling->tilingParameter, sizeof(uint32_t));
-}
-
#endif
#ifdef VK_EXT_global_priority_query
void marshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
@@ -28018,12 +27987,6 @@
structExtension));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
- marshal_VkImportPhysicalAddressGOOGLE(
- vkStream, rootType,
- reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension));
- break;
- }
default: {
marshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
vkStream, rootType,
@@ -28743,12 +28706,6 @@
vkStream, rootType, reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
- marshal_VkImportPhysicalAddressGOOGLE(
- vkStream, rootType,
- reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension));
- break;
- }
#endif
#ifdef VK_EXT_global_priority_query
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
@@ -30707,12 +30664,6 @@
structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
- unmarshal_VkImportPhysicalAddressGOOGLE(
- vkStream, rootType,
- reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
- break;
- }
default: {
unmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
vkStream, rootType,
@@ -31423,12 +31374,6 @@
vkStream, rootType, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
- unmarshal_VkImportPhysicalAddressGOOGLE(
- vkStream, rootType,
- reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
- break;
- }
#endif
#ifdef VK_EXT_global_priority_query
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
@@ -32584,12 +32529,6 @@
case OP_vkMapMemoryIntoAddressSpaceGOOGLE: {
return "OP_vkMapMemoryIntoAddressSpaceGOOGLE";
}
- case OP_vkRegisterImageColorBufferGOOGLE: {
- return "OP_vkRegisterImageColorBufferGOOGLE";
- }
- case OP_vkRegisterBufferColorBufferGOOGLE: {
- return "OP_vkRegisterBufferColorBufferGOOGLE";
- }
case OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE: {
return "OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE";
}
diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.h b/system/vulkan_enc/goldfish_vk_marshaling_guest.h
index 5ed2791..316e356 100644
--- a/system/vulkan_enc/goldfish_vk_marshaling_guest.h
+++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.h
@@ -16,7 +16,7 @@
// Autogenerated module goldfish_vk_marshaling_guest
//
// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// cereal -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -6680,14 +6680,6 @@
void unmarshal_VkImportBufferGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
VkImportBufferGOOGLE* forUnmarshaling);
-void marshal_VkImportPhysicalAddressGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkImportPhysicalAddressGOOGLE* forMarshaling);
-
-void unmarshal_VkImportPhysicalAddressGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
- VkImportPhysicalAddressGOOGLE* forUnmarshaling);
-
-#define OP_vkRegisterImageColorBufferGOOGLE 20318
-#define OP_vkRegisterBufferColorBufferGOOGLE 20319
#define OP_vkMapMemoryIntoAddressSpaceGOOGLE 20317
#define OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE 20320
#define OP_vkBeginCommandBufferAsyncGOOGLE 20321
diff --git a/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp b/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp
index 6960311..2631f9b 100644
--- a/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp
@@ -16,7 +16,7 @@
// Autogenerated module goldfish_vk_reserved_marshaling_guest
//
// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -16559,29 +16559,6 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkImportPhysicalAddressGOOGLE(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkImportPhysicalAddressGOOGLE* forMarshaling, uint8_t** ptr) {
- (void)vkStream;
- (void)rootType;
- memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- *ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
- rootType = forMarshaling->sType;
- }
- reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (uint64_t*)&forMarshaling->physicalAddress, sizeof(uint64_t));
- *ptr += sizeof(uint64_t);
- memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
- *ptr += sizeof(VkDeviceSize);
- memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
- *ptr += sizeof(VkFormat);
- memcpy(*ptr, (VkImageTiling*)&forMarshaling->tiling, sizeof(VkImageTiling));
- *ptr += sizeof(VkImageTiling);
- memcpy(*ptr, (uint32_t*)&forMarshaling->tilingParameter, sizeof(uint32_t));
- *ptr += sizeof(uint32_t);
-}
-
#endif
#ifdef VK_EXT_global_priority_query
void reservedmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
@@ -19389,13 +19366,6 @@
ptr);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
- reservedmarshal_VkImportPhysicalAddressGOOGLE(
- vkStream, rootType,
- reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension),
- ptr);
- break;
- }
default: {
reservedmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
vkStream, rootType,
@@ -20189,12 +20159,6 @@
ptr);
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
- reservedmarshal_VkImportPhysicalAddressGOOGLE(
- vkStream, rootType,
- reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension), ptr);
- break;
- }
#endif
#ifdef VK_EXT_global_priority_query
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
diff --git a/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h b/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h
index a1ed9ad..1449dfd 100644
--- a/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h
+++ b/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h
@@ -16,7 +16,7 @@
// Autogenerated module goldfish_vk_reserved_marshaling_guest
//
// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// cereal -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -3705,10 +3705,6 @@
void reservedmarshal_VkImportBufferGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkImportBufferGOOGLE* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkImportPhysicalAddressGOOGLE(
- VulkanStreamGuest* vkStream, VkStructureType rootType,
- const VkImportPhysicalAddressGOOGLE* forMarshaling, uint8_t** ptr);
-
#endif
#ifdef VK_EXT_global_priority_query
void reservedmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
diff --git a/system/vulkan_enc/goldfish_vk_transform_guest.cpp b/system/vulkan_enc/goldfish_vk_transform_guest.cpp
index 3a3aa43..a5dab78 100644
--- a/system/vulkan_enc/goldfish_vk_transform_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_transform_guest.cpp
@@ -16,7 +16,7 @@
// Autogenerated module goldfish_vk_transform_guest
//
// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -15254,24 +15254,6 @@
}
}
-void transform_tohost_VkImportPhysicalAddressGOOGLE(ResourceTracker* resourceTracker,
- VkImportPhysicalAddressGOOGLE* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
-void transform_fromhost_VkImportPhysicalAddressGOOGLE(ResourceTracker* resourceTracker,
- VkImportPhysicalAddressGOOGLE* toTransform) {
- (void)resourceTracker;
- (void)toTransform;
- if (toTransform->pNext) {
- transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
- }
-}
-
#endif
#ifdef VK_EXT_global_priority_query
void transform_tohost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
@@ -18412,12 +18394,6 @@
resourceTracker, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
- transform_tohost_VkImportPhysicalAddressGOOGLE(
- resourceTracker,
- reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
- break;
- }
#endif
#ifdef VK_EXT_global_priority_query
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
@@ -20908,12 +20884,6 @@
resourceTracker, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
- transform_fromhost_VkImportPhysicalAddressGOOGLE(
- resourceTracker,
- reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
- break;
- }
#endif
#ifdef VK_EXT_global_priority_query
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
diff --git a/system/vulkan_enc/goldfish_vk_transform_guest.h b/system/vulkan_enc/goldfish_vk_transform_guest.h
index 2b70e3d..acbf057 100644
--- a/system/vulkan_enc/goldfish_vk_transform_guest.h
+++ b/system/vulkan_enc/goldfish_vk_transform_guest.h
@@ -16,7 +16,7 @@
// Autogenerated module goldfish_vk_transform_guest
//
// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// cereal -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -5566,12 +5566,6 @@
void transform_fromhost_VkImportBufferGOOGLE(ResourceTracker* resourceTracker,
VkImportBufferGOOGLE* toTransform);
-void transform_tohost_VkImportPhysicalAddressGOOGLE(ResourceTracker* resourceTracker,
- VkImportPhysicalAddressGOOGLE* toTransform);
-
-void transform_fromhost_VkImportPhysicalAddressGOOGLE(ResourceTracker* resourceTracker,
- VkImportPhysicalAddressGOOGLE* toTransform);
-
#endif
#ifdef VK_EXT_global_priority_query
void transform_tohost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
diff --git a/system/vulkan_enc/vulkan_gfxstream.h b/system/vulkan_enc/vulkan_gfxstream.h
index 1c55e09..a2c922e 100644
--- a/system/vulkan_enc/vulkan_gfxstream.h
+++ b/system/vulkan_enc/vulkan_gfxstream.h
@@ -43,20 +43,6 @@
uint32_t buffer;
} VkImportBufferGOOGLE;
-typedef struct VkImportPhysicalAddressGOOGLE {
- VkStructureType sType;
- void* pNext;
- uint64_t physicalAddress;
- VkDeviceSize size;
- VkFormat format;
- VkImageTiling tiling;
- uint32_t tilingParameter;
-} VkImportPhysicalAddressGOOGLE;
-
-typedef VkResult(VKAPI_PTR* PFN_vkRegisterImageColorBufferGOOGLE)(VkDevice device, VkImage image,
- uint32_t colorBuffer);
-typedef VkResult(VKAPI_PTR* PFN_vkRegisterBufferColorBufferGOOGLE)(VkDevice device, VkBuffer buffer,
- uint32_t colorBuffer);
typedef VkResult(VKAPI_PTR* PFN_vkMapMemoryIntoAddressSpaceGOOGLE)(VkDevice device,
VkDeviceMemory memory,
uint64_t* pAddress);
@@ -126,12 +112,6 @@
VkDeviceSize dataSize);
#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkRegisterImageColorBufferGOOGLE(VkDevice device, VkImage image,
- uint32_t colorBuffer);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkRegisterBufferColorBufferGOOGLE(VkDevice device, VkBuffer buffer,
- uint32_t colorBuffer);
-
VKAPI_ATTR VkResult VKAPI_CALL vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device,
VkDeviceMemory memory,
uint64_t* pAddress);
diff --git a/system/vulkan_enc/vulkan_gfxstream_structure_type.h b/system/vulkan_enc/vulkan_gfxstream_structure_type.h
index b66918b..4df95ec 100644
--- a/system/vulkan_enc/vulkan_gfxstream_structure_type.h
+++ b/system/vulkan_enc/vulkan_gfxstream_structure_type.h
@@ -16,7 +16,7 @@
// Autogenerated module vulkan_gfxstream_structure_type
//
// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// cereal -o ../vulkan-cereal/stream-servers/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
diff --git a/third-party/fuchsia/LICENSE b/third-party/fuchsia/LICENSE
new file mode 100644
index 0000000..7ed244f
--- /dev/null
+++ b/third-party/fuchsia/LICENSE
@@ -0,0 +1,24 @@
+Copyright 2019 The Fuchsia Authors.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/third-party/fuchsia/README b/third-party/fuchsia/README
new file mode 100644
index 0000000..e315413
--- /dev/null
+++ b/third-party/fuchsia/README
@@ -0,0 +1 @@
+These files come from fuchsia.googlesource.com. Once Magma is in the Fuchsia SDK (https://fxbug.dev/116007, https://fxbug.dev/111471), these files should be removed and the Fuchsia SDK added as a proper dependency (https://fxbug.dev/122678).
diff --git a/third-party/fuchsia/magma/include/magma/magma_common_defs.h b/third-party/fuchsia/magma/include/magma/magma_common_defs.h
new file mode 100644
index 0000000..3fde38c
--- /dev/null
+++ b/third-party/fuchsia/magma/include/magma/magma_common_defs.h
@@ -0,0 +1,332 @@
+// Copyright 2016 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SRC_GRAPHICS_LIB_MAGMA_INCLUDE_MAGMA_MAGMA_COMMON_DEFS_H_
+#define SRC_GRAPHICS_LIB_MAGMA_INCLUDE_MAGMA_MAGMA_COMMON_DEFS_H_
+
+#include <stdint.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+// This header is C, so clang-tidy shouldn't recommend using C++ features.
+// NOLINTBEGIN(modernize-use-using)
+
+// LINT.IfChange(version)
+// This version should be incremented whenever the Magma API changes.
+#define MAGMA_API_VERSION 1
+// LINT.ThenChange()
+
+// LINT.IfChange
+#if defined(__Fuchsia__)
+// The entrypoints should be exported from libmagma_client.a. ICDs should use a
+// version script to re-exporting magma entrypoints.
+#define MAGMA_EXPORT __attribute__((visibility("default")))
+#else
+#define MAGMA_EXPORT
+#endif
+
+typedef uint64_t magma_query_t;
+
+// This is a list of vendor-neutral queries that can be passed to magma_query.
+// Returns the hardware vendor ID (simple result) - should be the PCI ID of the GPU vendor
+// if possible, or the Khronos vendor ID otherwise.
+#define MAGMA_QUERY_VENDOR_ID ((magma_query_t)0)
+// Returns the hardware device ID (simple result)
+#define MAGMA_QUERY_DEVICE_ID ((magma_query_t)1)
+// 2 was MAGMA_QUERY_IS_TEST_RESTART_SUPPORTED
+// Returns true if MAGMA_QUERY_TOTAL_TIME is supported (simple result)
+#define MAGMA_QUERY_IS_TOTAL_TIME_SUPPORTED ((magma_query_t)3)
+// 4 was MAGMA_QUERY_MINIMUM_MAPPABLE_ADDRESS
+// Upper 32bits: max inflight messages, lower 32bits: max inflight memory (MB) (simple result)
+#define MAGMA_QUERY_MAXIMUM_INFLIGHT_PARAMS ((magma_query_t)5)
+
+// All vendor-specific queries IDs that can be passed to magma_query must be >=
+// MAGMA_QUERY_VENDOR_PARAM_0.
+#define MAGMA_QUERY_VENDOR_PARAM_0 ((magma_query_t)10000)
+
+// This is a list of vendor-neutral queries that can be passed to magma_query.
+// Returns a struct magma_total_time_query_result (buffer result)
+#define MAGMA_QUERY_TOTAL_TIME ((magma_query_t)500)
+
+// reserved ID to represent an invalid object
+#define MAGMA_INVALID_OBJECT_ID ((uint64_t)0ull)
+
+// All vendor-specific command buffer flags must be >=
+// MAGMA_COMMAND_BUFFER_VENDOR_FLAGS_0.
+#define MAGMA_COMMAND_BUFFER_VENDOR_FLAGS_0 ((uint64_t)(1ull << 16))
+
+typedef int32_t magma_status_t;
+
+// possible values for magma_status_t
+#define MAGMA_STATUS_OK ((magma_status_t)(0))
+#define MAGMA_STATUS_INTERNAL_ERROR ((magma_status_t)(-1))
+#define MAGMA_STATUS_INVALID_ARGS ((magma_status_t)(-2))
+#define MAGMA_STATUS_ACCESS_DENIED ((magma_status_t)(-3))
+#define MAGMA_STATUS_MEMORY_ERROR ((magma_status_t)(-4))
+#define MAGMA_STATUS_CONTEXT_KILLED ((magma_status_t)(-5))
+#define MAGMA_STATUS_CONNECTION_LOST ((magma_status_t)(-6))
+#define MAGMA_STATUS_TIMED_OUT ((magma_status_t)(-7))
+#define MAGMA_STATUS_UNIMPLEMENTED ((magma_status_t)(-8))
+// This error means that an object was not in the right state for an operation on it.
+#define MAGMA_STATUS_BAD_STATE ((magma_status_t)(-9))
+#define MAGMA_STATUS_ALIAS_FOR_LAST MAGMA_STATUS_BAD_STATE
+
+typedef uint32_t magma_cache_operation_t;
+// possible values for magma_cache_operation_t
+#define MAGMA_CACHE_OPERATION_CLEAN ((magma_cache_operation_t)0)
+#define MAGMA_CACHE_OPERATION_CLEAN_INVALIDATE ((magma_cache_operation_t)1)
+
+typedef uint32_t magma_cache_policy_t;
+// possible values for magma_cache_policy_t
+#define MAGMA_CACHE_POLICY_CACHED ((magma_cache_policy_t)0)
+#define MAGMA_CACHE_POLICY_WRITE_COMBINING ((magma_cache_policy_t)1)
+#define MAGMA_CACHE_POLICY_UNCACHED ((magma_cache_policy_t)2)
+
+#define MAGMA_DUMP_TYPE_NORMAL ((uint32_t)(1 << 0))
+
+#define MAGMA_PERF_COUNTER_RESULT_DISCONTINUITY ((uint32_t)(1 << 0))
+
+typedef uint32_t magma_format_t;
+
+// Values must match fuchsia.sysmem.PixelFormatType
+#define MAGMA_FORMAT_INVALID ((magma_format_t)0)
+#define MAGMA_FORMAT_R8G8B8A8 ((magma_format_t)1)
+#define MAGMA_FORMAT_BGRA32 ((magma_format_t)101)
+#define MAGMA_FORMAT_I420 ((magma_format_t)102)
+#define MAGMA_FORMAT_M420 ((magma_format_t)103)
+#define MAGMA_FORMAT_NV12 ((magma_format_t)104)
+#define MAGMA_FORMAT_YUY2 ((magma_format_t)105)
+#define MAGMA_FORMAT_MJPEG ((magma_format_t)106)
+#define MAGMA_FORMAT_YV12 ((magma_format_t)107)
+#define MAGMA_FORMAT_BGR24 ((magma_format_t)108)
+#define MAGMA_FORMAT_RGB565 ((magma_format_t)109)
+#define MAGMA_FORMAT_RGB332 ((magma_format_t)110)
+#define MAGMA_FORMAT_RGB2220 ((magma_format_t)111)
+#define MAGMA_FORMAT_L8 ((magma_format_t)112)
+#define MAGMA_FORMAT_R8 ((magma_format_t)113)
+#define MAGMA_FORMAT_R8G8 ((magma_format_t)114)
+
+typedef uint64_t magma_format_modifier_t;
+// These must match the fuchsia.sysmem format modifier values.
+#define MAGMA_FORMAT_MODIFIER_LINEAR ((magma_format_modifier_t)0x0000000000000000)
+
+#define MAGMA_FORMAT_MODIFIER_INTEL_X_TILED ((magma_format_modifier_t)0x0100000000000001)
+#define MAGMA_FORMAT_MODIFIER_INTEL_Y_TILED ((magma_format_modifier_t)0x0100000000000002)
+#define MAGMA_FORMAT_MODIFIER_INTEL_YF_TILED ((magma_format_modifier_t)0x0100000000000003)
+
+#define MAGMA_FORMAT_MODIFIER_INTEL_Y_TILED_CCS ((magma_format_modifier_t)0x0100000001000002)
+#define MAGMA_FORMAT_MODIFIER_INTEL_YF_TILED_CCS ((magma_format_modifier_t)0x0100000001000003)
+
+#define MAGMA_FORMAT_MODIFIER_ARM_YUV_BIT ((magma_format_modifier_t)0x10)
+#define MAGMA_FORMAT_MODIFIER_ARM_SPLIT_BLOCK_BIT ((magma_format_modifier_t)0x20)
+#define MAGMA_FORMAT_MODIFIER_ARM_SPARSE_BIT ((magma_format_modifier_t)0x40)
+#define MAGMA_FORMAT_MODIFIER_ARM_BCH_BIT ((magma_format_modifier_t)0x800)
+#define MAGMA_FORMAT_MODIFIER_ARM_TE_BIT ((magma_format_modifier_t)0x1000)
+#define MAGMA_FORMAT_MODIFIER_ARM_TILED_HEADER_BIT ((magma_format_modifier_t)0x2000)
+
+#define MAGMA_FORMAT_MODIFIER_ARM ((magma_format_modifier_t)0x0800000000000000)
+#define MAGMA_FORMAT_MODIFIER_ARM_AFBC_16X16 ((magma_format_modifier_t)0x0800000000000001)
+#define MAGMA_FORMAT_MODIFIER_ARM_AFBC_32X8 ((magma_format_modifier_t)0x0800000000000002)
+#define MAGMA_FORMAT_MODIFIER_ARM_LINEAR_TE ((magma_format_modifier_t)0x0800000000001000)
+#define MAGMA_FORMAT_MODIFIER_ARM_AFBC_16X16_TE ((magma_format_modifier_t)0x0800000000001001)
+#define MAGMA_FORMAT_MODIFIER_ARM_AFBC_32X8_TE ((magma_format_modifier_t)0x0800000000001002)
+
+#define MAGMA_FORMAT_MODIFIER_ARM_AFBC_16X16_YUV_TILED_HEADER \
+ ((magma_format_modifier_t)0x0800000000002011)
+
+#define MAGMA_FORMAT_MODIFIER_ARM_AFBC_16X16_SPLIT_BLOCK_SPARSE_YUV \
+ ((magma_format_modifier_t)0x0800000000000071)
+#define MAGMA_FORMAT_MODIFIER_ARM_AFBC_16X16_SPLIT_BLOCK_SPARSE_YUV_TE \
+ ((magma_format_modifier_t)0x0800000000001071)
+
+#define MAGMA_FORMAT_MODIFIER_ARM_AFBC_16X16_SPLIT_BLOCK_SPARSE_YUV_TILED_HEADER \
+ ((magma_format_modifier_t)0x0800000000002071)
+#define MAGMA_FORMAT_MODIFIER_ARM_AFBC_16X16_SPLIT_BLOCK_SPARSE_YUV_TE_TILED_HEADER \
+ ((magma_format_modifier_t)0x0800000000003071)
+
+typedef uint32_t magma_colorspace_t;
+
+// Must match fuchsia.sysmem.ColorSpaceType values.
+#define MAGMA_COLORSPACE_INVALID ((magma_colorspace_t)0)
+#define MAGMA_COLORSPACE_SRGB ((magma_colorspace_t)1)
+#define MAGMA_COLORSPACE_REC601_NTSC ((magma_colorspace_t)2)
+#define MAGMA_COLORSPACE_REC601_NTSC_FULL_RANGE ((magma_colorspace_t)3)
+#define MAGMA_COLORSPACE_REC601_PAL ((magma_colorspace_t)4)
+#define MAGMA_COLORSPACE_REC601_PAL_FULL_RANGE ((magma_colorspace_t)5)
+#define MAGMA_COLORSPACE_REC709 ((magma_colorspace_t)6)
+#define MAGMA_COLORSPACE_REC2020 ((magma_colorspace_t)7)
+#define MAGMA_COLORSPACE_REC2100 ((magma_colorspace_t)8)
+
+typedef uint32_t magma_coherency_domain_t;
+
+#define MAGMA_COHERENCY_DOMAIN_CPU ((magma_coherency_domain_t)0)
+#define MAGMA_COHERENCY_DOMAIN_RAM ((magma_coherency_domain_t)1)
+#define MAGMA_COHERENCY_DOMAIN_INACCESSIBLE ((magma_coherency_domain_t)2)
+
+#define MAGMA_POLL_TYPE_SEMAPHORE ((uint32_t)1)
+#define MAGMA_POLL_TYPE_HANDLE ((uint32_t)2)
+
+#define MAGMA_POLL_CONDITION_READABLE ((uint32_t)1)
+#define MAGMA_POLL_CONDITION_SIGNALED ((uint32_t)3)
+
+typedef uint32_t magma_buffer_range_op_t;
+
+// Eagerly populate hardware page tables with the pages mapping in this range, committing pages as
+// needed. This is not needed for MAGMA_MAP_FLAG_GROWABLE allocations, since the page tables
+// will be populated on demand.
+#define MAGMA_BUFFER_RANGE_OP_POPULATE_TABLES ((magma_buffer_range_op_t)1)
+// Commit memory on the client thread. Hardware page tables may not be populated. This should be
+// used
+// before POPULATE_TABLES to ensure the expensive work of committing pages happens with the
+// correct priority and without blocking the processing in the MSD of commands from other threads
+// from the same connection.
+#define MAGMA_BUFFER_RANGE_OP_COMMIT ((magma_buffer_range_op_t)2)
+// Depopulate hardware page table mappings for this range. This prevents the hardware from
+// accessing
+// pages in that range, but the pages retain their contents.
+#define MAGMA_BUFFER_RANGE_OP_DEPOPULATE_TABLES ((magma_buffer_range_op_t)3)
+// Decommit memory wholy on the client thread. This may fail if the MSD currently has the page
+// tables populated.
+#define MAGMA_BUFFER_RANGE_OP_DECOMMIT ((magma_buffer_range_op_t)4)
+
+// Set `is_secure` flag in the `BufferMemorySettings` so protected memory is allocated.
+#define MAGMA_SYSMEM_FLAG_PROTECTED ((uint32_t)(1 << 0))
+// This flag is only used to modify the name of the buffer to signal that the client requested it
+// using vkAllocateMemory or similar.
+#define MAGMA_SYSMEM_FLAG_FOR_CLIENT ((uint32_t)(1 << 2))
+
+#define MAGMA_MAX_IMAGE_PLANES ((uint32_t)4)
+
+#define MAGMA_MAX_DRM_FORMAT_MODIFIERS ((uint32_t)16)
+
+// Normal bool doesn't have to be a particular size.
+typedef uint8_t magma_bool_t;
+
+typedef uint64_t magma_device_t;
+
+typedef uint64_t magma_buffer_t;
+
+typedef uint64_t magma_semaphore_t;
+
+typedef uint64_t magma_perf_count_pool_t;
+
+typedef uint64_t magma_connection_t;
+
+// An opaque handle that corresponds to a fuchsia.sysmem.Allocator connection to sysmem.
+typedef uint64_t magma_sysmem_connection_t;
+
+// Corresponds to a zx_handle_t on Fuchsia.
+typedef uint32_t magma_handle_t;
+
+typedef struct magma_poll_item {
+ union {
+ magma_semaphore_t semaphore;
+ magma_handle_t handle;
+ };
+ uint32_t type;
+ uint32_t condition;
+ uint32_t result;
+ uint32_t unused;
+} magma_poll_item_t;
+
+// A buffer referenced by a command buffer descriptor
+typedef struct magma_exec_resource {
+ uint64_t buffer_id;
+ uint64_t offset;
+ uint64_t length;
+} magma_exec_resource_t;
+
+// A resource to be executed by a command buffer descriptor
+typedef struct magma_exec_command_buffer {
+ uint32_t resource_index;
+ uint32_t unused;
+ uint64_t start_offset;
+} __attribute__((__aligned__(8))) magma_exec_command_buffer_t;
+
+typedef struct magma_command_descriptor {
+ // The count of `resources` that may be referenced by the hardware. These must have been
+ // mapped to the hardware previously.
+ uint32_t resource_count;
+ // The count of `command_buffers` to be executed as a unit.
+ uint32_t command_buffer_count;
+ // The count of `semaphore_ids` to be waited upon before beginning execution; these
+ // will be reset after all have been signaled.
+ uint32_t wait_semaphore_count;
+ // The count of `semaphore_ids` to be signaled after execution is complete.
+ uint32_t signal_semaphore_count;
+
+ struct magma_exec_resource* resources;
+ struct magma_exec_command_buffer* command_buffers;
+ // List of semaphore IDs: first the wait semaphore IDs, followed by signal semaphore IDs.
+ uint64_t* semaphore_ids;
+
+ uint64_t flags;
+
+} __attribute__((__aligned__(8))) magma_command_descriptor_t;
+
+typedef struct magma_inline_command_buffer {
+ void* data;
+ uint64_t size;
+ uint64_t* semaphore_ids;
+ uint32_t semaphore_count;
+} magma_inline_command_buffer_t;
+
+typedef struct magma_total_time_query_result {
+ uint64_t gpu_time_ns; // GPU time in ns since driver start.
+ uint64_t monotonic_time_ns; // monotonic clock time measured at same time CPU time was.
+} magma_total_time_query_result_t;
+
+typedef struct magma_buffer_offset {
+ uint64_t buffer_id;
+ uint64_t offset;
+ uint64_t length;
+} magma_buffer_offset_t;
+
+// The top 16 bits are reserved for vendor-specific flags.
+#define MAGMA_MAP_FLAG_VENDOR_SHIFT ((uint64_t)16)
+
+#define MAGMA_MAP_FLAG_READ ((uint64_t)(1 << 0))
+#define MAGMA_MAP_FLAG_WRITE ((uint64_t)(1 << 1))
+#define MAGMA_MAP_FLAG_EXECUTE ((uint64_t)(1 << 2))
+#define MAGMA_MAP_FLAG_GROWABLE ((uint64_t)(1 << 3))
+#define MAGMA_MAP_FLAG_VENDOR_0 ((uint64_t)(1 << MAGMA_MAP_FLAG_VENDOR_SHIFT))
+
+typedef struct magma_buffer_info {
+ uint64_t committed_byte_count;
+ uint64_t size;
+} magma_buffer_info_t;
+
+#define MAGMA_IMAGE_CREATE_FLAGS_PRESENTABLE ((uint32_t)1)
+#define MAGMA_IMAGE_CREATE_FLAGS_VULKAN_USAGE ((uint32_t)(1 << 1))
+
+typedef struct magma_image_create_info {
+ // A format specified by DRM (Linux Direct Rendering Manager)
+ uint64_t drm_format;
+ // The last modifier must be DRM_FORMAT_MOD_INVALID
+ uint64_t drm_format_modifiers[MAGMA_MAX_DRM_FORMAT_MODIFIERS];
+ uint32_t width;
+ uint32_t height;
+ // If MAGMA_IMAGE_CREATE_FLAGS_VULKAN_USAGE is provided, Vulkan usage flags
+ // should be provided in the upper 32 bits.
+ uint64_t flags;
+} magma_image_create_info_t;
+
+typedef struct magma_image_info {
+ uint64_t plane_strides[MAGMA_MAX_IMAGE_PLANES];
+ uint32_t plane_offsets[MAGMA_MAX_IMAGE_PLANES];
+ uint64_t drm_format_modifier;
+ uint32_t coherency_domain;
+ uint32_t unused;
+} magma_image_info_t;
+
+// LINT.ThenChange(version)
+// NOLINTEND(modernize-use-using)
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif // SRC_GRAPHICS_LIB_MAGMA_INCLUDE_MAGMA_MAGMA_COMMON_DEFS_H_
diff --git a/third-party/fuchsia/meson.build b/third-party/fuchsia/meson.build
new file mode 100644
index 0000000..2305a4f
--- /dev/null
+++ b/third-party/fuchsia/meson.build
@@ -0,0 +1,8 @@
+# Copyright 2023 Android Open Source Project
+# SPDX-License-Identifier: MIT
+
+inc_fuchsia_magma = include_directories('magma/include')
+
+fuchsia_magma_dep = declare_dependency(
+ include_directories: [inc_fuchsia_magma],
+)
diff --git a/third-party/meson.build b/third-party/meson.build
new file mode 100644
index 0000000..8c359ec
--- /dev/null
+++ b/third-party/meson.build
@@ -0,0 +1,8 @@
+# Copyright 2023 Android Open Source Project
+# SPDX-License-Identifier: MIT
+
+#================#
+# Subdirectories #
+#================#
+
+subdir('fuchsia')
