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)&params[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, &parameter_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, &parameter_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, &parameter_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, &parameter_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, &parameter_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, &parameter_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')