diff options
69 files changed, 5783 insertions, 2786 deletions
diff --git a/android/emulation/DmaMap.cpp b/android/emulation/DmaMap.cpp deleted file mode 100644 index fb04803a0..000000000 --- a/android/emulation/DmaMap.cpp +++ /dev/null @@ -1,152 +0,0 @@ -// Copyright 2016 The Android Open Source Project -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#include "android/emulation/DmaMap.h" - -#include "android/base/containers/Lookup.h" -#include "android/base/memory/LazyInstance.h" - -#include <type_traits> -#include <inttypes.h> -#include <stdio.h> - -#define DEBUG 0 - -#if DEBUG >= 1 -#define D(fmt,...) fprintf(stderr, "DmaMap: %s: " fmt "\n", __func__, ##__VA_ARGS__); -#else -#define D(...) (void)0 -#endif - -#if DEBUG >= 2 -#define DD(fmt,...) fprintf(stderr, "DmaMap: %s: " fmt "\n", __func__, ##__VA_ARGS__); -#else -#define DD(...) (void)0 -#endif - -#define E(fmt,...) fprintf(stderr, "DmaMap: ERROR: %s: " fmt "\n", __func__, ##__VA_ARGS__); - -namespace android { - -static DmaMap* sInstance = nullptr; - -DmaMap* DmaMap::get() { - return sInstance; -} - -DmaMap* DmaMap::set(DmaMap* dmaMap) { - DmaMap* result = sInstance; - sInstance = dmaMap; - return result; -} - -void DmaMap::addBuffer(void* hwpipe, - uint64_t guest_paddr, - uint64_t bufferSize) { - D("guest paddr 0x%llx bufferSize %llu", - (unsigned long long)guest_paddr, - (unsigned long long)bufferSize); - DmaBufferInfo info; - info.hwpipe = hwpipe; - info.guestAddr = guest_paddr; // guest address - info.bufferSize = bufferSize; // size of buffer - info.currHostAddr = kNullopt; // no current host address - android::base::AutoWriteLock lock(mLock); - createMappingLocked(&info); - mDmaBuffers[guest_paddr] = info; -} - -void DmaMap::removeBuffer(uint64_t guest_paddr) { - D("guest paddr 0x%llx", (unsigned long long)guest_paddr); - android::base::AutoWriteLock lock(mLock); - if (auto info = android::base::find(mDmaBuffers, guest_paddr)) { - removeMappingLocked(info); - mDmaBuffers.erase(guest_paddr); - } else { - E("guest addr 0x%llx not alloced!", - (unsigned long long)guest_paddr); - } -} - -void* DmaMap::getHostAddr(uint64_t guest_paddr) { - DD("guest paddr 0x%llx", (unsigned long long)guest_paddr); - android::base::AutoReadLock rlock(mLock); - if (auto info = android::base::find(mDmaBuffers, guest_paddr)) { - if (info->currHostAddr) { - DD("guest paddr 0x%llx -> host 0x%llx valid", - (unsigned long long)guest_paddr, - (unsigned long long)(*info->currHostAddr)); - return *(info->currHostAddr); - } else { - rlock.unlockRead(); - android::base::AutoWriteLock wlock(mLock); - createMappingLocked(info); - D("guest paddr 0x%llx -> host 0x%llx valid (new)", - (unsigned long long)guest_paddr, - (unsigned long long)*(info->currHostAddr)); - return *(info->currHostAddr); - } - } else { - E("guest paddr 0x%llx not alloced!", - (unsigned long long)guest_paddr); - return 0; - } -} - -void DmaMap::invalidateHostMappings() { - android::base::AutoWriteLock lock(mLock); - for (auto& it : mDmaBuffers) { - removeMappingLocked(&it.second); - } -} - -void DmaMap::resetHostMappings() { - android::base::AutoWriteLock lock(mLock); - for (auto& it : mDmaBuffers) { - removeMappingLocked(&it.second); - } - mDmaBuffers.clear(); -} - -void* DmaMap::getPipeInstance(uint64_t guest_paddr) { - android::base::AutoReadLock lock(mLock); - if (auto info = android::base::find(mDmaBuffers, guest_paddr)) { - return info->hwpipe; - } else { - E("guest paddr 0x%llx not alloced!", - (unsigned long long)guest_paddr); - return nullptr; - } -} - -void DmaMap::createMappingLocked(DmaBufferInfo* info) { - info->currHostAddr = doMap(info->guestAddr, info->bufferSize); -} - -void DmaMap::removeMappingLocked(DmaBufferInfo* info ) { - if (info->currHostAddr) { - doUnmap(*(info->currHostAddr), info->bufferSize); - info->currHostAddr = kNullopt; - D("guest addr 0x%llx host mapping 0x%llx removed.", - (unsigned long long)info->guestAddr, - (unsigned long long)info->currHostAddr); - } else { - D("guest addr 0x%llx has no host mapping. don't remove.", - (unsigned long long)info->guestAddr); - } -} - -} // namespace android - - diff --git a/android/emulation/DmaMap.h b/android/emulation/DmaMap.h deleted file mode 100644 index 754549fac..000000000 --- a/android/emulation/DmaMap.h +++ /dev/null @@ -1,72 +0,0 @@ -// Copyright 2016 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 "android/base/Compiler.h" -#include "android/base/Optional.h" -#include "android/base/synchronization/Lock.h" - -#include <unordered_map> -#include <inttypes.h> - -using android::base::Optional; -using android::base::kNullopt; - -namespace android { - -struct DmaBufferInfo { - void* hwpipe = nullptr; - uint64_t guestAddr = 0; - uint64_t bufferSize = 0; - Optional<void*> currHostAddr = kNullopt; -}; - -class DmaMap { -public: - // Constructor. - DmaMap() = default; - - // Destructor. - virtual ~DmaMap() = default; - - void addBuffer(void* hwpipe, uint64_t addr, uint64_t bufferSize); - void removeBuffer(uint64_t addr); - void* getHostAddr(uint64_t addr); - void invalidateHostMappings(); - void resetHostMappings(); - void* getPipeInstance(uint64_t addr); - - // get() / set are NOT thread-safe, - // but we don't expect multiple threads to call this - // concurrently at init time, and the worst that can happen is to leak - // a single instance. (c.f. VmLock) - static DmaMap* get(); - static DmaMap* set(DmaMap* dmaMap); -protected: - - virtual void createMappingLocked(DmaBufferInfo* info); - virtual void removeMappingLocked(DmaBufferInfo* info); - - // These are meant to be replaced by a real implementation - // in subclasses. - virtual void* doMap(uint64_t addr, uint64_t bufferSize) = 0; - virtual void doUnmap(void* mapped, uint64_t bufferSize) = 0; - - std::unordered_map<uint64_t, DmaBufferInfo> mDmaBuffers; - android::base::ReadWriteLock mLock; - DISALLOW_COPY_ASSIGN_AND_MOVE(DmaMap); -}; - -} // namespace android diff --git a/android/emulation/DmaMap_unittest.cpp b/android/emulation/DmaMap_unittest.cpp deleted file mode 100644 index d5e23b8d9..000000000 --- a/android/emulation/DmaMap_unittest.cpp +++ /dev/null @@ -1,173 +0,0 @@ -// Copyright 2016 The Android Open Source Project -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#include "android/emulation/DmaMap.h" -#include "android/emulation/testing/TestDmaMap.h" - -#include <gtest/gtest.h> - -using android::base::Optional; -using android::base::kNullopt; - -namespace android { - - -TEST(DmaMap, Default) { - // No default impl of DmaMap should exist on startup. - DmaMap* dmaMap = DmaMap::get(); - ASSERT_FALSE(dmaMap); -} - -TEST(DmaMap, CustomDmaMap) { - TestDmaMap myMap; - const DmaMapState& currState = myMap.dumpState(); - EXPECT_EQ(currState.size(), 0); -} - -TEST(DmaMap, SingleMapAdd) { - TestDmaMap myMap; - myMap.addBuffer(nullptr, 1, 2); - const DmaMapState& currState = myMap.dumpState(); - const auto& it = currState.find(1); - EXPECT_TRUE(it != currState.end()); - const DmaBufferInfo& info = it->second; - EXPECT_EQ(info.guestAddr, 1); - EXPECT_EQ(info.bufferSize, 2); - EXPECT_TRUE(info.currHostAddr); -} - -TEST(DmaMap, SingleMapAddRemove) { - TestDmaMap myMap; - const DmaMapState& currState = myMap.dumpState(); - myMap.addBuffer(nullptr, 1, 2); - const auto& it = currState.find(1); - EXPECT_TRUE(it != currState.end()); - myMap.removeBuffer(1); - const auto& it2 = currState.find(1); - EXPECT_TRUE(it2 == currState.end()); -} - -TEST(DmaMap, SingleMapAddMulti) { - TestDmaMap myMap; - myMap.addBuffer(nullptr, 1, 2); - myMap.addBuffer(nullptr, 1, 3); - const DmaMapState& currState = myMap.dumpState(); - const DmaBufferInfo& info = currState.find(1)->second; - EXPECT_EQ(info.guestAddr, 1); - EXPECT_EQ(info.bufferSize, 3); -} - -TEST(DmaMap, MultiMap) { - TestDmaMap myMap; - myMap.addBuffer(nullptr, 1, 2); - myMap.addBuffer(nullptr, 3, 4); - const DmaMapState& currState = myMap.dumpState(); - const auto& it1 = currState.find(1); - const auto& it3 = currState.find(3); - EXPECT_TRUE(it1 != currState.end()); - EXPECT_TRUE(it3 != currState.end()); - const DmaBufferInfo& info1 = it1->second; - const DmaBufferInfo& info3 = it3->second; - EXPECT_EQ(info1.guestAddr, 1); - EXPECT_EQ(info1.bufferSize, 2); - EXPECT_TRUE(info1.currHostAddr); - EXPECT_EQ(info3.guestAddr, 3); - EXPECT_EQ(info3.bufferSize, 4); - EXPECT_TRUE(info3.currHostAddr); - myMap.removeBuffer(1); - myMap.removeBuffer(3); - const auto& it1_notfound = currState.find(1); - const auto& it3_notfound = currState.find(3); - EXPECT_TRUE(it1_notfound == currState.end()); - EXPECT_TRUE(it3_notfound == currState.end()); -} - -TEST(DmaMap, SingleMapHostRead) { - TestDmaMap myMap; - myMap.addBuffer(nullptr, 1, 2); - myMap.getHostAddr(1); - - const DmaMapState& currState = myMap.dumpState(); - const auto& it = currState.find(1); - const DmaBufferInfo& info = it->second; - EXPECT_EQ(info.guestAddr, 1); - EXPECT_EQ(info.bufferSize, 2); - EXPECT_TRUE(info.currHostAddr); - - myMap.getHostAddr(1); - EXPECT_TRUE(currState.find(1)->second.currHostAddr); - myMap.getHostAddr(1); - EXPECT_TRUE(currState.find(1)->second.currHostAddr); -} - -TEST(DmaMap, SingleMapHostReadInvalidate) { - TestDmaMap myMap; - myMap.addBuffer(nullptr, 1, 2); - myMap.getHostAddr(1); - myMap.invalidateHostMappings(); - const DmaMapState& currState = myMap.dumpState(); - const auto& it = currState.find(1); - const DmaBufferInfo& info = it->second; - EXPECT_EQ(info.guestAddr, 1); - EXPECT_EQ(info.bufferSize, 2); - EXPECT_FALSE(info.currHostAddr); -} - -TEST(DmaMap, MultiMapHostReadInvalidate) { - TestDmaMap myMap; - const DmaMapState& currState = myMap.dumpState(); - myMap.addBuffer(nullptr, 1, 2); - myMap.addBuffer(nullptr, 3, 4); - myMap.addBuffer(nullptr, 5, 6); - myMap.getHostAddr(1); - myMap.getHostAddr(3); - EXPECT_TRUE(currState.find(1)->second.currHostAddr); - EXPECT_TRUE(currState.find(3)->second.currHostAddr); - EXPECT_TRUE(currState.find(5)->second.currHostAddr); - myMap.invalidateHostMappings(); - EXPECT_FALSE(currState.find(1)->second.currHostAddr); - EXPECT_FALSE(currState.find(3)->second.currHostAddr); - EXPECT_FALSE(currState.find(5)->second.currHostAddr); -} - -TEST(DmaMap, MultiMapHostReadInvalidateRemap) { - TestDmaMap myMap; - const DmaMapState& currState = myMap.dumpState(); - myMap.addBuffer(nullptr, 1, 2); - myMap.addBuffer(nullptr, 3, 4); - myMap.addBuffer(nullptr, 5, 6); - myMap.getHostAddr(1); - myMap.getHostAddr(3); - EXPECT_TRUE(currState.find(1)->second.currHostAddr); - EXPECT_TRUE(currState.find(3)->second.currHostAddr); - EXPECT_TRUE(currState.find(5)->second.currHostAddr); - myMap.invalidateHostMappings(); - myMap.getHostAddr(3); - myMap.getHostAddr(5); - EXPECT_FALSE(currState.find(1)->second.currHostAddr); - EXPECT_TRUE(currState.find(3)->second.currHostAddr); - EXPECT_TRUE(currState.find(5)->second.currHostAddr); -} - -TEST(DmaMap, ErrorCaseMapNonExistent) { - TestDmaMap myMap; - myMap.getHostAddr(1); -} - -TEST(DmaMap, ErrorCaseRemoveNonExistent) { - TestDmaMap myMap; - myMap.removeBuffer(1); -} - -} // namespace android diff --git a/android/emulation/GoldfishDma.cpp b/android/emulation/GoldfishDma.cpp deleted file mode 100644 index 1e5bf9f0a..000000000 --- a/android/emulation/GoldfishDma.cpp +++ /dev/null @@ -1,43 +0,0 @@ -#include "android/base/memory/LazyInstance.h" - -#include "android/emulation/GoldfishDma.h" -#include "android/emulation/DmaMap.h" - -#include "android/emulation/android_pipe_host.h" -#include "android/utils/assert.h" -#include "android/utils/debug.h" -#include "android/utils/system.h" - -static void android_goldfish_dma_add_buffer(void* pipe, uint64_t guest_paddr, uint64_t sz) { - android::DmaMap::get()->addBuffer(pipe, guest_paddr, sz); -} - -static void android_goldfish_dma_remove_buffer(uint64_t guest_paddr) { - android::DmaMap::get()->removeBuffer(guest_paddr); -} - -static void* android_goldfish_dma_get_host_addr(uint64_t guest_paddr) { - return android::DmaMap::get()->getHostAddr(guest_paddr); -} - -static void android_goldfish_dma_invalidate_host_mappings() { - android::DmaMap::get()->invalidateHostMappings(); -} - -static void android_goldfish_dma_unlock(uint64_t guest_paddr) { - void* hwpipe = android::DmaMap::get()->getPipeInstance(guest_paddr); - android_pipe_host_signal_wake(hwpipe, PIPE_WAKE_UNLOCK_DMA); -} - -static void android_goldfish_dma_reset_host_mappings() { - android::DmaMap::get()->resetHostMappings(); -} - -GoldfishDmaOps android_goldfish_dma_ops = { - .add_buffer = android_goldfish_dma_add_buffer, - .remove_buffer = android_goldfish_dma_remove_buffer, - .get_host_addr = android_goldfish_dma_get_host_addr, - .invalidate_host_mappings = android_goldfish_dma_invalidate_host_mappings, - .unlock = android_goldfish_dma_unlock, - .reset_host_mappings = android_goldfish_dma_reset_host_mappings, -}; diff --git a/android/emulation/GoldfishDma.h b/android/emulation/GoldfishDma.h deleted file mode 100644 index d28e5b7bf..000000000 --- a/android/emulation/GoldfishDma.h +++ /dev/null @@ -1,59 +0,0 @@ -/* Copyright (C) 2016 The Android Open Source Project -** -** This software is licensed under the terms of the GNU General Public -** License version 2, as published by the Free Software Foundation, and -** may be copied, distributed, and modified under those terms. -** -** This program is distributed in the hope that it will be useful, -** but WITHOUT ANY WARRANTY; without even the implied warranty of -** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -** GNU General Public License for more details. -*/ - -#pragma once - -#include <inttypes.h> - -static const uint32_t kDmaBufSizeMB = 32; -// GOLDFISH DMA -// -// Goldfish DMA is an extension to the pipe device -// and is designed to facilitate high-speed RAM->RAM -// transfers from guest to host. -// -// See docs/GOLDFISH-VIRTUAL-HARDWARE.txt and -// docs/ANDROID-QEMU-PIPE.txt -// -// for more details. -// Host / virtual device interface: -typedef struct { -// add_buffer(): -// Tell us that there is a physically-contiguous buffer in the guest -// starting at |guest_paddr|. This should be used upon allocation -// of the DMA buffer in the ugest. -void (*add_buffer)(void* pipe, uint64_t guest_paddr, uint64_t sz); -// remove_buffer(): -// Tell us that we don't care about tracking this buffer anymore. -// This should usually be used when the DMA buffer has been freed -// in the ugest. -void (*remove_buffer)(uint64_t guest_paddr); -// get_host_addr(): -// Obtain a pointer to guest physical memory that is usable as -// as host void*. -void* (*get_host_addr)(uint64_t guest_paddr); -// invalidate_host_mappings(): -// Sometimes (say, on snapshot save/load) we may need to re-map -// the guest DMA buffers so to regain access to them. -// This function tells our map of DMA buffers to remap the buffers -// next time they are used. -void (*invalidate_host_mappings)(void); -// unlock(): -// Unlocks the buffer at |guest_paddr| to signal the guest -// that we are done writing it. -void (*unlock)(uint64_t guest_paddr); -// reset_host_mappings(); -// Not only invalidates the mappings, but also removes them from the record. -void (*reset_host_mappings)(void); -} GoldfishDmaOps; - -extern GoldfishDmaOps android_goldfish_dma_ops; diff --git a/android/emulation/testing/TestDmaMap.h b/android/emulation/testing/TestDmaMap.h deleted file mode 100644 index c71fe9dea..000000000 --- a/android/emulation/testing/TestDmaMap.h +++ /dev/null @@ -1,49 +0,0 @@ -// Copyright 2016 The Android Open Source Project -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#include "android/emulation/DmaMap.h" - -#include <unordered_map> -#include <vector> - -namespace android { - -typedef std::unordered_map<uint64_t, DmaBufferInfo> DmaMapState; - -class TestDmaMap : public DmaMap { -public: - TestDmaMap() : mOldDmaMap(DmaMap::set(this)), mInstalled(true) {} - - ~TestDmaMap() { release(); } - - void release() { - if (mInstalled) { - // NOTE: A value of nullptr for mOldDmaMap is valid. - DmaMap::set(mOldDmaMap); - mInstalled = false; - } - } - - const DmaMapState& dumpState() { - return mDmaBuffers; - } - - virtual void* doMap(uint64_t addr, uint64_t buffer) { return nullptr; } - virtual void doUnmap(void* mapped, uint64_t buffer) { } - - DmaMap* mOldDmaMap = nullptr; - bool mInstalled = false; -}; - -} // namespace android diff --git a/host/commands/gen-entries.py b/host/commands/gen-entries.py index a122ef7e3..fbfdb4daf 100755 --- a/host/commands/gen-entries.py +++ b/host/commands/gen-entries.py @@ -61,7 +61,7 @@ def banner_command(argv): # Remove path from first parameter argv = argv[:] - argv[0] = "android/scripts/gen-entries.py" + argv[0] = "host/commands/gen-entries.py" return ' '.join(argv) def parse_entries_file(lines): @@ -151,165 +151,6 @@ def gen_functions_header(entries, prefix_name, verbatim, filename, with_args): print "" print "#endif // %s_FUNCTIONS_H" % prefix_name - - -# The purpose of gen_translator() -# is to quickly generate implementations on the host Translator, -# which processes commands that just got onto the renderthread off goldfish pipe -# and are fed to system OpenGL. - -def gen_translator(entries): - # Definitions for custom implementation bodies go in - # android/scripts/gles3translatorgen/gles30_custom.py - # android/scripts/gles3translatorgen/gles31_custom.py - from gles3translatorgen import gles30_custom - from gles3translatorgen import gles31_custom - - translator_custom_share_processing = { } - for (k, v) in gles30_custom.custom_share_processing.items(): - translator_custom_share_processing[k] = v - for (k, v) in gles31_custom.custom_share_processing.items(): - translator_custom_share_processing[k] = v - - translator_custom_pre = { } - for (k, v) in gles30_custom.custom_preprocesses.items(): - translator_custom_pre[k] = v - for (k, v) in gles31_custom.custom_preprocesses.items(): - translator_custom_pre[k] = v - - translator_custom_post = { } - for (k, v) in gles30_custom.custom_postprocesses.items(): - translator_custom_post[k] = v - for (k, v) in gles31_custom.custom_postprocesses.items(): - translator_custom_post[k] = v - - translator_no_passthrough = {} - for (k, v) in gles30_custom.no_passthrough.items(): - translator_no_passthrough[k] = v - for (k, v) in gles31_custom.no_passthrough.items(): - translator_no_passthrough[k] = v - - translator_needexternc = { - "glGetStringi": 1, - "glUniform4ui": 1, - "glGetUniformIndices": 1, - "glTransformFeedbackVaryings": 1, - "glCreateShaderProgramv": 1, - "glProgramUniform2ui": 1, - "glProgramUniform3ui": 1, - "glProgramUniform4ui": 1, - "glBindVertexBuffer": 1, - }; - translator_nocontext_fail_codes = { - "glClientWaitSync" : "GL_WAIT_FAILED", - }; - def needExternC(entry): - if translator_needexternc.has_key(entry.func_name): - return "extern \"C\" " - else: - return "" - def get_fail_code(entry): - if translator_nocontext_fail_codes.has_key(entry.func_name): - return translator_nocontext_fail_codes[entry.func_name]; - else: - return "0" - def gen_cxt_getter(entry): - if (entry.return_type == "void"): - print " GET_CTX_V2();" - else: - print " GET_CTX_V2_RET(%s);" % get_fail_code(entry) - - def gen_validations_custom_impl(entry): - isGen = entry.func_name.startswith("glGen") - isDelete = entry.func_name.startswith("glDelete") - isBufferOp = "Buffer" in entry.func_name - - hasTargetArg = "target" in entry.varnames - hasProgramArg = "program" in entry.varnames - - def mySetError(condition, glerr): - if entry.return_type == "void": - return "SET_ERROR_IF(%s,%s)" % (condition, glerr); - else: - return "RET_AND_SET_ERROR_IF(%s,%s,%s)" % (condition, glerr, get_fail_code(entry)); - - if (isGen or isDelete) and ("n" in entry.varnames): - print " %s;" % mySetError("n < 0", "GL_INVALID_VALUE"); - if (isBufferOp and hasTargetArg): - print " %s;" % mySetError("!GLESv2Validate::bufferTarget(ctx, target)", "GL_INVALID_ENUM"); - if translator_custom_pre.has_key(entry.func_name): - print translator_custom_pre[entry.func_name], - - def gen_call_ret(entry): - globalNameTypes = { - ("GLuint", "program") : "NamedObjectType::SHADER_OR_PROGRAM", - ("GLuint", "texture") : "NamedObjectType::TEXTURE", - ("GLuint", "buffer") : "NamedObjectType::VERTEXBUFFER", - ("GLuint", "sampler") : "NamedObjectType::SAMPLER", - ("GLuint", "query") : "NamedObjectType::QUERY", - } - globalNames = { - ("GLuint", "program") : "globalProgramName", - ("GLuint", "texture") : "globalTextureName", - ("GLuint", "buffer") : "globalBufferName", - ("GLuint", "sampler") : "globalSampler", - ("GLuint", "query") : "globalQuery", - } - - needsShareGroup = False - for v in zip(entry.vartypes, entry.varnames): - if v in globalNameTypes.keys(): - needsShareGroup = True - - if needsShareGroup: - print " if (ctx->shareGroup().get()) {" - for key in zip(entry.vartypes, entry.varnames): - vartype, varname = key - if globalNames.has_key(key): - print " const GLuint %s = ctx->shareGroup()->getGlobalName(%s, %s);" % (globalNames[key], globalNameTypes[key], varname) - - globalCall = ", ".join(map(lambda k: globalNames.get(k, k[1]), zip(entry.vartypes, entry.varnames))) - - if needsShareGroup and translator_custom_share_processing.has_key(entry.func_name): - print translator_custom_share_processing[entry.func_name], - - if (entry.return_type == "void"): - if (needsShareGroup): - print " ", - - if not translator_no_passthrough.has_key(entry.func_name): - print " ctx->dispatcher().%s(%s);" % (entry.func_name, globalCall) - - if needsShareGroup: - print " }" - if translator_custom_post.has_key(entry.func_name): - print translator_custom_post[entry.func_name]; - else: - if (needsShareGroup): - print " ", - if not translator_no_passthrough.has_key(entry.func_name): - print " %s %s = ctx->dispatcher().%s(%s);" % (entry.return_type, entry.func_name + "RET", entry.func_name, globalCall) - else: - print " %s %s = %s" % (entry.return_type, entry_func_name + "RET", get_fail_code(entry)) - - if translator_custom_post.has_key(entry.func_name): - print translator_custom_post[entry.func_name]; - - print " return %s;" % (entry.func_name + "RET"); - if needsShareGroup: - print " } else return %s;" % (get_fail_code(entry)) - - print "// Auto-generated with: %s" % banner_command(sys.argv) - print "// This file is best left unedited." - print "// Try to make changes through gen_translator in gen-entries.py," - print "// and/or parcel out custom functionality in separate code." - for entry in entries: - print "%sGL_APICALL %s GL_APIENTRY %s(%s) {" % (needExternC(entry), entry.return_type, entry.func_name, entry.parameters) - gen_cxt_getter(entry); - gen_validations_custom_impl(entry); - gen_call_ret(entry); - print "}\n" - def gen_dll_wrapper(entries, prefix_name, verbatim, filename): """Generate a C source file that contains functions that act as wrappers for entry points located in another shared library. This allows the @@ -423,8 +264,6 @@ def parse_file(filename, lines, mode): gen_windows_def_file(entries) elif mode == 'sym': gen_unix_sym_file(entries) - elif mode == 'translator_passthrough': - gen_translator(entries) elif mode == 'wrapper': gen_dll_wrapper(entries, prefix_name, verbatim, filename) elif mode == 'symbols': @@ -439,7 +278,7 @@ def parse_file(filename, lines, mode): # List of valid --mode option values. mode_list = [ - 'def', 'sym', 'translator_passthrough', 'wrapper', 'symbols', '_symbols', 'functions', 'funcargs' + 'def', 'sym', 'wrapper', 'symbols', '_symbols', 'functions', 'funcargs' ] # Argument parsing. diff --git a/host/libs/Android.bp b/host/libs/Android.bp new file mode 100644 index 000000000..99a3ff0cd --- /dev/null +++ b/host/libs/Android.bp @@ -0,0 +1,24 @@ +// +// Copyright (C) 2017 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. + +subdirs = [ + "adb_connection_maintainer", + "config", + "ivserver", + "monitor", + "usbip", + "virglrenderer", + "vm_manager", +] diff --git a/host/libs/virglrenderer/.clang-format b/host/libs/virglrenderer/.clang-format new file mode 100644 index 000000000..4b8411883 --- /dev/null +++ b/host/libs/virglrenderer/.clang-format @@ -0,0 +1,17 @@ +BasedOnStyle: Google +AccessModifierOffset: -2 +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: false +AllowShortIfStatementsOnASingleLine: false +AllowShortLoopsOnASingleLine: false +ConstructorInitializerAllOnOneLineOrOnePerLine: false +ColumnLimit: 100 +CommentPragmas: NOLINT:.* +Cpp11BracedListStyle: false +DerivePointerAlignment: false +IndentWidth: 4 +PointerAlignment: Left +TabWidth: 4 +UseTab: Never +PenaltyExcessCharacter: 32 diff --git a/host/libs/virglrenderer/.gitignore b/host/libs/virglrenderer/.gitignore new file mode 100644 index 000000000..562939a07 --- /dev/null +++ b/host/libs/virglrenderer/.gitignore @@ -0,0 +1,3 @@ +renderControl_dec/renderControl_server_context.cpp +GLESv1_dec/gles1_server_context.cpp +GLESv3_dec/gles3_server_context.cpp diff --git a/host/libs/virglrenderer/AVDVirglRenderer.cpp b/host/libs/virglrenderer/AVDVirglRenderer.cpp new file mode 100644 index 000000000..a089489f8 --- /dev/null +++ b/host/libs/virglrenderer/AVDVirglRenderer.cpp @@ -0,0 +1,1092 @@ +/* + * Copyright (C) 2018 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. + */ +#undef NDEBUG + +extern "C" { +#include <linux/virtio_gpu.h> +#include <virgl/virglrenderer.h> +#include <virgl_hw.h> +} + +#include <sys/uio.h> + +#include <dlfcn.h> +#include <algorithm> +#include <cassert> +#include <cerrno> +#include <cstdio> +#include <cstdlib> +#include <cstring> +#include <deque> +#include <map> +#include <mutex> +#include <string> +#include <vector> + +#include <EGL/egl.h> +#include <EGL/eglext.h> +#include <GLES/gl.h> +#include <GLES/glext.h> +#include <GLES3/gl31.h> +#include <GLES3/gl3ext.h> + +#include <drm/drm_fourcc.h> + +#include <OpenGLESDispatch/EGLDispatch.h> +#include <OpenGLESDispatch/GLESv1Dispatch.h> +#include <OpenGLESDispatch/GLESv3Dispatch.h> + +#include "OpenglRender/IOStream.h" + +#include "Context.h" +#include "EglConfig.h" +#include "EglContext.h" +#include "EglSurface.h" +#include "EglSync.h" +#include "Resource.h" + +#include <VirtioGpuCmd.h> + +// for debug only +#include <sys/syscall.h> +#include <unistd.h> +#define gettid() (int)syscall(__NR_gettid) + +#ifndef PAGE_SIZE +#define PAGE_SIZE 0x1000 +#endif + +#define MAX_CMDRESPBUF_SIZE (10 * PAGE_SIZE) + +#define ALIGN(A, B) (((A) + (B)-1) / (B) * (B)) + +// Enable passing scanout buffers as texture names to sdl2 backend +#define QEMU_HARDWARE_GL_INTEROP + +#ifdef QEMU_HARDWARE_GL_INTEROP +typedef GLenum (*PFNGLGETERROR)(void); +typedef void (*PFNGLBINDTEXTURE)(GLenum target, GLuint texture); +typedef void (*PFNGLGENTEXTURES)(GLsizei n, GLuint* textures); +typedef void (*PFNGLTEXPARAMETERI)(GLenum target, GLenum pname, GLint param); +typedef void (*PFNGLPIXELSTOREI)(GLenum pname, GLint param); +typedef void (*PFNGLTEXIMAGE2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, + GLsizei height, GLint border, GLenum format, GLenum type, + const void* pixels); +static PFNGLBINDTEXTURE g_glBindTexture; +static PFNGLGENTEXTURES g_glGenTextures; +static PFNGLTEXPARAMETERI g_glTexParameteri; +static PFNGLPIXELSTOREI g_glPixelStorei; +static PFNGLTEXIMAGE2D g_glTexImage2D; +static virgl_renderer_gl_context g_ctx0_alt; +#endif + +// Global state +std::map<uint32_t, EglContext*> EglContext::map; +std::map<uint32_t, EglSurface*> EglSurface::map; +std::map<uint32_t, EglImage*> EglImage::map; +std::map<uint32_t, Resource*> Resource::map; +std::map<uint64_t, EglSync*> EglSync::map; +std::map<uint32_t, Context*> Context::map; +std::vector<EglConfig*> EglConfig::vec; +static virgl_renderer_callbacks* g_cb; +const EGLint EglConfig::kAttribs[]; +uint32_t EglContext::nextId = 1U; +uint32_t EglSurface::nextId = 1U; +uint32_t EglImage::nextId = 1U; +uint64_t EglSync::nextId = 1U; +static void* g_cookie; + +// Fence queue, must be thread safe +static std::mutex g_fence_deque_mutex; +static std::deque<int> g_fence_deque; + +// Other GPU context and state +static EGLSurface g_ctx0_surface; +static EGLContext g_ctx0_es1; +static EGLContext g_ctx0_es2; +static EGLDisplay g_dpy; + +// Last context receiving a command. Allows us to find the context a fence is +// being created for. Works around the poorly designed virgl interface. +static Context* g_last_submit_cmd_ctx; + +#ifdef OPENGL_DEBUG_PRINTOUT + +#include "emugl/common/logging.h" + +// For logging from the protocol decoders + +void default_logger(const char* fmt, ...) { + va_list ap; + va_start(ap, fmt); + vprintf(fmt, ap); + va_end(ap); +} + +emugl_logger_t emugl_cxt_logger = default_logger; + +#endif + +static void dump_global_state(void) { + printf("AVDVIRGLRENDERER GLOBAL STATE\n\n"); + + printf("Resources:\n"); + for (auto const& it : Resource::map) { + Resource const* res = it.second; + + printf( + " Resource %u: %ux%u 0x%x %p (%zub) t=%u b=%u d=%u a=%u l=%u " + "n=%u f=%u\n", + res->args.handle, res->args.width, res->args.height, res->args.format, + res->iov ? res->iov[0].iov_base : nullptr, res->iov ? res->iov[0].iov_len : 0, + res->args.target, res->args.bind, res->args.depth, res->args.array_size, + res->args.last_level, res->args.nr_samples, res->args.flags); + + for (auto const& it : res->context_map) { + Context const* ctx = it.second; + + printf(" Context %u, pid=%d, tid=%d\n", ctx->handle, ctx->pid, ctx->tid); + } + } + + printf("Contexts:\n"); + for (auto const& it : Context::map) { + Context const* ctx = it.second; + + printf(" Context %u: %s pid=%u tid=%u\n", ctx->handle, ctx->name.c_str(), ctx->pid, + ctx->tid); + + for (auto const& it : ctx->resource_map) { + Resource const* res = it.second; + + printf(" Resource %u\n", res->args.handle); + } + } +} + +static int sync_linear_to_iovec(Resource* res, uint64_t offset, const virgl_box* box) { + uint32_t bpp; + switch (res->args.format) { + case VIRGL_FORMAT_R8_UNORM: + bpp = 1U; + break; + case VIRGL_FORMAT_B5G6R5_UNORM: + bpp = 2U; + break; + default: + bpp = 4U; + break; + } + + if (box->x > res->args.width || box->y > res->args.height) + return 0; + if (box->w == 0U || box->h == 0U) + return 0; + uint32_t w = std::min(box->w, res->args.width - box->x); + uint32_t h = std::min(box->h, res->args.height - box->y); + uint32_t stride = ALIGN(res->args.width * bpp, 16U); + offset += box->y * stride + box->x * bpp; + size_t length = (h - 1U) * stride + w * bpp; + if (offset + length > res->linearSize) + return EINVAL; + + if (res->num_iovs > 1) { + const char* linear = static_cast<const char*>(res->linear); + for (uint32_t i = 0, iovOffset = 0U; length && i < res->num_iovs; i++) { + if (iovOffset + res->iov[i].iov_len > offset) { + char* iov_base = static_cast<char*>(res->iov[i].iov_base); + size_t copyLength = std::min(length, res->iov[i].iov_len); + memcpy(iov_base + offset - iovOffset, linear, copyLength); + linear += copyLength; + offset += copyLength; + length -= copyLength; + } + iovOffset += res->iov[i].iov_len; + } + } + + return 0; +} + +static int sync_iovec_to_linear(Resource* res, uint64_t offset, const virgl_box* box) { + uint32_t bpp; + switch (res->args.format) { + case VIRGL_FORMAT_R8_UNORM: + bpp = 1U; + break; + case VIRGL_FORMAT_B5G6R5_UNORM: + bpp = 2U; + break; + default: + bpp = 4U; + break; + } + + if (box->x > res->args.width || box->y > res->args.height) + return 0; + if (box->w == 0U || box->h == 0U) + return 0; + uint32_t w = std::min(box->w, res->args.width - box->x); + uint32_t h = std::min(box->h, res->args.height - box->y); + uint32_t stride = ALIGN(res->args.width * bpp, 16U); + offset += box->y * stride + box->x * bpp; + size_t length = (h - 1U) * stride + w * bpp; + if (offset + length > res->linearSize) + return EINVAL; + + if (res->num_iovs > 1) { + char* linear = static_cast<char*>(res->linear); + for (uint32_t i = 0, iovOffset = 0U; length && i < res->num_iovs; i++) { + if (iovOffset + res->iov[i].iov_len > offset) { + const char* iov_base = static_cast<const char*>(res->iov[i].iov_base); + size_t copyLength = std::min(length, res->iov[i].iov_len); + memcpy(linear, iov_base + offset - iovOffset, copyLength); + linear += copyLength; + offset += copyLength; + length -= copyLength; + } + iovOffset += res->iov[i].iov_len; + } + } + + return 0; +} + +// The below API was defined by virglrenderer 'master', but does not seem to +// be used by QEMU, so just ignore it for now.. +// +// virgl_renderer_get_rect +// virgl_renderer_get_fd_for_texture +// virgl_renderer_cleanup +// virgl_renderer_reset +// virgl_renderer_get_poll_fd + +int virgl_renderer_init(void* cookie, int flags, virgl_renderer_callbacks* cb) { + if (!cookie || !cb) + return EINVAL; + + if (flags != 0) + return ENOSYS; + + if (cb->version != 1) + return ENOSYS; + +#ifdef QEMU_HARDWARE_GL_INTEROP + // FIXME: If we just use "libGL.so" here, mesa's interception library returns + // stub dlsyms that do nothing at runtime, even after binding.. + void* handle = dlopen( + "/usr/lib/x86_64-linux-gnu/nvidia/" + "current/libGL.so.384.111", + RTLD_NOW); + assert(handle != nullptr); + g_glBindTexture = (PFNGLBINDTEXTURE)dlsym(handle, "glBindTexture"); + assert(g_glBindTexture != nullptr); + g_glGenTextures = (PFNGLGENTEXTURES)dlsym(handle, "glGenTextures"); + assert(g_glGenTextures != nullptr); + g_glTexParameteri = (PFNGLTEXPARAMETERI)dlsym(handle, "glTexParameteri"); + assert(g_glTexParameteri != nullptr); + g_glPixelStorei = (PFNGLPIXELSTOREI)dlsym(handle, "glPixelStorei"); + assert(g_glPixelStorei != nullptr); + g_glTexImage2D = (PFNGLTEXIMAGE2D)dlsym(handle, "glTexImage2D"); + assert(g_glTexImage2D != nullptr); +#endif + + if (!egl_dispatch_init()) + return ENOENT; + + if (!gles1_dispatch_init()) + return ENOENT; + + if (!gles3_dispatch_init()) + return ENOENT; + + g_dpy = s_egl.eglGetDisplay(EGL_DEFAULT_DISPLAY); + if (g_dpy == EGL_NO_DISPLAY) { + printf("Failed to open default EGL display\n"); + return ENOENT; + } + + if (!s_egl.eglInitialize(g_dpy, nullptr, nullptr)) { + printf("Failed to initialize EGL display\n"); + g_dpy = EGL_NO_DISPLAY; + return ENOENT; + } + + EGLint nConfigs; + if (!s_egl.eglGetConfigs(g_dpy, nullptr, 0, &nConfigs)) { + printf("Failed to retrieve number of EGL configs\n"); + s_egl.eglTerminate(g_dpy); + g_dpy = EGL_NO_DISPLAY; + return ENOENT; + } + + EGLConfig configs[nConfigs]; + if (!s_egl.eglGetConfigs(g_dpy, configs, nConfigs, &nConfigs)) { + printf("Failed to retrieve EGL configs\n"); + s_egl.eglTerminate(g_dpy); + g_dpy = EGL_NO_DISPLAY; + return ENOENT; + } + for (EGLint c = 0; c < nConfigs; c++) { + EGLint configId; + if (!s_egl.eglGetConfigAttrib(g_dpy, configs[c], EGL_CONFIG_ID, &configId)) { + printf("Failed to retrieve EGL config ID\n"); + s_egl.eglTerminate(g_dpy); + g_dpy = EGL_NO_DISPLAY; + return ENOENT; + } + EglConfig* config = + new (std::nothrow) EglConfig(g_dpy, configs[c], s_egl.eglGetConfigAttrib); + if (!config) + return ENOMEM; + } + + // clang-format off + EGLint const attrib_list[] = { + EGL_CONFORMANT, EGL_OPENGL_ES_BIT | EGL_OPENGL_ES3_BIT_KHR, + EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, + EGL_NONE, + }; + // clang-format on + EGLint num_config = 0; + EGLConfig config; + if (!s_egl.eglChooseConfig(g_dpy, attrib_list, &config, 1, &num_config) || num_config != 1) { + printf("Failed to select ES1 & ES3 capable EGL config\n"); + s_egl.eglTerminate(g_dpy); + g_dpy = EGL_NO_DISPLAY; + return ENOENT; + } + + // clang-format off + EGLint const pbuffer_attrib_list[] = { + EGL_WIDTH, 1, + EGL_HEIGHT, 1, + EGL_NONE + }; + // clang-format on + g_ctx0_surface = s_egl.eglCreatePbufferSurface(g_dpy, config, pbuffer_attrib_list); + if (!g_ctx0_surface) { + printf("Failed to create pbuffer surface for context 0\n"); + s_egl.eglTerminate(g_dpy); + g_dpy = EGL_NO_DISPLAY; + return ENOENT; + } + + // clang-format off + EGLint const es1_attrib_list[] = { + EGL_CONTEXT_CLIENT_VERSION, 1, + EGL_NONE + }; + // clang-format on + g_ctx0_es1 = s_egl.eglCreateContext(g_dpy, config, EGL_NO_CONTEXT, es1_attrib_list); + if (g_ctx0_es1 == EGL_NO_CONTEXT) { + printf("Failed to create ES1 context 0\n"); + s_egl.eglDestroySurface(g_dpy, g_ctx0_surface); + s_egl.eglTerminate(g_dpy); + g_dpy = EGL_NO_DISPLAY; + return ENOENT; + } + + // clang-format off + EGLint const es2_attrib_list[] = { + EGL_CONTEXT_CLIENT_VERSION, 3, // yes, 3 + EGL_NONE + }; + // clang-format on + g_ctx0_es2 = s_egl.eglCreateContext(g_dpy, config, EGL_NO_CONTEXT, es2_attrib_list); + if (g_ctx0_es2 == EGL_NO_CONTEXT) { + printf("Failed to create ES2 context 0\n"); + s_egl.eglDestroySurface(g_dpy, g_ctx0_surface); + s_egl.eglDestroyContext(g_dpy, g_ctx0_es1); + g_ctx0_es1 = EGL_NO_CONTEXT; + s_egl.eglTerminate(g_dpy); + g_dpy = EGL_NO_DISPLAY; + } + +#ifdef QEMU_HARDWARE_GL_INTEROP + // This is the hardware GPU context. In future, this code should probably + // be removed and SwiftShader be used for all presentation blits. + virgl_renderer_gl_ctx_param ctx_params = { + .major_ver = 3, + .minor_ver = 0, + }; + g_ctx0_alt = cb->create_gl_context(cookie, 0, &ctx_params); + if (!g_ctx0_alt) { + printf("Failed to create hardware GL context 0\n"); + s_egl.eglDestroySurface(g_dpy, g_ctx0_surface); + s_egl.eglDestroyContext(g_dpy, g_ctx0_es1); + g_ctx0_es1 = EGL_NO_CONTEXT; + s_egl.eglTerminate(g_dpy); + g_dpy = EGL_NO_DISPLAY; + } + + // Test we can actually make it current; otherwise, bail + if (cb->make_current(cookie, 0, g_ctx0_alt)) { + printf("Failed to make hardware GL context 0 current\n"); + cb->destroy_gl_context(cookie, g_ctx0_alt); + g_ctx0_alt = nullptr; + s_egl.eglDestroySurface(g_dpy, g_ctx0_surface); + s_egl.eglDestroyContext(g_dpy, g_ctx0_es1); + g_ctx0_es1 = EGL_NO_CONTEXT; + s_egl.eglTerminate(g_dpy); + g_dpy = EGL_NO_DISPLAY; + } +#endif + + EglContext::nextId = 1U; + g_cookie = cookie; + g_cb = cb; + return 0; +} + +void virgl_renderer_poll(void) { + std::lock_guard<std::mutex> lk(g_fence_deque_mutex); + for (auto fence : g_fence_deque) + g_cb->write_fence(g_cookie, fence); + g_fence_deque.clear(); +} + +void* virgl_renderer_get_cursor_data(uint32_t resource_id, uint32_t* width, uint32_t* height) { + if (!width || !height) + return nullptr; + + std::map<uint32_t, Resource*>::iterator it; + it = Resource::map.find(resource_id); + if (it == Resource::map.end()) + return nullptr; + + Resource* res = it->second; + if (res->args.bind != VIRGL_RES_BIND_CURSOR) + return nullptr; + + void* pixels = malloc(res->linearSize); + memcpy(pixels, res->linear, res->linearSize); + *height = res->args.height; + *width = res->args.width; + return pixels; +} + +// NOTE: This function is called from thread context. Do not touch anything +// without a mutex to protect it from concurrent access. Everything else in +// libvirglrenderer is designed to be single-threaded *only*. + +// Hack to serialize all calls into EGL or GLES functions due to bugs in +// swiftshader. This should be removed as soon as possible. +static std::mutex swiftshader_wa_mutex; + +static void process_cmd(Context* ctx, char* buf, size_t bufSize, int fence) { + VirtioGpuCmd* cmd_resp = reinterpret_cast<VirtioGpuCmd*>(ctx->cmd_resp->linear); + + IOStream stream(cmd_resp->buf, MAX_CMDRESPBUF_SIZE - sizeof(*cmd_resp)); + + { + std::lock_guard<std::mutex> lk(swiftshader_wa_mutex); + size_t decodedBytes; + + decodedBytes = ctx->render_control.decode(buf, bufSize, &stream, &ctx->checksum_calc); + bufSize -= decodedBytes; + buf += decodedBytes; + + decodedBytes = ctx->gles1.decode(buf, bufSize, &stream, &ctx->checksum_calc); + bufSize -= decodedBytes; + buf += decodedBytes; + + decodedBytes = ctx->gles3.decode(buf, bufSize, &stream, &ctx->checksum_calc); + bufSize -= decodedBytes; + buf += decodedBytes; + } + + assert(bufSize == 0); + + cmd_resp->cmdSize += stream.getFlushSize(); + + printf("(tid %d) ctx %d: cmd %u, size %zu, fence %d\n", gettid(), ctx->handle, cmd_resp->op, + cmd_resp->cmdSize - sizeof(*cmd_resp), fence); + if (cmd_resp->cmdSize - sizeof(*cmd_resp) > 0) { + printf("(tid %d) ", gettid()); + for (size_t i = 0; i < cmd_resp->cmdSize - sizeof(*cmd_resp); i++) { + printf("%.2x ", (unsigned char)cmd_resp->buf[i]); + } + printf("\n"); + } + + virgl_box box = { + .w = cmd_resp->cmdSize, + .h = 1, + }; + sync_linear_to_iovec(ctx->cmd_resp, 0, &box); + + { + std::lock_guard<std::mutex> lk(g_fence_deque_mutex); + g_fence_deque.push_back(fence); + } +} + +int virgl_renderer_submit_cmd(void* buffer, int ctx_id, int ndw) { + VirtioGpuCmd* cmd = static_cast<VirtioGpuCmd*>(buffer); + size_t bufSize = sizeof(uint32_t) * ndw; + + if (bufSize < sizeof(*cmd)) { + printf("bad buffer size, bufSize=%zu, ctx=%d\n", bufSize, ctx_id); + return -1; + } + + printf("ctx %d: cmd %u, size %zu\n", ctx_id, cmd->op, cmd->cmdSize - sizeof(*cmd)); + + for (size_t i = 0; i < bufSize - sizeof(*cmd); i++) { + printf("%.2x ", (unsigned char)cmd->buf[i]); + } + printf("\n"); + + if (cmd->cmdSize < bufSize) { + printf("ignoring short command, cmdSize=%u, bufSize=%zu\n", cmd->cmdSize, bufSize); + return 0; + } + + if (cmd->cmdSize > bufSize) { + printf("command would overflow buffer, cmdSize=%u, bufSize=%zu\n", cmd->cmdSize, bufSize); + return -1; + } + + std::map<uint32_t, Context*>::iterator it; + it = Context::map.find((uint32_t)ctx_id); + if (it == Context::map.end()) { + printf("command submit from invalid context %d, ignoring\n", ctx_id); + return 0; + } + + Context* ctx = it->second; + + // When the context is created, the remote side should send a test command + // (op == 0) which we use to set up our link to this context's 'response + // buffer'. Only apps using EGL or GLES have this. Gralloc contexts will + // never hit this path because they do not submit 3D commands. + if (cmd->op == 0) { + std::map<uint32_t, Resource*>::iterator it; + it = Resource::map.find(*(uint32_t*)cmd->buf); + if (it != Resource::map.end()) { + Resource* res = it->second; + size_t cmdRespBufSize = 0U; + for (size_t i = 0; i < res->num_iovs; i++) + cmdRespBufSize += res->iov[i].iov_len; + if (cmdRespBufSize == MAX_CMDRESPBUF_SIZE) + ctx->cmd_resp = res; + } + } + + if (!ctx->cmd_resp) { + printf("context command response page not set up, ctx=%d\n", ctx_id); + return -1; + } + + VirtioGpuCmd* cmd_resp = reinterpret_cast<VirtioGpuCmd*>(ctx->cmd_resp->linear); + + // We can configure bits of the response now. The size, and any message, will + // be updated later. This must be done even for the dummy 'op == 0' command. + cmd_resp->op = cmd->op; + cmd_resp->cmdSize = sizeof(*cmd_resp); + + if (cmd->op == 0) { + // Send back a no-op response, just to keep the protocol in check + virgl_box box = { + .w = cmd_resp->cmdSize, + .h = 1, + }; + sync_linear_to_iovec(ctx->cmd_resp, 0, &box); + } else { + // If the rcSetPuid command was already processed, this command will be + // processed by another thread. If not, the command data will be copied + // here and responded to when ctx->setFence() is called later. + ctx->submitCommand(buffer, bufSize); + } + + g_last_submit_cmd_ctx = ctx; + return 0; +} + +void virgl_renderer_get_cap_set(uint32_t set, uint32_t* max_ver, uint32_t* max_size) { + if (!max_ver || !max_size) + return; + + printf("Request for caps version %u\n", set); + + switch (set) { + case 1: + *max_ver = 1; + *max_size = sizeof(virgl_caps_v1); + break; + case 2: + *max_ver = 2; + *max_size = sizeof(virgl_caps_v2); + break; + default: + *max_ver = 0; + *max_size = 0; + break; + } +} + +void virgl_renderer_fill_caps(uint32_t set, uint32_t, void* caps_) { + union virgl_caps* caps = static_cast<union virgl_caps*>(caps_); + EGLSurface old_read_surface, old_draw_surface; + GLfloat range[2] = { 0.0f, 0.0f }; + bool fill_caps_v2 = false; + EGLContext old_context; + GLint max = 0; + + if (!caps) + return; + + // We don't need to handle caps yet, because our guest driver's features + // should be as close as possible to the host driver's. But maybe some day + // we'll support gallium shaders and the virgl control stream, so it seems + // like a good idea to set up the driver caps correctly.. + + // If this is broken, nothing will work properly + old_read_surface = s_egl.eglGetCurrentSurface(EGL_READ); + old_draw_surface = s_egl.eglGetCurrentSurface(EGL_DRAW); + old_context = s_egl.eglGetCurrentContext(); + if (!s_egl.eglMakeCurrent(g_dpy, g_ctx0_surface, g_ctx0_surface, g_ctx0_es1)) { + printf("Failed to make ES1 context current\n"); + return; + } + + // Don't validate 'version' because it looks like this was misdesigned + // upstream and won't be set; instead, 'set' was bumped from 1->2. + + switch (set) { + case 0: + case 1: + memset(caps, 0, sizeof(virgl_caps_v1)); + caps->max_version = 1; + break; + case 2: + memset(caps, 0, sizeof(virgl_caps_v2)); + caps->max_version = 2; + fill_caps_v2 = true; + break; + default: + caps->max_version = 0; + return; + } + + if (fill_caps_v2) { + printf("Will probe and fill caps version 2.\n"); + } + + // Formats supported for textures + + caps->v1.sampler.bitmask[0] = (1 << (VIRGL_FORMAT_B8G8R8A8_UNORM - (0 * 32))) | + (1 << (VIRGL_FORMAT_B5G6R5_UNORM - (0 * 32))); + caps->v1.sampler.bitmask[2] = (1 << (VIRGL_FORMAT_R8G8B8A8_UNORM - (2 * 32))); + caps->v1.sampler.bitmask[4] = (1 << (VIRGL_FORMAT_R8G8B8X8_UNORM - (4 * 32))); + + // Formats supported for rendering + + caps->v1.render.bitmask[0] = (1 << (VIRGL_FORMAT_B8G8R8A8_UNORM - (0 * 32))) | + (1 << (VIRGL_FORMAT_B5G6R5_UNORM - (0 * 32))); + caps->v1.render.bitmask[2] = (1 << (VIRGL_FORMAT_R8G8B8A8_UNORM - (2 * 32))); + caps->v1.render.bitmask[4] = (1 << (VIRGL_FORMAT_R8G8B8X8_UNORM - (4 * 32))); + + // Could parse s_gles1.glGetString(GL_SHADING_LANGUAGE_VERSION, ...)? + caps->v1.glsl_level = 300; // OpenGL ES GLSL 3.00 + + // Call with any API (v1, v3) bound + + caps->v1.max_viewports = 1; + + s_gles1.glGetIntegerv(GL_MAX_DRAW_BUFFERS_EXT, &max); + caps->v1.max_render_targets = max; + + s_gles1.glGetIntegerv(GL_MAX_SAMPLES_EXT, &max); + caps->v1.max_samples = max; + + if (fill_caps_v2) { + s_gles1.glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, range); + caps->v2.min_aliased_point_size = range[0]; + caps->v2.max_aliased_point_size = range[1]; + + s_gles1.glGetFloatv(GL_ALIASED_LINE_WIDTH_RANGE, range); + caps->v2.min_aliased_line_width = range[0]; + caps->v2.max_aliased_line_width = range[1]; + + // An extension, but everybody has it + s_gles1.glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &max); + caps->v2.max_vertex_attribs = max; + + // Call with ES 1.0 bound *only* + + s_gles1.glGetFloatv(GL_SMOOTH_POINT_SIZE_RANGE, range); + caps->v2.min_smooth_point_size = range[0]; + caps->v2.max_smooth_point_size = range[1]; + + s_gles1.glGetFloatv(GL_SMOOTH_LINE_WIDTH_RANGE, range); + caps->v2.min_smooth_line_width = range[0]; + caps->v2.max_smooth_line_width = range[1]; + } + + if (!s_egl.eglMakeCurrent(g_dpy, g_ctx0_surface, g_ctx0_surface, g_ctx0_es2)) { + s_egl.eglMakeCurrent(g_dpy, old_draw_surface, old_read_surface, old_context); + printf("Failed to make ES3 context current\n"); + return; + } + + // Call with ES 3.0 bound *only* + + caps->v1.bset.primitive_restart = 1; + caps->v1.bset.seamless_cube_map = 1; + caps->v1.bset.occlusion_query = 1; + caps->v1.bset.instanceid = 1; + caps->v1.bset.ubo = 1; + + s_gles1.glGetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS, &max); + caps->v1.max_texture_array_layers = max; + + s_gles1.glGetIntegerv(GL_MAX_VERTEX_UNIFORM_BLOCKS, &max); + caps->v1.max_uniform_blocks = max + 1; + + if (fill_caps_v2) { + s_gles1.glGetFloatv(GL_MAX_TEXTURE_LOD_BIAS, &caps->v2.max_texture_lod_bias); + + s_gles1.glGetIntegerv(GL_MAX_VERTEX_OUTPUT_COMPONENTS, &max); + caps->v2.max_vertex_outputs = max / 4; + + s_gles1.glGetIntegerv(GL_MIN_PROGRAM_TEXEL_OFFSET, &caps->v2.min_texel_offset); + s_gles1.glGetIntegerv(GL_MAX_PROGRAM_TEXEL_OFFSET, &caps->v2.max_texel_offset); + + s_gles1.glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &max); + caps->v2.uniform_buffer_offset_alignment = max; + } + + // ES 2.0 extensions (fixme) + + // Gallium compatibility; not usable currently. + caps->v1.prim_mask = (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6); + + if (!s_egl.eglMakeCurrent(g_dpy, old_draw_surface, old_read_surface, old_context)) { + printf("Failed to make no context current\n"); + } +} + +int virgl_renderer_create_fence(int client_fence_id, uint32_t cmd_type) { + switch (cmd_type) { + case VIRTIO_GPU_CMD_SUBMIT_3D: + if (g_last_submit_cmd_ctx) { + g_last_submit_cmd_ctx->setFence(client_fence_id); + break; + } + // Fall through + default: { + std::lock_guard<std::mutex> lk(g_fence_deque_mutex); + g_fence_deque.push_back(client_fence_id); + break; + } + } + return 0; +} + +void virgl_renderer_force_ctx_0(void) { +#ifdef QEMU_HARDWARE_GL_INTEROP + if (!g_ctx0_alt) + return; + + if (g_cb->make_current(g_cookie, 0, g_ctx0_alt)) { + printf("Failed to make hardware GL context 0 current\n"); + g_cb->destroy_gl_context(g_cookie, g_ctx0_alt); + g_ctx0_alt = nullptr; + } +#endif +} + +int virgl_renderer_resource_create(virgl_renderer_resource_create_args* args, iovec* iov, + uint32_t num_iovs) { + if (!args) + return EINVAL; + + if (args->bind == VIRGL_RES_BIND_CURSOR) { + // Enforce limitation of current virtio-gpu-3d implementation + if (args->width != 64 || args->height != 64 || args->format != VIRGL_FORMAT_B8G8R8A8_UNORM) + return EINVAL; + } + + assert(!Resource::map.count(args->handle) && "Can't insert same resource twice!"); + + Resource* res = new (std::nothrow) Resource(args, num_iovs, iov); + if (!res) + return ENOMEM; + + printf("Creating Resource %u (num_iovs=%u)\n", args->handle, num_iovs); + return 0; +} + +void virgl_renderer_resource_unref(uint32_t res_handle) { + std::map<uint32_t, Resource*>::iterator it; + + it = Resource::map.find(res_handle); + if (it == Resource::map.end()) + return; + + Resource* res = it->second; + + for (auto const& it : Context::map) { + Context const* ctx = it.second; + + virgl_renderer_ctx_detach_resource(ctx->handle, res->args.handle); + } + + assert(res->context_map.empty() && "Deleted resource was associated with contexts"); + + printf("Deleting Resource %u\n", res_handle); + delete res; +} + +int virgl_renderer_resource_attach_iov(int res_handle, iovec* iov, int num_iovs) { + std::map<uint32_t, Resource*>::iterator it; + + it = Resource::map.find((uint32_t)res_handle); + if (it == Resource::map.end()) + return ENOENT; + + Resource* res = it->second; + + if (!res->iov) { + printf( + "Attaching backing store for Resource %d " + "(num_iovs=%d)\n", + res_handle, num_iovs); + + res->num_iovs = num_iovs; + res->iov = iov; + + res->reallocLinear(); + + // Assumes that when resources are attached, they contain junk, and we + // don't need to synchronize with the linear buffer + } + + return 0; +} + +void virgl_renderer_resource_detach_iov(int res_handle, iovec** iov, int* num_iovs) { + std::map<uint32_t, Resource*>::iterator it; + + it = Resource::map.find((uint32_t)res_handle); + if (it == Resource::map.end()) + return; + + Resource* res = it->second; + + printf("Detaching backing store for Resource %d\n", res_handle); + + // Synchronize our linear buffer, if any, with the iovec that we are about + // to give up. Most likely this is not required, but it seems cleaner. + virgl_box box = { + .w = res->args.width, + .h = res->args.height, + }; + sync_linear_to_iovec(res, 0, &box); + + if (num_iovs) + *num_iovs = res->num_iovs; + res->num_iovs = 0U; + + if (iov) + *iov = res->iov; + res->iov = nullptr; + + res->reallocLinear(); +} + +int virgl_renderer_resource_get_info(int res_handle, virgl_renderer_resource_info* info) { + if (!info) + return EINVAL; + + std::map<uint32_t, Resource*>::iterator it; + + it = Resource::map.find((uint32_t)res_handle); + if (it == Resource::map.end()) + return ENOENT; + + Resource* res = it->second; + + uint32_t bpp = 4U; + switch (res->args.format) { + case VIRGL_FORMAT_B8G8R8A8_UNORM: + info->drm_fourcc = DRM_FORMAT_BGRA8888; + break; + case VIRGL_FORMAT_B5G6R5_UNORM: + info->drm_fourcc = DRM_FORMAT_BGR565; + bpp = 2U; + break; + case VIRGL_FORMAT_R8G8B8A8_UNORM: + info->drm_fourcc = DRM_FORMAT_RGBA8888; + break; + case VIRGL_FORMAT_R8G8B8X8_UNORM: + info->drm_fourcc = DRM_FORMAT_RGBX8888; + break; + default: + return EINVAL; + } + +#ifdef QEMU_HARDWARE_GL_INTEROP + GLenum type = GL_UNSIGNED_BYTE; + GLenum format = GL_RGBA; + switch (res->args.format) { + case VIRGL_FORMAT_B8G8R8A8_UNORM: + format = 0x80E1; // GL_BGRA + break; + case VIRGL_FORMAT_B5G6R5_UNORM: + type = GL_UNSIGNED_SHORT_5_6_5; + format = GL_RGB; + break; + case VIRGL_FORMAT_R8G8B8X8_UNORM: + format = GL_RGB; + break; + } + + if (!res->tex_id) { + g_glGenTextures(1, &res->tex_id); + g_glBindTexture(GL_TEXTURE_2D, res->tex_id); + g_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + g_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + g_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + g_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + } else { + g_glBindTexture(GL_TEXTURE_2D, res->tex_id); + } + + g_glPixelStorei(GL_UNPACK_ROW_LENGTH, ALIGN(res->args.width, 16)); + g_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, res->args.width, res->args.height, 0, format, type, + res->linear); +#endif + + info->stride = ALIGN(res->args.width * bpp, 16U); + info->virgl_format = res->args.format; + info->handle = res->args.handle; + info->height = res->args.height; + info->width = res->args.width; + info->depth = res->args.depth; + info->flags = res->args.flags; + info->tex_id = res->tex_id; + + printf("Scanning out Resource %d\n", res_handle); + dump_global_state(); + + return 0; +} + +int virgl_renderer_context_create(uint32_t handle, uint32_t nlen, const char* name) { + assert(!Context::map.count(handle) && "Can't insert same context twice!"); + + Context* ctx = new (std::nothrow) Context(handle, name, nlen, process_cmd, g_dpy); + if (!ctx) + return ENOMEM; + + printf("Creating Context %u (%.*s)\n", handle, (int)nlen, name); + return 0; +} + +void virgl_renderer_context_destroy(uint32_t handle) { + std::map<uint32_t, Context*>::iterator it; + it = Context::map.find(handle); + if (it == Context::map.end()) + return; + + Context* ctx = it->second; + printf("Destroying Context %u\n", handle); + delete ctx; +} + +int virgl_renderer_transfer_read_iov(uint32_t handle, uint32_t, uint32_t, uint32_t, uint32_t, + virgl_box* box, uint64_t offset, iovec*, int) { + // stride, layer_stride and level are not set by minigbm, so don't try to + // validate them right now. iov and iovec_cnt are always passed as nullptr + // and 0 by qemu, so ignore those too + + std::map<uint32_t, Resource*>::iterator it; + it = Resource::map.find((uint32_t)handle); + if (it == Resource::map.end()) + return EINVAL; + + return sync_linear_to_iovec(it->second, offset, box); +} + +int virgl_renderer_transfer_write_iov(uint32_t handle, uint32_t, int, uint32_t, uint32_t, + virgl_box* box, uint64_t offset, iovec*, unsigned int) { + // stride, layer_stride and level are not set by minigbm, so don't try to + // validate them right now. iov and iovec_cnt are always passed as nullptr + // and 0 by qemu, so ignore those too + + std::map<uint32_t, Resource*>::iterator it; + it = Resource::map.find((uint32_t)handle); + if (it == Resource::map.end()) + return EINVAL; + + return sync_iovec_to_linear(it->second, offset, box); +} + +void virgl_renderer_ctx_attach_resource(int ctx_id, int res_handle) { + std::map<uint32_t, Context*>::iterator ctx_it; + + ctx_it = Context::map.find((uint32_t)ctx_id); + if (ctx_it == Context::map.end()) + return; + + Context* ctx = ctx_it->second; + + assert(!ctx->resource_map.count((uint32_t)res_handle) && + "Can't attach resource to context twice!"); + + std::map<uint32_t, Resource*>::iterator res_it; + + res_it = Resource::map.find((uint32_t)res_handle); + if (res_it == Resource::map.end()) + return; + + Resource* res = res_it->second; + + printf("Attaching Resource %d to Context %d\n", res_handle, ctx_id); + res->context_map.emplace((uint32_t)ctx_id, ctx); + ctx->resource_map.emplace((uint32_t)res_handle, res); +} + +void virgl_renderer_ctx_detach_resource(int ctx_id, int res_handle) { + std::map<uint32_t, Context*>::iterator ctx_it; + + ctx_it = Context::map.find((uint32_t)ctx_id); + if (ctx_it == Context::map.end()) + return; + + Context* ctx = ctx_it->second; + + std::map<uint32_t, Resource*>::iterator res_it; + + res_it = ctx->resource_map.find((uint32_t)res_handle); + if (res_it == ctx->resource_map.end()) + return; + + Resource* res = res_it->second; + + ctx_it = res->context_map.find((uint32_t)ctx_id); + if (ctx_it == res->context_map.end()) + return; + + printf("Detaching Resource %d from Context %d\n", res_handle, ctx_id); + if (ctx->cmd_resp && ctx->cmd_resp->args.handle == (uint32_t)res_handle) + ctx->cmd_resp = nullptr; + ctx->resource_map.erase(res_it); + res->context_map.erase(ctx_it); +} diff --git a/host/libs/virglrenderer/Android.bp b/host/libs/virglrenderer/Android.bp new file mode 100644 index 000000000..7fd35d904 --- /dev/null +++ b/host/libs/virglrenderer/Android.bp @@ -0,0 +1,43 @@ +// +// Copyright (C) 2018 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. +// + +cc_library_host_shared { + name: "libvirglrenderer", + include_dirs: [ + "external/libdrm", + "external/libdrm/include", + "device/generic/goldfish-opengl/system", + ], + local_include_dirs: [ "include" ], + srcs: [ + "AVDVirglRenderer.cpp", + "ChecksumCalculator.cpp", + "GLESv1.cpp", + "GLESv1_dec/gles1_dec.cpp", + "GLESv3.cpp", + "GLESv3_dec/gles3_dec.cpp", + "Gralloc1.cpp", + "OpenGLESDispatch/EGLDispatch.cpp", + "OpenGLESDispatch/GLESv1Dispatch.cpp", + "OpenGLESDispatch/GLESv3Dispatch.cpp", + "RenderControl.cpp", + "renderControl_dec/renderControl_dec.cpp", + ], + cflags: ["-Wno-unused-parameter", "-DOPENGL_DEBUG_PRINTOUT"], + host_ldlibs: [ "-ldl" ], + version_script : "libvirglrenderer.lds", + defaults: [ "cuttlefish_host_only" ], +} diff --git a/host/libs/virglrenderer/ChecksumCalculator.cpp b/host/libs/virglrenderer/ChecksumCalculator.cpp index 7bd82fc76..b5d11c0cf 100644 --- a/host/libs/virglrenderer/ChecksumCalculator.cpp +++ b/host/libs/virglrenderer/ChecksumCalculator.cpp @@ -1,23 +1,21 @@ /* -* Copyright (C) 2016 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. -*/ + * Copyright (C) 2016 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 "ChecksumCalculator.h" -#include "android/base/files/Stream.h" - #include <string> #include <vector> @@ -140,33 +138,3 @@ uint32_t ChecksumCalculator::computeV1Checksum() const { revLen = (revLen & 0xaaaaaaaa) >> 1 | (revLen & 0x55555555) << 1; return revLen; } - -void ChecksumCalculator::save(android::base::Stream* stream) { - assert(!m_isEncodingChecksum); - switch (m_version) { - case 1: - assert(m_v1BufferTotalLength == 0); - break; - } - - // Our checksum should never become > 255 bytes. Ever. - assert((uint8_t)m_checksumSize == m_checksumSize); - stream->putByte(m_checksumSize); - stream->putBe32(m_version); - stream->putBe32(m_numRead); - stream->putBe32(m_numWrite); -} - -void ChecksumCalculator::load(android::base::Stream* stream) { - assert(!m_isEncodingChecksum); - switch (m_version) { - case 1: - assert(m_v1BufferTotalLength == 0); - break; - } - - m_checksumSize = stream->getByte(); - m_version = stream->getBe32(); - m_numRead = stream->getBe32(); - m_numWrite = stream->getBe32(); -} diff --git a/host/libs/virglrenderer/ChecksumCalculator.h b/host/libs/virglrenderer/ChecksumCalculator.h index df94403e2..8e8ce952a 100644 --- a/host/libs/virglrenderer/ChecksumCalculator.h +++ b/host/libs/virglrenderer/ChecksumCalculator.h @@ -1,18 +1,18 @@ /* -* Copyright (C) 2016 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. -*/ + * Copyright (C) 2016 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 @@ -29,7 +29,11 @@ #define LOG_CHECKSUMHELPER(x...) #endif -namespace android { namespace base { class Stream; } } +namespace android { +namespace base { +class Stream; +} +} // namespace android // ChecksumCalculator adds checksum as an array of bytes to GL pipe communication, which // size depends on the protocol version. Each pipe should use one ChecksumCalculator. @@ -124,11 +128,13 @@ namespace android { namespace base { class Stream; } } // } class ChecksumCalculator { -public: + public: static constexpr size_t kMaxChecksumLength = 8; // Get and set current checksum version - uint32_t getVersion() const { return m_version; } + uint32_t getVersion() const { + return m_version; + } // Call setVersion to set a checksum version. It should be called before // addBuffer(), writeChecksum() and validate(). And it should be called // exact once per rendering thread if both host and guest support checksum. @@ -146,7 +152,9 @@ public: static const char* getMaxVersionStrPrefix(); // Size of checksum in the current version - size_t checksumByteSize() const { return m_checksumSize; } + size_t checksumByteSize() const { + return m_checksumSize; + } // Update the current checksum value from the data // at |buf| of |bufLen| bytes. Once all buffers @@ -169,11 +177,7 @@ public: // Will reset the list of buffers by calling resetChecksum. bool validate(const void* expectedChecksum, size_t expectedChecksumLen); - // Snapshot support. - void save(android::base::Stream* stream); - void load(android::base::Stream* stream); - -private: + private: static constexpr size_t kVersion1ChecksumSize = 8; // 2 x uint32_t static_assert(kVersion1ChecksumSize <= kMaxChecksumLength, diff --git a/host/libs/virglrenderer/ChecksumCalculatorThreadInfo.h b/host/libs/virglrenderer/ChecksumCalculatorThreadInfo.h index e22d3bade..51f8e1c31 100644 --- a/host/libs/virglrenderer/ChecksumCalculatorThreadInfo.h +++ b/host/libs/virglrenderer/ChecksumCalculatorThreadInfo.h @@ -1,60 +1,45 @@ /* -* Copyright (C) 2016 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. -*/ + * Copyright (C) 2018 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 "ChecksumCalculator.h" -// ChecksumCalculatorThreadInfo is the class that makes ChecksumCalculator -// thread-safe. On the host, please only use ChecksumCalculator through this -// class. +#include <stdio.h> -class ChecksumCalculatorThreadInfo { -public: - ChecksumCalculatorThreadInfo(); - ~ChecksumCalculatorThreadInfo(); - - ChecksumCalculator& get(); +// NOTE: This fork of ChecksumCalculatorThreadInfo is *not* thread safe - static bool setVersion(uint32_t version); - - static uint32_t getMaxVersion(); - static const char* getMaxVersionString() { - return ChecksumCalculator::getMaxVersionStr(); +class ChecksumCalculatorThreadInfo { + public: + static bool writeChecksum(ChecksumCalculator* calc, void* buf, size_t bufLen, + void* outputChecksum, size_t outputChecksumLen) { + calc->addBuffer(buf, bufLen); + return calc->writeChecksum(outputChecksum, outputChecksumLen); } - static bool writeChecksum(ChecksumCalculator* calc, - void* buf, - size_t bufLen, - void* outputChecksum, - size_t outputChecksumLen); - - static bool validate(ChecksumCalculator* calc, - void* buf, - size_t bufLen, - void* checksum, - size_t checksumLen); - - static void validOrDie(ChecksumCalculator* calc, - void* buf, - size_t bufLen, - void* checksum, - size_t checksumLen, - const char* message); + static bool validate(ChecksumCalculator* calc, void* buf, size_t bufLen, void* checksum, + size_t checksumLen) { + calc->addBuffer(buf, bufLen); + return calc->validate(checksum, checksumLen); + } -private: - ChecksumCalculator m_protocol; + static void validOrDie(ChecksumCalculator* calc, void* buf, size_t bufLen, void* checksum, + size_t checksumLen, const char* message) { + if (!validate(calc, buf, bufLen, checksum, checksumLen)) { + printf("%s\n", message); + } + } }; diff --git a/host/libs/virglrenderer/Context.h b/host/libs/virglrenderer/Context.h new file mode 100644 index 000000000..53c5488cd --- /dev/null +++ b/host/libs/virglrenderer/Context.h @@ -0,0 +1,150 @@ +/* + * Copyright (C) 2018 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 + +#undef NDEBUG + +#include <cassert> +#include <condition_variable> +#include <cstdint> +#include <map> +#include <mutex> +#include <string> +#include <thread> + +#include "GLESv1.h" +#include "GLESv3.h" +#include "RenderControl.h" +#include "Resource.h" + +struct EglContext; +struct Context; + +typedef void (*PFNSUBMITCMD)(Context*, char*, size_t, int); + +struct Context { + static std::map<uint32_t, Context*> map; + + Context(uint32_t handle_, const char* name_, uint32_t nlen_, PFNSUBMITCMD pfnProcessCmd_, + EGLDisplay dpy_) + : render_control(this, dpy_), worker(), name(std::string(name_, nlen_)), handle(handle_), + pfnProcessCmd(pfnProcessCmd_) { + map.emplace(handle, this); + reset(); + } + + ~Context() { + { + std::lock_guard<std::mutex> lk(m); + killWorker = true; + } + cv.notify_one(); + if (worker.joinable()) + worker.join(); + map.erase(handle); + } + + Context* bind(EglContext* ctx_) { + for (auto const& it : Context::map) { + Context* ctx = it.second; + if (ctx == this) + continue; + if (ctx->ctx == ctx_) + return ctx; + } + ctx = ctx_; + return nullptr; + } + + void unbind() { + ctx = nullptr; + } + + void setPidTid(int pid_, int tid_) { + if (pid != pid_ && tid != tid_) { + assert(!worker.joinable() && "Changing pid/tid is not allowed"); + worker = std::thread(&Context::worker_func, this); + } + pid = pid_; + tid = tid_; + } + + void submitCommand(void* buf, size_t bufSize) { + char* cmdBufCopy = new char[bufSize]; + memcpy(cmdBufCopy, buf, bufSize); + { + std::lock_guard<std::mutex> lk(m); + cmdBufSize = bufSize; + cmdBuf = cmdBufCopy; + } + cv.notify_one(); + } + + void setFence(int fence_) { + { + std::lock_guard<std::mutex> lk(m); + fence = fence_; + if (!worker.joinable()) + processCmd(); + } + cv.notify_one(); + } + + std::map<uint32_t, Resource*> resource_map; + ChecksumCalculator checksum_calc; + RenderControl render_control; + Resource* cmd_resp = nullptr; + EglContext* ctx = nullptr; + std::thread worker; + std::string name; + uint32_t handle; + GLESv1 gles1; + GLESv3 gles3; + int pid = 0; + int tid = 0; + + private: + std::condition_variable cv; + PFNSUBMITCMD pfnProcessCmd; + bool killWorker = false; + size_t cmdBufSize; + char* cmdBuf; + std::mutex m; + int fence; + + void reset() { + cmdBuf = nullptr; + cmdBufSize = 0U; + fence = 0; + } + + void worker_func() { + while (!killWorker) { + std::unique_lock<std::mutex> lk(m); + cv.wait(lk, [this] { return killWorker || (cmdBuf && fence); }); + if (!killWorker) + processCmd(); + lk.unlock(); + } + } + + void processCmd() { + pfnProcessCmd(this, cmdBuf, cmdBufSize, fence); + delete cmdBuf; + reset(); + } +}; diff --git a/host/libs/virglrenderer/EglConfig.h b/host/libs/virglrenderer/EglConfig.h new file mode 100644 index 000000000..3b5cd2b49 --- /dev/null +++ b/host/libs/virglrenderer/EglConfig.h @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2018 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 <cstdint> +#include <vector> + +#include <EGL/egl.h> +#include <EGL/eglext.h> + +typedef EGLBoolean (*PFNEGLGETCONFIGATTRIB)(EGLDisplay, EGLConfig, EGLint, EGLint*); + +struct EglConfig { + static std::vector<EglConfig*> vec; + + // clang-format off + static constexpr EGLint kAttribs[] = { + EGL_DEPTH_SIZE, + EGL_STENCIL_SIZE, + EGL_RENDERABLE_TYPE, + EGL_SURFACE_TYPE, + EGL_CONFIG_ID, + EGL_BUFFER_SIZE, + EGL_ALPHA_SIZE, + EGL_BLUE_SIZE, + EGL_GREEN_SIZE, + EGL_RED_SIZE, + EGL_CONFIG_CAVEAT, + EGL_LEVEL, + EGL_MAX_PBUFFER_HEIGHT, + EGL_MAX_PBUFFER_PIXELS, + EGL_MAX_PBUFFER_WIDTH, + EGL_NATIVE_RENDERABLE, + EGL_NATIVE_VISUAL_ID, + EGL_NATIVE_VISUAL_TYPE, + 0x3030, // EGL_PRESERVED_RESOURCES + EGL_SAMPLES, + EGL_SAMPLE_BUFFERS, + EGL_TRANSPARENT_TYPE, + EGL_TRANSPARENT_BLUE_VALUE, + EGL_TRANSPARENT_GREEN_VALUE, + EGL_TRANSPARENT_RED_VALUE, + EGL_BIND_TO_TEXTURE_RGB, + EGL_BIND_TO_TEXTURE_RGBA, + EGL_MIN_SWAP_INTERVAL, + EGL_MAX_SWAP_INTERVAL, + EGL_LUMINANCE_SIZE, + EGL_ALPHA_MASK_SIZE, + EGL_COLOR_BUFFER_TYPE, + //EGL_MATCH_NATIVE_PIXMAP, + EGL_RECORDABLE_ANDROID, + EGL_CONFORMANT + }; + // clang-format on + + static constexpr size_t kNumAttribs = sizeof(kAttribs) / sizeof(kAttribs[0]); + + EglConfig(EGLDisplay dpy, EGLConfig config_, PFNEGLGETCONFIGATTRIB pfnEglGetConfigAttrib) + : config(config_) { + for (size_t a = 0; a < kNumAttribs; a++) { + if (!pfnEglGetConfigAttrib(dpy, config, kAttribs[a], &attribs[a])) + attribs[a] = 0; + } + vec.push_back(this); + } + + ~EglConfig() { + for (size_t i = 0; i < EglConfig::vec.size(); i++) { + if (vec[i] == this) { + vec.erase(vec.begin() + i); + break; + } + } + } + + EGLint attribs[kNumAttribs]; + EGLConfig config; +}; diff --git a/host/libs/virglrenderer/EglContext.h b/host/libs/virglrenderer/EglContext.h new file mode 100644 index 000000000..7283c08cd --- /dev/null +++ b/host/libs/virglrenderer/EglContext.h @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2018 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 <cstdint> +#include <map> + +#include <EGL/egl.h> + +struct EglContext { + enum GLESApi { + GLESApi_CM = 1, + GLESApi_2 = 2, + GLESApi_3_0 = 3, + GLESApi_3_1 = 4, + }; + + static std::map<uint32_t, EglContext*> map; + static uint32_t nextId; + + EglContext(EGLContext context_, uint32_t ctx_, GLESApi api_) + : create_ctx(ctx_), context(context_), api(api_), id(nextId++) { + map.emplace(id, this); + } + + ~EglContext() { + map.erase(id); + } + + EglContext* bind(uint32_t ctx_) { + for (auto const& it : EglContext::map) { + EglContext* ctx = it.second; + if (ctx == this) + continue; + if (ctx->bound_ctx == ctx_) + return ctx; + } + bound_ctx = ctx_; + return nullptr; + } + + void unbind() { + bound_ctx = 0U; + } + + bool disposable() { + return context == EGL_NO_CONTEXT && bound_ctx == 0U; + } + + uint32_t create_ctx; + EGLContext context; + enum GLESApi api; + uint32_t id; + + private: + uint32_t bound_ctx = 0U; +}; diff --git a/host/libs/virglrenderer/EglImage.h b/host/libs/virglrenderer/EglImage.h new file mode 100644 index 000000000..09b968c20 --- /dev/null +++ b/host/libs/virglrenderer/EglImage.h @@ -0,0 +1,45 @@ +/* + * Copyright (C) 2018 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 <cstdint> +#include <map> + +#include <EGL/egl.h> +#include <EGL/eglext.h> + +typedef EGLBoolean (*PFNEGLDESTROYIMAGEKHR)(EGLDisplay, EGLImageKHR); + +struct EglImage { + static std::map<uint32_t, EglImage*> map; + static uint32_t nextId; + + EglImage(EGLDisplay dpy_, EGLImageKHR image_, PFNEGLDESTROYIMAGEKHR pfnEglDestroyImageKHR_) + : pfnEglDestroyImageKHR(pfnEglDestroyImageKHR_), image(image_), dpy(dpy_), id(nextId++) { + map.emplace(id, this); + } + + ~EglImage() { + pfnEglDestroyImageKHR(dpy, image); + map.erase(id); + } + + PFNEGLDESTROYIMAGEKHR pfnEglDestroyImageKHR; + EGLImageKHR image; + EGLDisplay dpy; + uint32_t id; +}; diff --git a/host/libs/virglrenderer/EglSurface.h b/host/libs/virglrenderer/EglSurface.h new file mode 100644 index 000000000..4bb880dbb --- /dev/null +++ b/host/libs/virglrenderer/EglSurface.h @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2018 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 <cstdint> +#include <map> + +#include <EGL/egl.h> + +struct ANativeWindow; + +struct EglSurface { + static std::map<uint32_t, EglSurface*> map; + static uint32_t nextId; + + EglSurface(EGLConfig config_, uint32_t ctx_, uint32_t width_, uint32_t height_) + : create_ctx(ctx_), config(config_), height(height_), width(width_), id(nextId++) { + map.emplace(id, this); + } + + ~EglSurface() { + map.erase(id); + } + + EglSurface* bind(uint32_t ctx_, bool read_) { + for (auto const& it : EglSurface::map) { + EglSurface* sur = it.second; + if (sur == this) + continue; + if (sur->bound_ctx == ctx_) { + if (read_ && sur->read) + return sur; + if (!read_ && sur->draw) + return sur; + } + } + if (read_) { + read = true; + } else { + draw = true; + } + bound_ctx = ctx_; + return nullptr; + } + + void unbind(bool read_) { + if (read || draw) { + if (read_) + read = false; + else + draw = false; + if (read || draw) + return; + bound_ctx = 0U; + } + return; + } + + bool disposable() { + return surface == EGL_NO_SURFACE && bound_ctx == 0U; + } + + EGLSurface surface = EGL_NO_SURFACE; + ANativeWindow* window = nullptr; + uint32_t create_ctx; + EGLConfig config; + uint32_t height; + uint32_t width; + uint32_t id; + + private: + uint32_t bound_ctx = 0U; + bool draw = false; + bool read = false; +}; diff --git a/host/libs/virglrenderer/EglSync.h b/host/libs/virglrenderer/EglSync.h new file mode 100644 index 000000000..8dda71331 --- /dev/null +++ b/host/libs/virglrenderer/EglSync.h @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2018 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 <cstdint> +#include <map> + +#include <EGL/egl.h> + +struct EglSync { + static std::map<uint64_t, EglSync*> map; + static uint64_t nextId; + + EglSync(EGLSyncKHR sync_) : sync(sync_), id(nextId++) { + map.emplace(id, this); + } + + ~EglSync() { + map.erase(id); + } + + EGLSyncKHR sync; + uint64_t id; +}; diff --git a/host/libs/virglrenderer/GLESv1.cpp b/host/libs/virglrenderer/GLESv1.cpp new file mode 100644 index 000000000..17a7ae4b3 --- /dev/null +++ b/host/libs/virglrenderer/GLESv1.cpp @@ -0,0 +1,448 @@ +/* + * Copyright (C) 2018 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 <OpenGLESDispatch/GLESv1Dispatch.h> + +#include "GLESv1.h" + +// Stubs (common) + +static void glDeleteFencesNV(GLsizei, const GLuint*) { + printf("%s: not implemented\n", __func__); +} + +static void glDisableDriverControlQCOM(GLuint) { + printf("%s: not implemented\n", __func__); +} + +static void glDiscardFramebufferEXT(GLenum, GLsizei, const GLenum*) { + printf("%s: not implemented\n", __func__); +} + +static void glEnableDriverControlQCOM(GLuint) { + printf("%s: not implemented\n", __func__); +} + +static void glEndTilingQCOM(GLbitfield) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetBufferPointervQCOM(GLenum, GLvoid**) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetBuffersQCOM(GLuint*, GLint, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetFramebuffersQCOM(GLuint*, GLint, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetProgramBinarySourceQCOM(GLuint, GLenum, GLchar*, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetProgramsQCOM(GLuint*, GLint, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetRenderbuffersQCOM(GLuint*, GLint, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetShadersQCOM(GLuint*, GLint, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetTexLevelParameterivQCOM(GLuint, GLenum, GLint, GLenum, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetTexSubImageQCOM(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, + GLenum, GLenum, GLvoid*) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetTexturesQCOM(GLuint*, GLint, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static GLboolean glExtIsProgramBinaryQCOM(GLuint) { + printf("%s: not implemented\n", __func__); + return GL_FALSE; +} + +static void glExtTexObjectStateOverrideiQCOM(GLenum, GLenum, GLint) { + printf("%s: not implemented\n", __func__); +} + +static void glFinishFenceNV(GLuint) { + printf("%s: not implemented\n", __func__); +} + +static void glFramebufferTexture2DMultisampleIMG(GLenum, GLenum, GLenum, GLuint, GLint, GLsizei) { + printf("%s: not implemented\n", __func__); +} + +static void glGenFencesNV(GLsizei, GLuint*) { + printf("%s: not implemented\n", __func__); +} + +static void glGetDriverControlsQCOM(GLint*, GLsizei, GLuint*) { + printf("%s: not implemented\n", __func__); +} + +static void glGetDriverControlStringQCOM(GLuint, GLsizei, GLsizei*, GLchar*) { + printf("%s: not implemented\n", __func__); +} + +static void glGetFenceivNV(GLuint, GLenum, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static GLboolean glIsFenceNV(GLuint) { + printf("%s: not implemented\n", __func__); + return GL_FALSE; +} + +static void* glMapBufferOES(GLenum, GLenum) { + printf("%s: not implemented\n", __func__); + return nullptr; +} + +static void glMultiDrawArraysEXT(GLenum, const GLint*, const GLsizei*, GLsizei) { + printf("%s: not implemented\n", __func__); +} + +static void glMultiDrawElementsEXT(GLenum, const GLsizei*, GLenum, const GLvoid* const*, GLsizei) { + printf("%s: not implemented\n", __func__); +} + +static void glRenderbufferStorageMultisampleIMG(GLenum, GLsizei, GLenum, GLsizei, GLsizei) { + printf("%s: not implemented\n", __func__); +} + +static void glSetFenceNV(GLuint, GLenum) { + printf("%s: not implemented\n", __func__); +} + +static void glStartTilingQCOM(GLuint, GLuint, GLuint, GLuint, GLbitfield) { + printf("%s: not implemented\n", __func__); +} + +static GLboolean glTestFenceNV(GLuint) { + printf("%s: not implemented\n", __func__); + return GL_FALSE; +} + +// Stubs (ES 1.1) + +static void glBindVertexArrayOES(GLuint) { + printf("%s: not implemented\n", __func__); +} + +static void glCurrentPaletteMatrixOES(GLuint) { + printf("%s: not implemented\n", __func__); +} + +static void glDeleteVertexArraysOES(GLsizei, const GLuint*) { + printf("%s: not implemented\n", __func__); +} + +static void glGenVertexArraysOES(GLsizei, GLuint*) { + printf("%s: not implemented\n", __func__); +} + +static void glGetBufferPointervOES(GLenum, GLenum, GLvoid**) { + printf("%s: not implemented\n", __func__); +} + +static void glGetTexGenfvOES(GLenum, GLenum, GLfloat*) { + printf("%s: not implemented\n", __func__); +} + +static void glGetTexGenivOES(GLenum, GLenum, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static void glGetTexGenxvOES(GLenum, GLenum, GLfixed*) { + printf("%s: not implemented\n", __func__); +} + +static GLboolean glIsVertexArrayOES(GLuint) { + printf("%s: not implemented\n", __func__); + return GL_FALSE; +} + +static void glLoadPaletteFromModelViewMatrixOES() { + printf("%s: not implemented\n", __func__); +} + +static void glMatrixIndexPointerData(GLint, GLenum, GLsizei, void*, GLuint) { + printf("%s: not implemented\n", __func__); +} + +static void glMatrixIndexPointerOffset(GLint, GLenum, GLsizei, GLuint) { + printf("%s: not implemented\n", __func__); +} + +static void glMultiDrawArraysSUN(GLenum, GLint*, GLsizei*, GLsizei) { + printf("%s: not implemented\n", __func__); +} + +static void glMultiDrawElementsSUN(GLenum, const GLsizei*, GLenum, const GLvoid**, GLsizei) { + printf("%s: not implemented\n", __func__); +} + +static GLbitfield glQueryMatrixxOES(GLfixed*, GLint*) { + printf("%s: not implemented\n", __func__); + return 0; +} + +static void glTexGenfOES(GLenum, GLenum, GLfloat) { + printf("%s: not implemented\n", __func__); +} + +static void glTexGenfvOES(GLenum, GLenum, const GLfloat*) { + printf("%s: not implemented\n", __func__); +} + +static void glTexGeniOES(GLenum, GLenum, GLint) { + printf("%s: not implemented\n", __func__); +} + +static void glTexGenivOES(GLenum, GLenum, const GLint*) { + printf("%s: not implemented\n", __func__); +} + +static void glTexGenxOES(GLenum, GLenum, GLfixed) { + printf("%s: not implemented\n", __func__); +} + +static void glTexGenxvOES(GLenum, GLenum, const GLfixed*) { + printf("%s: not implemented\n", __func__); +} + +static GLboolean glUnmapBufferOES(GLenum) { + printf("%s: not implemented\n", __func__); + return GL_FALSE; +} + +static void glWeightPointerData(GLint, GLenum, GLsizei, void*, GLuint) { + printf("%s: not implemented\n", __func__); +} + +static void glWeightPointerOffset(GLint, GLenum, GLsizei, GLuint) { + printf("%s: not implemented\n", __func__); +} + +// Non-stubs (common) + +static void glDrawElementsData(GLenum mode, GLsizei count, GLenum type, void* indices, GLuint) { + s_gles1.glDrawElements(mode, count, type, indices); +} + +static void glDrawElementsOffset(GLenum mode, GLsizei count, GLenum type, GLuint offset) { + s_gles1.glDrawElements(mode, count, type, reinterpret_cast<const GLvoid*>(offset)); +} + +static GLint glFinishRoundTrip() { + s_gles1.glFinish(); + return 0; +} + +static void glGetCompressedTextureFormats(int count, GLint* formats) { + int nFormats; + s_gles1.glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &nFormats); + if (nFormats <= count) + s_gles1.glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, formats); +} + +// Non-stubs (ES 1.1) + +static void glColorPointerData(GLint size, GLenum type, GLsizei, void* data, GLuint) { + s_gles1.glColorPointer(size, type, 0, data); +} + +static void glColorPointerOffset(GLint size, GLenum type, GLsizei, GLuint offset) { + s_gles1.glColorPointer(size, type, 0, reinterpret_cast<GLvoid*>(offset)); +} + +static void glNormalPointerData(GLenum type, GLsizei, void* data, GLuint) { + s_gles1.glNormalPointer(type, 0, data); +} + +static void glNormalPointerOffset(GLenum type, GLsizei, GLuint offset) { + s_gles1.glNormalPointer(type, 0, reinterpret_cast<GLvoid*>(offset)); +} + +static void glPointSizePointerData(GLenum type, GLsizei, void* data, GLuint) { + s_gles1.glPointSizePointerOES(type, 0, data); +} + +static void glPointSizePointerOffset(GLenum type, GLsizei, GLuint offset) { + s_gles1.glPointSizePointerOES(type, 0, reinterpret_cast<GLvoid*>(offset)); +} + +static void glTexCoordPointerData(GLint, GLint size, GLenum type, GLsizei, void* data, GLuint) { + // FIXME: unit? + s_gles1.glTexCoordPointer(size, type, 0, data); +} + +static void glTexCoordPointerOffset(GLint size, GLenum type, GLsizei, GLuint offset) { + s_gles1.glTexCoordPointer(size, type, 0, reinterpret_cast<GLvoid*>(offset)); +} + +static void glVertexPointerData(GLint size, GLenum type, GLsizei, void* data, GLuint) { + s_gles1.glVertexPointer(size, type, 0, data); +} + +static void glVertexPointerOffset(GLint size, GLenum type, GLsizei, GLuint offset) { + s_gles1.glVertexPointer(size, type, 0, reinterpret_cast<GLvoid*>(offset)); +} + +#define KNIT(return_type, function_name, signature, callargs) function_name = s_gles1.function_name; + +GLESv1::GLESv1() { + LIST_GLES1_FUNCTIONS(KNIT, KNIT) + + // Remap some ES 1.0 extensions that become core in ES 1.1 + glAlphaFuncxOES = glAlphaFuncx; + glClearColorxOES = glClearColorx; + glClearDepthfOES = glClearDepthf; + glClearDepthxOES = glClearDepthx; + glClipPlanefIMG = glClipPlanef; + glClipPlanefOES = glClipPlanef; + glClipPlanexIMG = glClipPlanex; + glClipPlanexOES = glClipPlanex; + glColor4xOES = glColor4x; + glDepthRangefOES = glDepthRangef; + glDepthRangexOES = glDepthRangex; + glFogxOES = glFogx; + glFogxvOES = glFogxv; + glFrustumfOES = glFrustumf; + glFrustumxOES = glFrustumx; + glGetClipPlanefOES = glGetClipPlanef; + glGetClipPlanexOES = glGetClipPlanex; + glGetFixedvOES = glGetFixedv; + glGetLightxvOES = glGetLightxv; + glGetMaterialxvOES = glGetMaterialxv; + glGetTexEnvxvOES = glGetTexEnvxv; + glGetTexParameterxvOES = glGetTexParameterxv; + glLightModelxOES = glLightModelx; + glLightModelxvOES = glLightModelxv; + glLightxOES = glLightx; + glLightxvOES = glLightxv; + glLineWidthxOES = glLineWidthx; + glLoadMatrixxOES = glLoadMatrixx; + glMaterialxOES = glMaterialx; + glMaterialxvOES = glMaterialxv; + glMultiTexCoord4xOES = glMultiTexCoord4x; + glMultMatrixxOES = glMultMatrixx; + glNormal3xOES = glNormal3x; + glOrthofOES = glOrthof; + glOrthoxOES = glOrthox; + glPointParameterxOES = glPointParameterx; + glPointParameterxvOES = glPointParameterxv; + glPointSizexOES = glPointSizex; + glPolygonOffsetxOES = glPolygonOffsetx; + glRotatexOES = glRotatex; + glSampleCoveragexOES = glSampleCoveragex; + glScalexOES = glScalex; + glTexEnvxOES = glTexEnvx; + glTexEnvxvOES = glTexEnvxv; + glTexParameterxOES = glTexParameterx; + glTexParameterxvOES = glTexParameterxv; + glTranslatexOES = glTranslatex; + + // Entrypoints requiring custom wrappers (common) + glDrawElementsData = ::glDrawElementsData; + glDrawElementsOffset = ::glDrawElementsOffset; + glFinishRoundTrip = ::glFinishRoundTrip; + glGetCompressedTextureFormats = ::glGetCompressedTextureFormats; + + // Entrypoints requiring custom wrappers (ES 1.1) + glColorPointerData = ::glColorPointerData; + glColorPointerOffset = ::glColorPointerOffset; + glNormalPointerData = ::glNormalPointerData; + glNormalPointerOffset = ::glNormalPointerOffset; + glPointSizePointerData = ::glPointSizePointerData; + glPointSizePointerOffset = ::glPointSizePointerOffset; + glTexCoordPointerData = ::glTexCoordPointerData; + glTexCoordPointerOffset = ::glTexCoordPointerOffset; + glVertexPointerData = ::glVertexPointerData; + glVertexPointerOffset = ::glVertexPointerOffset; + + // Stub some extensions we will never implement (common) + glDeleteFencesNV = ::glDeleteFencesNV; + glDisableDriverControlQCOM = ::glDisableDriverControlQCOM; + glDiscardFramebufferEXT = ::glDiscardFramebufferEXT; + glEnableDriverControlQCOM = ::glEnableDriverControlQCOM; + glEndTilingQCOM = ::glEndTilingQCOM; + glExtGetBufferPointervQCOM = ::glExtGetBufferPointervQCOM; + glExtGetBuffersQCOM = ::glExtGetBuffersQCOM; + glExtGetFramebuffersQCOM = ::glExtGetFramebuffersQCOM; + glExtGetProgramBinarySourceQCOM = ::glExtGetProgramBinarySourceQCOM; + glExtGetProgramsQCOM = ::glExtGetProgramsQCOM; + glExtGetRenderbuffersQCOM = ::glExtGetRenderbuffersQCOM; + glExtGetShadersQCOM = ::glExtGetShadersQCOM; + glExtGetTexLevelParameterivQCOM = ::glExtGetTexLevelParameterivQCOM; + glExtGetTexSubImageQCOM = ::glExtGetTexSubImageQCOM; + glExtGetTexturesQCOM = ::glExtGetTexturesQCOM; + glExtIsProgramBinaryQCOM = ::glExtIsProgramBinaryQCOM; + glExtTexObjectStateOverrideiQCOM = ::glExtTexObjectStateOverrideiQCOM; + glFinishFenceNV = ::glFinishFenceNV; + glFramebufferTexture2DMultisampleIMG = ::glFramebufferTexture2DMultisampleIMG; + glGenFencesNV = ::glGenFencesNV; + glGetDriverControlsQCOM = ::glGetDriverControlsQCOM; + glGetDriverControlStringQCOM = ::glGetDriverControlStringQCOM; + glGetFenceivNV = ::glGetFenceivNV; + glIsFenceNV = ::glIsFenceNV; + glMapBufferOES = ::glMapBufferOES; + glMultiDrawArraysEXT = ::glMultiDrawArraysEXT; + glMultiDrawElementsEXT = ::glMultiDrawElementsEXT; + glRenderbufferStorageMultisampleIMG = ::glRenderbufferStorageMultisampleIMG; + glSetFenceNV = ::glSetFenceNV; + glStartTilingQCOM = ::glStartTilingQCOM; + glTestFenceNV = ::glTestFenceNV; + + // Stub some extensions we will never implement (ES 1.1) + glBindVertexArrayOES = ::glBindVertexArrayOES; + glCurrentPaletteMatrixOES = ::glCurrentPaletteMatrixOES; + glDeleteVertexArraysOES = ::glDeleteVertexArraysOES; + glGenVertexArraysOES = ::glGenVertexArraysOES; + glGetBufferPointervOES = ::glGetBufferPointervOES; + glGetTexGenfvOES = ::glGetTexGenfvOES; + glGetTexGenivOES = ::glGetTexGenivOES; + glGetTexGenxvOES = ::glGetTexGenxvOES; + glIsVertexArrayOES = ::glIsVertexArrayOES; + glLoadPaletteFromModelViewMatrixOES = ::glLoadPaletteFromModelViewMatrixOES; + glMatrixIndexPointerData = ::glMatrixIndexPointerData; + glMatrixIndexPointerOffset = ::glMatrixIndexPointerOffset; + glMultiDrawArraysSUN = ::glMultiDrawArraysSUN; + glMultiDrawElementsSUN = ::glMultiDrawElementsSUN; + glQueryMatrixxOES = ::glQueryMatrixxOES; + glTexGenfOES = ::glTexGenfOES; + glTexGenfvOES = ::glTexGenfvOES; + glTexGeniOES = ::glTexGeniOES; + glTexGenivOES = ::glTexGenivOES; + glTexGenxOES = ::glTexGenxOES; + glTexGenxvOES = ::glTexGenxvOES; + glUnmapBufferOES = ::glUnmapBufferOES; + glWeightPointerData = ::glWeightPointerData; + glWeightPointerOffset = ::glWeightPointerOffset; +} diff --git a/host/libs/virglrenderer/GLESv1.h b/host/libs/virglrenderer/GLESv1.h new file mode 100644 index 000000000..f8b90732b --- /dev/null +++ b/host/libs/virglrenderer/GLESv1.h @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2018 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 "GLESv1_dec/gles1_dec.h" + +struct GLESv1 : public gles1_decoder_context_t { + GLESv1(); +}; diff --git a/host/libs/virglrenderer/GLESv1_dec/gles1.attrib b/host/libs/virglrenderer/GLESv1_dec/gles1.attrib index 3cbc9d37e..a1f1ee769 100644 --- a/host/libs/virglrenderer/GLESv1_dec/gles1.attrib +++ b/host/libs/virglrenderer/GLESv1_dec/gles1.attrib @@ -1,704 +1,444 @@ GLOBAL - base_opcode 1024 - encoder_headers "glUtils.h" "GLEncoderUtils.h" - -#void glClipPlanef(GLenum plane, GLfloat *equation) -glClipPlanef - dir equation in - len equation (4 * sizeof(float)) + base_opcode 1024 -#void glFogfv(GLenum pname, GLfloat *params) -glFogfv - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) +glClipPlanef + dir equation in + len equation (4 * sizeof(float)) -#void glGetFloatv(GLenum pname, GLfloat *params) glGetFloatv - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) + dir params out -#void glGetLightfv(GLenum light, GLenum pname, GLfloat *params) glGetLightfv - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) + dir params out -#void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params) glGetMaterialfv - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) + dir params out -#void glGetTexEnvfv(GLenum env, GLenum pname, GLfloat *params) glGetTexEnvfv - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) + dir params out -#void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) glGetTexParameterfv - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) - -#void glLightModelfv(GLenum pname, GLfloat *params) -glLightModelfv - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) + dir params out -#void glLightfv(GLenum light, GLenum pname, GLfloat *params) -glLightfv - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) - -#void glLoadMatrixf(GLfloat *m) glLoadMatrixf - len m (16 * sizeof(GLfloat)) - -#void glMaterialfv(GLenum face, GLenum pname, GLfloat *params) -glMaterialfv - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) + len m (16 * sizeof(GLfloat)) -#void glMultMatrixf(GLfloat *m) glMultMatrixf - len m (16 * sizeof(GLfloat)) + len m (16 * sizeof(GLfloat)) -#void glPointParameterfv(GLenum pname, GLfloat *params) -glPointParameterfv - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) - -#void glTexEnvfv(GLenum target, GLenum pname, GLfloat *params) -glTexEnvfv - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) - -#void glTexParameterfv(GLenum target, GLenum pname, GLfloat *params) -glTexParameterfv - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) - -#void glBufferData(GLenum target, GLsizeiptr size, GLvoid *data, GLenum usage) glBufferData - len data size - var_flag data nullAllowed + len data size + var_flag data nullAllowed -#void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data) glBufferSubData - dir data in - len data size - var_flag data nullAllowed + dir data in + len data size + var_flag data nullAllowed -#void glClipPlanex(GLenum plane, GLfixed *eqn) glClipPlanex - dir eqn in - len eqn (4 * sizeof(GLfixed)) + dir eqn in + len eqn (4 * sizeof(GLfixed)) -#void glColorPointer(GLint size, GLenum type, GLsizei stride, GLvoid *pointer) -#we treat the pointer as offset to a VBO glColorPointer - len pointer (sizeof(unsigned int)) - flag unsupported + len pointer (sizeof(unsigned int)) + flag unsupported -#void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, GLvoid *data) glCompressedTexImage2D - len data imageSize + len data imageSize var_flag data nullAllowed -#void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLvoid *data) glCompressedTexSubImage2D - len data imageSize + len data imageSize var_flag data nullAllowed -#void glDeleteBuffers(GLsizei n, GLuint *buffers) glDeleteBuffers - flag custom_decoder - len buffers (n * sizeof(GLuint)) - param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } + len buffers (n * sizeof(GLuint)) + param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glDeleteTextures(GLsizei n, GLuint *textures) glDeleteTextures - flag custom_decoder - len textures (n * sizeof(GLuint)) - param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } + len textures (n * sizeof(GLuint)) + param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#this function is marked as unsupported - it shouldn't be called directly -#instead it translated into - glDrawDirectElements and glDrawIndirectElements -#void glDrawElements(GLenum mode, GLsizei count, GLenum type, GLvoid *indices) glDrawElements - flag unsupported - - -#void glFogxv(GLenum pname, GLfixed *params) -glFogxv - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + flag unsupported -#void glGetBooleanv(GLenum pname, GLboolean *params) glGetBooleanv - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLboolean)) + dir params out -#void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params) glGetBufferParameteriv - len params (sizeof(GLint)) - dir params out + len params (sizeof(GLint)) + dir params out -#void glGenBuffers(GLsizei n, GLuint *buffers) glGenBuffers - flag custom_decoder - len buffers (n * sizeof(GLuint)) - dir buffers out - param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } + len buffers (n * sizeof(GLuint)) + dir buffers out + param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glGenTextures(GLsizei n, GLuint *textures) glGenTextures - flag custom_decoder - len textures (n * sizeof(GLuint)) - dir textures out - param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } + len textures (n * sizeof(GLuint)) + dir textures out + param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glGetFixedv(GLenum pname, GLfixed *params) glGetFixedv - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + dir params out -#void glGetIntegerv(GLenum pname, GLint *params) glGetIntegerv - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLint)) + dir params out -#void glGetLightxv(GLenum light, GLenum pname, GLfixed *params) glGetLightxv - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + dir params out -#void glGetMaterialxv(GLenum face, GLenum pname, GLfixed *params) glGetMaterialxv - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + dir params out -#void glGetPointerv(GLenum pname, void **params) glGetPointerv - flag unsupported + flag unsupported -#GLubyte* glGetString(GLenum name) glGetString - flag unsupported + flag unsupported -#void glGetTexEnviv(GLenum env, GLenum pname, GLint *params) glGetTexEnviv - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLint)) + dir params out -#void glGetTexEnvxv(GLenum env, GLenum pname, GLfixed *params) glGetTexEnvxv - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + dir params out -#void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params) glGetTexParameteriv - dir params out - len params (sizeof(GLint)) + dir params out + len params (sizeof(GLint)) -#void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params) glGetTexParameterxv - dir params out - len params (sizeof(GLfixed)) - -#void glLightModelxv(GLenum pname, GLfixed *params) -glLightModelxv - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) - -#void glLightxv(GLenum light, GLenum pname, GLfixed *params) -glLightxv - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + dir params out + len params (sizeof(GLfixed)) -#void glLoadMatrixx(GLfixed *m) glLoadMatrixx - len m (16 * sizeof(GLfixed)) + len m (16 * sizeof(GLfixed)) -#void glMaterialxv(GLenum face, GLenum pname, GLfixed *params) -glMaterialxv - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) - -#void glMultMatrixx(GLfixed *m) glMultMatrixx - len m (16 * sizeof(GLfixed)) + len m (16 * sizeof(GLfixed)) -#void glNormalPointer(GLenum type, GLsizei stride, GLvoid *pointer) -#we treat the pointer as an offset to a VBO glNormalPointer - len pointer (sizeof(unsigned int)) - flag unsupported - -#void glPointParameterxv(GLenum pname, GLfixed *params) -glPointParameterxv - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + len pointer (sizeof(unsigned int)) + flag unsupported -#void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) glReadPixels - dir pixels out - len pixels glesv1_enc::pixelDataSize(self, width, height, format, type, 1) + dir pixels out + len pixels glesv1_enc::pixelDataSize(self, width, height, format, type, 1) -#void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, GLvoid *pointer) glTexCoordPointer - len pointer (sizeof(unsigned int)) - flag unsupported - -#void glTexEnviv(GLenum target, GLenum pname, GLint *params) -glTexEnviv - len params (glUtilsParamSize(pname) * sizeof(GLint)) - -#void glTexEnvxv(GLenum target, GLenum pname, GLfixed *params) -glTexEnvxv - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + len pointer (sizeof(unsigned int)) + flag unsupported -#void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLvoid *pixels) glTexImage2D - dir pixels in - len pixels glesv1_enc::pixelDataSize(self, width, height, format, type, 0) - var_flag pixels nullAllowed isLarge + dir pixels in + len pixels glesv1_enc::pixelDataSize(self, width, height, format, type, 0) + var_flag pixels nullAllowed isLarge -#void glTexParameteriv(GLenum target, GLenum pname, GLint *params) -glTexParameteriv - len params (glUtilsParamSize(pname) * sizeof(GLint)) - -#void glTexParameterxv(GLenum target, GLenum pname, GLfixed *params) -glTexParameterxv - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) - -#void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) glTexSubImage2D - len pixels glesv1_enc::pixelDataSize(self, width, height, format, type, 0) - var_flag pixels nullAllowed isLarge + len pixels glesv1_enc::pixelDataSize(self, width, height, format, type, 0) + var_flag pixels nullAllowed isLarge -#void glVertexPointer(GLint size, GLenum type, GLsizei stride, GLvoid *pointer) -# we treat the pointer as an offset to a VBO glVertexPointer - flag unsupported + flag unsupported -#void glPointSizePointerOES(GLenum type, GLsizei stride, GLvoid *pointer) glPointSizePointerOES - len pointer (sizeof(unsigned int)) - flag unsupported + len pointer (sizeof(unsigned int)) + flag unsupported -#void glGetClipPlanef(GLenum pname, GLfloat * eqn) glGetClipPlanef - dir eqn out - len eqn (4 * sizeof(GLfloat)) + dir eqn out + len eqn (4 * sizeof(GLfloat)) -#void glVertexPointerData(GLint size, GLenum type, GLsizei stride, void *data, GLuint datalen) glVertexPointerData - len data datalen - custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen) - flag custom_decoder - flag not_api + len data datalen + flag not_api -#void glColorPointerData(GLint size, GLenum type, GLsizei stride, void *data, GLuint datalen) glColorPointerData - len data datalen - flag custom_decoder - custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen) - flag not_api + len data datalen + flag not_api -#void glNormalPointerData(GLenum type, GLsizei stride, void *data, GLuint datalen) glNormalPointerData - len data datalen - flag custom_decoder - custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, 3, type, stride, datalen) - flag not_api + len data datalen + flag not_api -#void glPointSizePointerData(GLenum type, GLsizei stride, void *data, GLuint datalen) glPointSizePointerData - len data datalen - flag custom_decoder - custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, 1, type, stride, datalen) - flag not_api + len data datalen + flag not_api -#void glTexCoordPointerData(GLint size, GLenum type, GLsizei stride, void *data, GLuint datalen) glTexCoordPointerData - len data datalen - flag custom_decoder - custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen) - flag not_api + len data datalen + flag not_api -#void glWeightPointerData(GLint size, GLenum type, GLsizei stride, void * data, GLuint datalen) glWeightPointerData - len data datalen - custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char*)data, size, type, stride, datalen) - flag custom_decoder - flag not_api + len data datalen + flag not_api -#void glMatrixIndexPointerData(GLint size, GLenum type, GLsizei stride, void * data, GLuint datalen) glMatrixIndexPointerData - len data datalen - custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char*)data, size, type, stride, datalen) - flag custom_decoder - flag not_api + len data datalen + flag not_api glVertexPointerOffset - flag custom_decoder - flag not_api + flag not_api + glNormalPointerOffset - flag custom_decoder - flag not_api + flag not_api + glTexCoordPointerOffset - flag custom_decoder - flag not_api + flag not_api + glPointSizePointerOffset - flag custom_decoder - flag not_api + flag not_api + glColorPointerOffset - flag custom_decoder - flag not_api + flag not_api + glWeightPointerOffset - flag custom_decoder - flag not_api + flag not_api + glMatrixIndexPointerOffset - flag custom_decoder - flag not_api + flag not_api glDrawElementsData - len data datalen - flag custom_decoder - flag not_api + len data datalen + flag not_api glDrawElementsOffset - flag custom_decoder - flag not_api + flag not_api glGetCompressedTextureFormats - dir formats out - len formats (count * sizeof(GLint)) - flag custom_decoder - flag not_api + dir formats out + len formats (count * sizeof(GLint)) + flag not_api glFinishRoundTrip - flag custom_decoder - flag not_api - -#gles1 extensions + flag not_api -#void glDrawTexsvOES(GLshort *coords) glDrawTexsvOES - len coords (5 * sizeof(GLshort)) + len coords (5 * sizeof(GLshort)) -#void glDrawTexivOES(GLint *coords) glDrawTexivOES - len coords (5 * sizeof(GLint)) + len coords (5 * sizeof(GLint)) -#void glDrawTexxvOES(GLfixed *coords) glDrawTexxvOES - len coords (5 * sizeof(GLfixed)) + len coords (5 * sizeof(GLfixed)) -#void glDrawTexfvOES(GLfloat *coords) glDrawTexfvOES - len coords (5 * sizeof(GLfloat)) + len coords (5 * sizeof(GLfloat)) -#glClipPlanexOES(GLenum plane, const GLfixed * equation) glClipPlanexOES - dir equation in - len equation (4 * sizeof(GLfixed)) + dir equation in + len equation (4 * sizeof(GLfixed)) -#glClipPlanexIMG(GLenum plane, const GLfixed * equation) glClipPlanexIMG - dir equation in - len equation (4 * sizeof(GLfixed)) + dir equation in + len equation (4 * sizeof(GLfixed)) -#void glFogxvOES(GLenum pname, GLfixed *params) glFogxvOES - dir params in - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + dir params in -#void glGetClipPlanexOES(GLenum pname, GLfixed * eqn) glGetClipPlanexOES - dir eqn out - len eqn (4 * sizeof(GLfixed)) + dir eqn out + len eqn (4 * sizeof(GLfixed)) -#void glGetClipPlanex(GLenum pname, GLfixed * eqn) glGetClipPlanex - dir eqn out - len eqn (4 * sizeof(GLfixed)) + dir eqn out + len eqn (4 * sizeof(GLfixed)) -#void glGetFixedvOES(GLenum pname, GLfixed *params) glGetFixedvOES - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + dir params out -#void glGetLightxvOES(GLenum light, GLenum pname, GLfixed *params) glGetLightxvOES - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + dir params out -#void glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed *params) glGetMaterialxvOES - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + dir params out -#void glGetTexEnvxvOES(GLenum env, GLenum pname, GLfixed *params) glGetTexEnvxvOES - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + dir params out -#void glGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed *params) glGetTexParameterxvOES - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + dir params out -#void glLightModelxvOES(GLenum pname, GLfixed *params) glLightModelxvOES - dir params in - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + dir params in -#void glLightxvOES(GLenum light, GLenum pname, GLfixed *params) glLightxvOES - dir params in - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + dir params in -#void glLoadMatrixxOES(GLfixed *m) glLoadMatrixxOES - dir m in - len m (16 * sizeof(GLfixed)) + dir m in + len m (16 * sizeof(GLfixed)) -#void glMaterialxvOES(GLenum face, GLenum pname, GLfixed *params) glMaterialxvOES - dir params in - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + dir params in -#void glMultMatrixxOES(GLfixed *m) glMultMatrixxOES - dir m in - len m (16 * sizeof(GLfixed)) + dir m in + len m (16 * sizeof(GLfixed)) -#void glPointParameterxvOES(GLenum pname, GLfixed *params) glPointParameterxvOES - dir params in - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + dir params in -#void glTexEnvxvOES(GLenum target, GLenum pname, GLfixed *params) glTexEnvxvOES - dir params in - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + dir params in -#void glTexParameterxvOES(GLenum target, GLenum pname, GLfixed *params) glTexParameterxvOES - dir params in - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) + dir params in -#void glDeleteRenderbuffersOES(GLsizei n, GLuint *renderbuffers) glDeleteRenderbuffersOES - flag custom_decoder - dir renderbuffers in - len renderbuffers (n * sizeof(GLuint)) - param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } + dir renderbuffers in + len renderbuffers (n * sizeof(GLuint)) + param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glGenRenderbuffersOES(GLsizei n, GLuint *renderbuffers) glGenRenderbuffersOES - flag custom_decoder - dir renderbuffers out - len renderbuffers (n * sizeof(GLuint)) - param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } + dir renderbuffers out + len renderbuffers (n * sizeof(GLuint)) + param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint *params) glGetRenderbufferParameterivOES - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLint)) + dir params out -#void glDeleteFramebuffersOES(GLsizei n, GLuint *framebuffers) glDeleteFramebuffersOES - flag custom_decoder - dir framebuffers in - len framebuffers (n * sizeof(GLuint)) - param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } + dir framebuffers in + len framebuffers (n * sizeof(GLuint)) + param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glGenFramebuffersOES(GLsizei n, GLuint *framebuffers) glGenFramebuffersOES - flag custom_decoder - dir framebuffers out - len framebuffers (n * sizeof(GLuint)) - param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } + dir framebuffers out + len framebuffers (n * sizeof(GLuint)) + param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint *params) glGetFramebufferAttachmentParameterivOES - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLint)) + dir params out -#void* glMapBufferOES(GLenum target, GLenum access) glMapBufferOES - flag unsupported + flag unsupported -#void glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid ** params) glGetBufferPointervOES - flag unsupported + flag unsupported -#void glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, GLvoid *pointer) glMatrixIndexPointerOES - len pointer (sizeof(unsigned int)) - flag unsupported + len pointer (sizeof(unsigned int)) + flag unsupported -#void glWeightPointerOES(GLint size, GLenum type, GLsizei stride, GLvoid *pointer) glWeightPointerOES - len pointer (sizeof(unsigned int)) - flag unsupported + len pointer (sizeof(unsigned int)) + flag unsupported -#glQueryMatrixxOES(GLfixed * mantissa, GLint * exponent) glQueryMatrixxOES - dir mantissa out - len mantissa (16 * sizeof(GLfixed)) - dir exponent out - len exponent (16 * sizeof(GLfixed)) + dir mantissa out + len mantissa (16 * sizeof(GLfixed)) + dir exponent out + len exponent (16 * sizeof(GLfixed)) -#void glClipPlanefOES(GLenum plane, GLfloat *equation) glClipPlanefOES - dir equation in - len equation (4 * sizeof(GLfloat)) + dir equation in + len equation (4 * sizeof(GLfloat)) -#void glClipPlanefIMG(GLenum plane, GLfloat *equation) glClipPlanefIMG - dir equation in - len equation (4 * sizeof(GLfloat)) + dir equation in + len equation (4 * sizeof(GLfloat)) -#void glGetClipPlanefOES(GLenum pname, GLfloat * eqn) glGetClipPlanefOES - dir eqn out - len eqn (4 * sizeof(GLfloat)) + dir eqn out + len eqn (4 * sizeof(GLfloat)) -#void glTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params) -glTexGenfvOES - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) - -#void glTexGenivOES(GLenum coord, GLenum pname, GLint *params) -glTexGenivOES - len params (glUtilsParamSize(pname) * sizeof(GLint)) - -#void glTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params) -glTexGenxvOES - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) - -#void glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params) -glGetTexGenfvOES - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) - -#void glGetTexGenivOES(GLenum coord, GLenum pname, GLint *params) -glGetTexGenivOES - len params (glUtilsParamSize(pname) * sizeof(GLint)) - -#void glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params) -glGetTexGenxvOES - len params (glUtilsParamSize(pname) * sizeof(GLfixed)) - -#void glDeleteVertexArraysOES(GLsizei n, const GLuint *arrays) glDeleteVertexArraysOES - flag custom_decoder - dir arrays in - len arrays (n * sizeof(GLuint)) - param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } + dir arrays in + len arrays (n * sizeof(GLuint)) + param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glGenVertexArraysOES(GLsizei n, GLuint *arrays) glGenVertexArraysOES - flag custom_decoder - dir arrays out - len arrays (n * sizeof(GLuint)) - param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } + dir arrays out + len arrays (n * sizeof(GLuint)) + param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum *attachments) glDiscardFramebufferEXT - dir attachments in - len attachments (numAttachments * sizeof(const GLenum)) + dir attachments in + len attachments (numAttachments * sizeof(const GLenum)) -#void glMultiDrawArraysEXT(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount) glMultiDrawArraysEXT - flag unsupported - -#void glMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei primcount) + flag unsupported + glMultiDrawElementsEXT - flag unsupported + flag unsupported -#void glMultiDrawArraysSUN(GLenum mode, GLint *first, GLsizei *count, GLsizei primcount) glMultiDrawArraysSUN - flag unsupported - -#void glMultiDrawElementsSUN(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount) + flag unsupported + glMultiDrawElementsSUN - flag unsupported + flag unsupported -#void glDeleteFencesNV(GLsizei n, const GLuint *fences) glDeleteFencesNV - dir fences in - len fences (n * sizeof(GLuint)) - param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } + dir fences in + len fences (n * sizeof(GLuint)) + param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glGenFencesNV(GLsizei n, GLuint *fences) glGenFencesNV - dir fences in - len fences (n * sizeof(GLuint)) - param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } + dir fences in + len fences (n * sizeof(GLuint)) + param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glGetFenceivNV(GLuint fence, GLenum pname, GLint *params) glGetFenceivNV - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLint)) + dir params out -#void glGetDriverControlsQCOM(GLint *num, GLsizei size, GLuint *driverControls) glGetDriverControlsQCOM - dir num out - len num (1 * sizeof(GLint)) - dir driverControls out - len driverControls (size * sizeof(GLuint)) + dir num out + len num (1 * sizeof(GLint)) + dir driverControls out + len driverControls (size * sizeof(GLuint)) -#void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei *length, GLchar *driverControlString) glGetDriverControlStringQCOM - dir length out - len length (1 * sizeof(GLsizei)) - dir driverControlString out - len driverControlString (1 * sizeof(GLchar)) + dir length out + len length (1 * sizeof(GLsizei)) + dir driverControlString out + len driverControlString (1 * sizeof(GLchar)) -#void glExtGetTexturesQCOM(GLuint *textures, GLint maxTextures, GLint *numTextures) glExtGetTexturesQCOM - dir textures out - len textures (maxTextures * sizeof(GLuint)) - dir numTextures out - len numTextures (1 * sizeof(GLint)) + dir textures out + len textures (maxTextures * sizeof(GLuint)) + dir numTextures out + len numTextures (1 * sizeof(GLint)) -#void glExtGetBuffersQCOM(GLuint *buffers, GLint maxBuffers, GLint *numBuffers) glExtGetBuffersQCOM - dir buffers out - len buffers (maxBuffers * sizeof(GLuint)) - dir numBuffers out - len numBuffers (1 * sizeof(GLint)) + dir buffers out + len buffers (maxBuffers * sizeof(GLuint)) + dir numBuffers out + len numBuffers (1 * sizeof(GLint)) -#void glExtGetRenderbuffersQCOM(GLuint *renderbuffers, GLint maxRenderbuffers, GLint *numRenderbuffers) glExtGetRenderbuffersQCOM - dir renderbuffers out - len renderbuffers (maxRenderbuffers * sizeof(GLuint)) - dir numRenderbuffers out - len numRenderbuffers (1 * sizeof(GLint)) + dir renderbuffers out + len renderbuffers (maxRenderbuffers * sizeof(GLuint)) + dir numRenderbuffers out + len numRenderbuffers (1 * sizeof(GLint)) -#void glExtGetFramebuffersQCOM(GLuint *framebuffers, GLint maxFramebuffers, GLint *numFramebuffers) glExtGetFramebuffersQCOM - dir framebuffers out - len framebuffers (maxFramebuffers * sizeof(GLuint)) - dir numFramebuffers out - len numFramebuffers (1 * sizeof(GLint)) + dir framebuffers out + len framebuffers (maxFramebuffers * sizeof(GLuint)) + dir numFramebuffers out + len numFramebuffers (1 * sizeof(GLint)) -#void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint *params) glExtGetTexLevelParameterivQCOM - dir params out - len params (glUtilsParamSize(pname) * sizeof(GLint)) + dir params out -#void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid *texels) glExtGetTexSubImageQCOM - dir texels out - len texels (depth * glesv1_enc::pixelDataSize(self, width, height, format, type, 0)) + dir texels out + len texels (depth * glesv1_enc::pixelDataSize(self, width, height, format, type, 0)) -#void glExtGetBufferPointervQCOM(GLenum target, GLvoid **params) glExtGetBufferPointervQCOM - flag unsupported + flag unsupported -#void glExtGetShadersQCOM(GLuint *shaders, GLint maxShaders, GLint *numShaders) glExtGetShadersQCOM - dir shaders out - len shaders (maxShaders * sizeof(GLuint)) - dir numShaders out - len numShaders (1 * sizeof(GLint)) + dir shaders out + len shaders (maxShaders * sizeof(GLuint)) + dir numShaders out + len numShaders (1 * sizeof(GLint)) -#void glExtGetProgramsQCOM(GLuint *programs, GLint maxPrograms, GLint *numPrograms) glExtGetProgramsQCOM - dir programs out - len programs (maxPrograms * sizeof(GLuint)) - dir numPrograms out - len numPrograms (1 * sizeof(GLint)) + dir programs out + len programs (maxPrograms * sizeof(GLuint)) + dir numPrograms out + len numPrograms (1 * sizeof(GLint)) -#void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar *source, GLint *length) glExtGetProgramBinarySourceQCOM - flag unsupported + flag unsupported diff --git a/host/libs/virglrenderer/GLESv1_dec/gles1_types.h b/host/libs/virglrenderer/GLESv1_dec/gles1_types.h index c8355ada1..097e03f71 100644 --- a/host/libs/virglrenderer/GLESv1_dec/gles1_types.h +++ b/host/libs/virglrenderer/GLESv1_dec/gles1_types.h @@ -1,21 +1,19 @@ /* -* Copyright (C) 2011 The Android Open Source Project -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ -#ifndef __GLES1_TYPES__H -#define __GLES1_TYPES__H + * Copyright (C) 2018 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 "gl_base_types.h" - -#endif // __GLES1_TYPES__H +#include <GLES/gl.h> +#include <GLES/glext.h> diff --git a/host/libs/virglrenderer/GLESv3.cpp b/host/libs/virglrenderer/GLESv3.cpp new file mode 100644 index 000000000..dd2707d17 --- /dev/null +++ b/host/libs/virglrenderer/GLESv3.cpp @@ -0,0 +1,642 @@ +/* + * Copyright (C) 2018 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 <OpenGLESDispatch/GLESv3Dispatch.h> + +#include "GLESv3.h" + +#include <string> +#include <vector> + +// Stubs (common) + +static void glDeleteFencesNV(GLsizei, const GLuint*) { + printf("%s: not implemented\n", __func__); +} + +static void glDisableDriverControlQCOM(GLuint) { + printf("%s: not implemented\n", __func__); +} + +static void glDiscardFramebufferEXT(GLenum, GLsizei, const GLenum*) { + printf("%s: not implemented\n", __func__); +} + +static void glEnableDriverControlQCOM(GLuint) { + printf("%s: not implemented\n", __func__); +} + +static void glEndTilingQCOM(GLbitfield) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetBufferPointervQCOM(GLenum, GLvoid**) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetBuffersQCOM(GLuint*, GLint, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetFramebuffersQCOM(GLuint*, GLint, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetProgramBinarySourceQCOM(GLuint, GLenum, GLchar*, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetProgramsQCOM(GLuint*, GLint, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetRenderbuffersQCOM(GLuint*, GLint, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetShadersQCOM(GLuint*, GLint, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetTexLevelParameterivQCOM(GLuint, GLenum, GLint, GLenum, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetTexSubImageQCOM(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, + GLenum, GLenum, GLvoid*) { + printf("%s: not implemented\n", __func__); +} + +static void glExtGetTexturesQCOM(GLuint*, GLint, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static GLboolean glExtIsProgramBinaryQCOM(GLuint) { + printf("%s: not implemented\n", __func__); + return GL_FALSE; +} + +static void glExtTexObjectStateOverrideiQCOM(GLenum, GLenum, GLint) { + printf("%s: not implemented\n", __func__); +} + +static void glFinishFenceNV(GLuint) { + printf("%s: not implemented\n", __func__); +} + +static void glFramebufferTexture2DMultisampleIMG(GLenum, GLenum, GLenum, GLuint, GLint, GLsizei) { + printf("%s: not implemented\n", __func__); +} + +static void glGenFencesNV(GLsizei, GLuint*) { + printf("%s: not implemented\n", __func__); +} + +static void glGetDriverControlsQCOM(GLint*, GLsizei, GLuint*) { + printf("%s: not implemented\n", __func__); +} + +static void glGetDriverControlStringQCOM(GLuint, GLsizei, GLsizei*, GLchar*) { + printf("%s: not implemented\n", __func__); +} + +static void glGetFenceivNV(GLuint, GLenum, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static GLboolean glIsFenceNV(GLuint) { + printf("%s: not implemented\n", __func__); + return GL_FALSE; +} + +static void* glMapBufferOES(GLenum, GLenum) { + printf("%s: not implemented\n", __func__); + return nullptr; +} + +static void glMultiDrawArraysEXT(GLenum, const GLint*, const GLsizei*, GLsizei) { + printf("%s: not implemented\n", __func__); +} + +static void glMultiDrawElementsEXT(GLenum, const GLsizei*, GLenum, const GLvoid* const*, GLsizei) { + printf("%s: not implemented\n", __func__); +} + +static void glRenderbufferStorageMultisampleIMG(GLenum, GLsizei, GLenum, GLsizei, GLsizei) { + printf("%s: not implemented\n", __func__); +} + +static void glSetFenceNV(GLuint, GLenum) { + printf("%s: not implemented\n", __func__); +} + +static void glStartTilingQCOM(GLuint, GLuint, GLuint, GLuint, GLbitfield) { + printf("%s: not implemented\n", __func__); +} + +static GLboolean glTestFenceNV(GLuint) { + printf("%s: not implemented\n", __func__); + return GL_FALSE; +} + +// Stubs (ES 3.1) + +static void glBeginPerfMonitorAMD(GLuint) { + printf("%s: not implemented\n", __func__); +} + +static void glCoverageMaskNV(GLboolean) { + printf("%s: not implemented\n", __func__); +} + +static void glCoverageOperationNV(GLenum) { + printf("%s: not implemented\n", __func__); +} + +static void glDeletePerfMonitorsAMD(GLsizei, GLuint*) { + printf("%s: not implemented\n", __func__); +} + +static void glEndPerfMonitorAMD(GLuint) { + printf("%s: not implemented\n", __func__); +} + +static void glGenPerfMonitorsAMD(GLsizei, GLuint*) { + printf("%s: not implemented\n", __func__); +} + +static void glGetPerfMonitorCounterDataAMD(GLuint, GLenum, GLsizei, GLuint*, GLint*) { + printf("%s: not implemented\n", __func__); +} + +static void glGetPerfMonitorCounterInfoAMD(GLuint, GLuint, GLenum, GLvoid*) { + printf("%s: not implemented\n", __func__); +} + +static void glGetPerfMonitorCountersAMD(GLuint, GLint*, GLint*, GLsizei, GLuint*) { + printf("%s: not implemented\n", __func__); +} + +static void glGetPerfMonitorCounterStringAMD(GLuint, GLuint, GLsizei, GLsizei*, GLchar*) { + printf("%s: not implemented\n", __func__); +} + +static void glGetPerfMonitorGroupsAMD(GLint*, GLsizei, GLuint*) { + printf("%s: not implemented\n", __func__); +} + +static void glGetPerfMonitorGroupStringAMD(GLuint, GLsizei, GLsizei*, GLchar*) { + printf("%s: not implemented\n", __func__); +} + +static void glSelectPerfMonitorCountersAMD(GLuint, GLboolean, GLuint, GLint, GLuint*) { + printf("%s: not implemented\n", __func__); +} + +// Non-stubs (common) + +static void glDrawElementsData(GLenum mode, GLsizei count, GLenum type, void* indices, GLuint) { + s_gles3.glDrawElements(mode, count, type, indices); +} + +static void glDrawElementsOffset(GLenum mode, GLsizei count, GLenum type, GLuint offset) { + s_gles3.glDrawElements(mode, count, type, reinterpret_cast<const GLvoid*>(offset)); +} + +static GLint glFinishRoundTrip() { + s_gles3.glFinish(); + return 0; +} + +static void glGetCompressedTextureFormats(int count, GLint* formats) { + int nFormats; + s_gles3.glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &nFormats); + if (nFormats <= count) + s_gles3.glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, formats); +} + +// Non-stubs (ES 3.1) + +struct GlSync { + GlSync(GLESv3* ctx_, GLsync sync_) : sync(sync_), id(ctx_->sync_nextId++), ctx(ctx_) { + ctx->sync_map.emplace(id, this); + } + + ~GlSync() { + ctx->sync_map.erase(id); + } + + GLsync sync; + uint64_t id; + + private: + GLESv3* ctx; +}; + +static GLenum glClientWaitSyncAEMU(void* ctx_, uint64_t wait_on, GLbitfield flags, + GLuint64 timeout) { + GLESv3* ctx = static_cast<GLESv3*>(ctx_); + + std::map<uint64_t, GlSync*>::iterator it; + it = ctx->sync_map.find(wait_on); + if (it == ctx->sync_map.end()) + return GL_INVALID_VALUE; + + GlSync* sync = it->second; + return s_gles3.glClientWaitSync(sync->sync, flags, timeout); +} + +static void glCompressedTexImage2DOffsetAEMU(GLenum target, GLint level, GLenum internalformat, + GLsizei width, GLsizei height, GLint border, + GLsizei imageSize, GLuint offset) { + s_gles3.glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, + reinterpret_cast<const GLvoid*>(offset)); +} + +static void glCompressedTexImage3DOffsetAEMU(GLenum target, GLint level, GLenum internalformat, + GLsizei width, GLsizei height, GLsizei depth, + GLint border, GLsizei imageSize, GLuint offset) { + s_gles3.glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, + imageSize, reinterpret_cast<const GLvoid*>(offset)); +} + +static void glCompressedTexSubImage2DOffsetAEMU(GLenum target, GLint level, GLint xoffset, + GLint yoffset, GLsizei width, GLsizei height, + GLenum format, GLsizei imageSize, GLuint offset) { + s_gles3.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, + imageSize, reinterpret_cast<const GLvoid*>(offset)); +} + +static void glCompressedTexSubImage3DOffsetAEMU(GLenum target, GLint level, GLint xoffset, + GLint yoffset, GLint zoffset, GLsizei width, + GLsizei height, GLsizei depth, GLenum format, + GLsizei imageSize, GLuint offset) { + s_gles3.glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, + format, imageSize, reinterpret_cast<const GLvoid*>(offset)); +} + +static GLuint glCreateShaderProgramvAEMU(GLenum type, GLsizei, const char* packedStrings, GLuint) { + return s_gles3.glCreateShaderProgramv(type, 1, &packedStrings); +} + +static void glDeleteSyncAEMU(void* ctx_, uint64_t to_delete) { + GLESv3* ctx = static_cast<GLESv3*>(ctx_); + + std::map<uint64_t, GlSync*>::iterator it; + it = ctx->sync_map.find(to_delete); + if (it == ctx->sync_map.end()) + return; + + GlSync* sync = it->second; + s_gles3.glDeleteSync(sync->sync); + delete sync; +} + +static void glDrawArraysIndirectDataAEMU(GLenum mode, const void* indirect, GLuint) { + s_gles3.glDrawArraysIndirect(mode, indirect); +} + +static void glDrawArraysIndirectOffsetAEMU(GLenum mode, GLuint offset) { + s_gles3.glDrawArraysIndirect(mode, reinterpret_cast<const void*>(offset)); +} + +static void glDrawElementsIndirectDataAEMU(GLenum mode, GLenum type, const void* indirect, GLuint) { + s_gles3.glDrawElementsIndirect(mode, type, indirect); +} + +static void glDrawElementsIndirectOffsetAEMU(GLenum mode, GLenum type, GLuint offset) { + s_gles3.glDrawElementsIndirect(mode, type, reinterpret_cast<const void*>(offset)); +} + +static void glDrawElementsInstancedDataAEMU(GLenum mode, GLsizei count, GLenum type, + const void* indices, GLsizei primcount, GLsizei) { + s_gles3.glDrawElementsInstanced(mode, count, type, indices, primcount); +} + +static void glDrawElementsInstancedOffsetAEMU(GLenum mode, GLsizei count, GLenum type, + GLuint offset, GLsizei primcount) { + s_gles3.glDrawElementsInstanced(mode, count, type, reinterpret_cast<const void*>(offset), + primcount); +} + +static void glDrawRangeElementsDataAEMU(GLenum mode, GLuint start, GLuint end, GLsizei count, + GLenum type, const GLvoid* indices, GLsizei) { + s_gles3.glDrawRangeElements(mode, start, end, count, type, indices); +} + +static void glDrawRangeElementsOffsetAEMU(GLenum mode, GLuint start, GLuint end, GLsizei count, + GLenum type, GLuint offset) { + s_gles3.glDrawRangeElements(mode, start, end, count, type, + reinterpret_cast<const GLvoid*>(offset)); +} + +static uint64_t glFenceSyncAEMU(void* ctx_, GLenum condition, GLbitfield flags) { + GLsync sync_ = s_gles3.glFenceSync(condition, flags); + if (sync_ == 0) + return 0U; + + GLESv3* ctx = static_cast<GLESv3*>(ctx_); + GlSync* sync = new (std::nothrow) GlSync(ctx, sync_); + if (!sync) { + s_gles3.glDeleteSync(sync_); + return 0U; + } + + return sync->id; +} + +static void glFlushMappedBufferRangeAEMU(GLenum target, GLintptr offset, GLsizeiptr length, + GLbitfield access, void* guest_buffer) { + if (guest_buffer && length) { + void* gpuPtr = s_gles3.glMapBufferRange(target, offset, length, access); + if (gpuPtr) { + memcpy(gpuPtr, guest_buffer, length); + s_gles3.glFlushMappedBufferRange(target, 0, length); + s_gles3.glUnmapBuffer(target); + } + } +} + +static void glGetSyncivAEMU(void* ctx_, uint64_t sync_, GLenum pname, GLsizei bufSize, + GLsizei* length, GLint* values) { + GLESv3* ctx = static_cast<GLESv3*>(ctx_); + + std::map<uint64_t, GlSync*>::iterator it; + it = ctx->sync_map.find(sync_); + if (it == ctx->sync_map.end()) + return; + + GlSync* sync = it->second; + s_gles3.glGetSynciv(sync->sync, pname, bufSize, length, values); +} + +static std::vector<std::string> sUnpackVarNames(GLsizei count, const char* packedNames) { + std::vector<std::string> unpacked; + GLsizei current = 0; + + while (current < count) { + const char* delimPos = strstr(packedNames, ";"); + size_t nameLen = delimPos - packedNames; + std::string next; + next.resize(nameLen); + memcpy(&next[0], packedNames, nameLen); + unpacked.push_back(next); + packedNames = delimPos + 1; + current++; + } + + return unpacked; +} + +static void glGetUniformIndicesAEMU(GLuint program, GLsizei uniformCount, const GLchar* packedNames, + GLsizei packedLen, GLuint* uniformIndices) { + std::vector<std::string> unpacked = sUnpackVarNames(uniformCount, packedNames); + GLchar** unpackedArray = new GLchar*[unpacked.size()]; + GLsizei i = 0; + for (auto& elt : unpacked) { + unpackedArray[i] = (GLchar*)&elt[0]; + i++; + } + + s_gles3.glGetUniformIndices(program, uniformCount, const_cast<const GLchar**>(unpackedArray), + uniformIndices); + delete[] unpackedArray; +} + +static GLboolean glIsSyncAEMU(void* ctx_, uint64_t sync) { + GLESv3* ctx = static_cast<GLESv3*>(ctx_); + return ctx->sync_map.count(sync) ? GL_TRUE : GL_FALSE; +} + +static void glMapBufferRangeAEMU(GLenum target, GLintptr offset, GLsizeiptr length, + GLbitfield access, void* mapped) { + if ((access & GL_MAP_READ_BIT) || + ((access & GL_MAP_WRITE_BIT) && + (!(access & GL_MAP_INVALIDATE_RANGE_BIT) && !(access & GL_MAP_INVALIDATE_BUFFER_BIT)))) { + void* gpuPtr = s_gles3.glMapBufferRange(target, offset, length, access); + if (gpuPtr) { + if (mapped) + memcpy(mapped, gpuPtr, length); + s_gles3.glUnmapBuffer(target); + } + } +} + +static void glReadPixelsOffsetAEMU(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, + GLenum type, GLuint offset) { + s_gles3.glReadPixels(x, y, width, height, format, type, reinterpret_cast<GLvoid*>(offset)); +} + +static void glShaderString(GLuint shader, const GLchar* string, GLsizei) { + s_gles3.glShaderSource(shader, 1, &string, NULL); +} + +static void glTexImage2DOffsetAEMU(GLenum target, GLint level, GLint internalformat, GLsizei width, + GLsizei height, GLint border, GLenum format, GLenum type, + GLuint offset) { + s_gles3.glTexImage2D(target, level, internalformat, width, height, border, format, type, + reinterpret_cast<const GLvoid*>(offset)); +} + +static void glTexImage3DOffsetAEMU(GLenum target, GLint level, GLint internalFormat, GLsizei width, + GLsizei height, GLsizei depth, GLint border, GLenum format, + GLenum type, GLuint offset) { + s_gles3.glTexImage3D(target, level, internalFormat, width, height, depth, border, format, type, + reinterpret_cast<const GLvoid*>(offset)); +} + +static void glTexSubImage2DOffsetAEMU(GLenum target, GLint level, GLint xoffset, GLint yoffset, + GLsizei width, GLsizei height, GLenum format, GLenum type, + GLuint offset) { + s_gles3.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, + reinterpret_cast<const GLvoid*>(offset)); +} + +static void glTexSubImage3DOffsetAEMU(GLenum target, GLint level, GLint xoffset, GLint yoffset, + GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, + GLenum format, GLenum type, GLuint offset) { + s_gles3.glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, + type, reinterpret_cast<const GLvoid*>(offset)); +} + +static void glTransformFeedbackVaryingsAEMU(GLuint program, GLsizei count, + const char* packedVaryings, GLuint packedVaryingsLen, + GLenum bufferMode) { + std::vector<std::string> unpacked = sUnpackVarNames(count, packedVaryings); + char** unpackedArray = new char*[unpacked.size()]; + GLsizei i = 0; + for (auto& elt : unpacked) { + unpackedArray[i] = &elt[0]; + i++; + } + + s_gles3.glTransformFeedbackVaryings(program, count, const_cast<const char**>(unpackedArray), + bufferMode); + delete[] unpackedArray; +} + +static void glUnmapBufferAEMU(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, + void* guest_buffer, GLboolean* out_res) { + *out_res = GL_TRUE; + + if (access & GL_MAP_WRITE_BIT) { + if (guest_buffer) { + void* gpuPtr = s_gles3.glMapBufferRange(target, offset, length, access); + if (gpuPtr) + memcpy(gpuPtr, guest_buffer, length); + } + + *out_res = s_gles3.glUnmapBuffer(target); + } +} + +static void glVertexAttribIPointerDataAEMU(GLuint index, GLint size, GLenum type, GLsizei, + void* data, GLuint) { + s_gles3.glVertexAttribIPointer(index, size, type, 0, data); +} + +static void glVertexAttribIPointerOffsetAEMU(GLuint index, GLint size, GLenum type, GLsizei, + GLuint offset) { + s_gles3.glVertexAttribIPointer(index, size, type, 0, reinterpret_cast<const GLvoid*>(offset)); +} + +static void glVertexAttribPointerData(GLuint indx, GLint size, GLenum type, GLboolean normalized, + GLsizei, void* data, GLuint) { + s_gles3.glVertexAttribPointer(indx, size, type, normalized, 0, data); +} + +static void glVertexAttribPointerOffset(GLuint indx, GLint size, GLenum type, GLboolean normalized, + GLsizei, GLuint offset) { + s_gles3.glVertexAttribPointer(indx, size, type, normalized, 0, + reinterpret_cast<const GLvoid*>(offset)); +} + +static void glWaitSyncAEMU(void* ctx_, uint64_t wait_on, GLbitfield flags, GLuint64 timeout) { + GLESv3* ctx = static_cast<GLESv3*>(ctx_); + + std::map<uint64_t, GlSync*>::iterator it; + it = ctx->sync_map.find(wait_on); + if (it == ctx->sync_map.end()) + return; + + GlSync* sync = it->second; + s_gles3.glWaitSync(sync->sync, flags, timeout); +} + +#define KNIT(return_type, function_name, signature, callargs) function_name = s_gles3.function_name; + +GLESv3::GLESv3() { + LIST_GLES3_FUNCTIONS(KNIT, KNIT) + + // Remap some ES 2.0 extensions that become core in ES 3.1 + glBindVertexArrayOES = glBindVertexArray; + glDeleteVertexArraysOES = glDeleteVertexArrays; + glGenVertexArraysOES = glGenVertexArrays; + glGetProgramBinaryOES = glGetProgramBinary; + glIsVertexArrayOES = glIsVertexArray; + glProgramBinaryOES = glProgramBinary; + glUnmapBufferOES = glUnmapBuffer; + + // Entrypoints requiring custom wrappers (common) + glDrawElementsData = ::glDrawElementsData; + glDrawElementsOffset = ::glDrawElementsOffset; + glFinishRoundTrip = ::glFinishRoundTrip; + glGetCompressedTextureFormats = ::glGetCompressedTextureFormats; + + // Entrypoints requiring custom wrappers (ES 3.1) + glClientWaitSyncAEMU = ::glClientWaitSyncAEMU; + glCompressedTexImage2DOffsetAEMU = ::glCompressedTexImage2DOffsetAEMU; + glCompressedTexImage3DOffsetAEMU = ::glCompressedTexImage3DOffsetAEMU; + glCompressedTexSubImage2DOffsetAEMU = ::glCompressedTexSubImage2DOffsetAEMU; + glCompressedTexSubImage3DOffsetAEMU = ::glCompressedTexSubImage3DOffsetAEMU; + glCreateShaderProgramvAEMU = ::glCreateShaderProgramvAEMU; + glDeleteSyncAEMU = ::glDeleteSyncAEMU; + glDrawArraysIndirectDataAEMU = ::glDrawArraysIndirectDataAEMU; + glDrawArraysIndirectOffsetAEMU = ::glDrawArraysIndirectOffsetAEMU; + glDrawElementsIndirectDataAEMU = ::glDrawElementsIndirectDataAEMU; + glDrawElementsIndirectOffsetAEMU = ::glDrawElementsIndirectOffsetAEMU; + glDrawElementsInstancedDataAEMU = ::glDrawElementsInstancedDataAEMU; + glDrawElementsInstancedOffsetAEMU = ::glDrawElementsInstancedOffsetAEMU; + glDrawRangeElementsDataAEMU = ::glDrawRangeElementsDataAEMU; + glDrawRangeElementsOffsetAEMU = ::glDrawRangeElementsOffsetAEMU; + glFenceSyncAEMU = ::glFenceSyncAEMU; + glFlushMappedBufferRangeAEMU = ::glFlushMappedBufferRangeAEMU; + glGetSyncivAEMU = ::glGetSyncivAEMU; + glGetUniformIndicesAEMU = ::glGetUniformIndicesAEMU; + glIsSyncAEMU = ::glIsSyncAEMU; + glMapBufferRangeAEMU = ::glMapBufferRangeAEMU; + glReadPixelsOffsetAEMU = ::glReadPixelsOffsetAEMU; + glShaderString = ::glShaderString; + glTexImage2DOffsetAEMU = ::glTexImage2DOffsetAEMU; + glTexImage3DOffsetAEMU = ::glTexImage3DOffsetAEMU; + glTexSubImage2DOffsetAEMU = ::glTexSubImage2DOffsetAEMU; + glTexSubImage3DOffsetAEMU = ::glTexSubImage3DOffsetAEMU; + glTransformFeedbackVaryingsAEMU = ::glTransformFeedbackVaryingsAEMU; + glUnmapBufferAEMU = ::glUnmapBufferAEMU; + glVertexAttribIPointerDataAEMU = ::glVertexAttribIPointerDataAEMU; + glVertexAttribIPointerOffsetAEMU = ::glVertexAttribIPointerOffsetAEMU; + glVertexAttribPointerData = ::glVertexAttribPointerData; + glVertexAttribPointerOffset = ::glVertexAttribPointerOffset; + glWaitSyncAEMU = ::glWaitSyncAEMU; + + // Stub some extensions we will never implement (common) + glDeleteFencesNV = ::glDeleteFencesNV; + glDisableDriverControlQCOM = ::glDisableDriverControlQCOM; + glDiscardFramebufferEXT = ::glDiscardFramebufferEXT; + glEnableDriverControlQCOM = ::glEnableDriverControlQCOM; + glEndTilingQCOM = ::glEndTilingQCOM; + glExtGetBufferPointervQCOM = ::glExtGetBufferPointervQCOM; + glExtGetBuffersQCOM = ::glExtGetBuffersQCOM; + glExtGetFramebuffersQCOM = ::glExtGetFramebuffersQCOM; + glExtGetProgramBinarySourceQCOM = ::glExtGetProgramBinarySourceQCOM; + glExtGetProgramsQCOM = ::glExtGetProgramsQCOM; + glExtGetRenderbuffersQCOM = ::glExtGetRenderbuffersQCOM; + glExtGetShadersQCOM = ::glExtGetShadersQCOM; + glExtGetTexLevelParameterivQCOM = ::glExtGetTexLevelParameterivQCOM; + glExtGetTexSubImageQCOM = ::glExtGetTexSubImageQCOM; + glExtGetTexturesQCOM = ::glExtGetTexturesQCOM; + glExtIsProgramBinaryQCOM = ::glExtIsProgramBinaryQCOM; + glExtTexObjectStateOverrideiQCOM = ::glExtTexObjectStateOverrideiQCOM; + glFinishFenceNV = ::glFinishFenceNV; + glFramebufferTexture2DMultisampleIMG = ::glFramebufferTexture2DMultisampleIMG; + glGenFencesNV = ::glGenFencesNV; + glGetDriverControlsQCOM = ::glGetDriverControlsQCOM; + glGetDriverControlStringQCOM = ::glGetDriverControlStringQCOM; + glGetFenceivNV = ::glGetFenceivNV; + glIsFenceNV = ::glIsFenceNV; + glMapBufferOES = ::glMapBufferOES; + glMultiDrawArraysEXT = ::glMultiDrawArraysEXT; + glMultiDrawElementsEXT = ::glMultiDrawElementsEXT; + glRenderbufferStorageMultisampleIMG = ::glRenderbufferStorageMultisampleIMG; + glSetFenceNV = ::glSetFenceNV; + glStartTilingQCOM = ::glStartTilingQCOM; + glTestFenceNV = ::glTestFenceNV; + + // Stub some extensions we will never implement (ES 3.1) + glBeginPerfMonitorAMD = ::glBeginPerfMonitorAMD; + glCoverageMaskNV = ::glCoverageMaskNV; + glCoverageOperationNV = ::glCoverageOperationNV; + glDeletePerfMonitorsAMD = ::glDeletePerfMonitorsAMD; + glEndPerfMonitorAMD = ::glEndPerfMonitorAMD; + glGenPerfMonitorsAMD = ::glGenPerfMonitorsAMD; + glGetPerfMonitorCounterDataAMD = ::glGetPerfMonitorCounterDataAMD; + glGetPerfMonitorCounterInfoAMD = ::glGetPerfMonitorCounterInfoAMD; + glGetPerfMonitorCountersAMD = ::glGetPerfMonitorCountersAMD; + glGetPerfMonitorCounterStringAMD = ::glGetPerfMonitorCounterStringAMD; + glGetPerfMonitorGroupsAMD = ::glGetPerfMonitorGroupsAMD; + glGetPerfMonitorGroupStringAMD = ::glGetPerfMonitorGroupStringAMD; + glSelectPerfMonitorCountersAMD = ::glSelectPerfMonitorCountersAMD; +} diff --git a/host/libs/virglrenderer/GLESv3.h b/host/libs/virglrenderer/GLESv3.h new file mode 100644 index 000000000..33eab48f6 --- /dev/null +++ b/host/libs/virglrenderer/GLESv3.h @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2018 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 "GLESv3_dec/gles3_dec.h" + +#include <map> + +struct GlSync; + +struct GLESv3 : public gles3_decoder_context_t { + GLESv3(); + + glDrawBuffers_server_proc_t glDrawBuffersEXT; + + glDrawArraysInstanced_server_proc_t glDrawArraysInstancedEXT; + glDrawElementsInstanced_server_proc_t glDrawElementsInstancedEXT; + + glVertexAttribDivisor_server_proc_t glVertexAttribDivisorEXT; + + std::map<uint64_t, GlSync*> sync_map; + + private: + uint64_t sync_nextId = 1U; + friend struct GlSync; +}; diff --git a/host/libs/virglrenderer/GLESv3_dec/gles3.attrib b/host/libs/virglrenderer/GLESv3_dec/gles3.attrib index 6b452f409..d5d8d1836 100644 --- a/host/libs/virglrenderer/GLESv3_dec/gles3.attrib +++ b/host/libs/virglrenderer/GLESv3_dec/gles3.attrib @@ -1,120 +1,68 @@ GLOBAL base_opcode 2048 - encoder_headers <string.h> "glUtils.h" "GL2EncoderUtils.h" -#void glBindAttribLocation(GLuint program, GLuint index, GLchar *name) glBindAttribLocation - flag custom_decoder len name (strlen(name) + 1) -#void glBufferData(GLenum target, GLsizeiptr size, GLvoid *data, GLenum usage) glBufferData len data size var_flag data nullAllowed isLarge -#void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data) glBufferSubData len data size var_flag data nullAllowed isLarge -#void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, GLvoid *data) glCompressedTexImage2D len data imageSize param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; } var_flag data nullAllowed isLarge param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLvoid *data) glCompressedTexSubImage2D len data imageSize param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; } var_flag data nullAllowed isLarge param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; } -glDeleteShader - flag custom_decoder - -glDeleteProgram - flag custom_decoder - -#void glDeleteBuffers(GLsizei n, GLuint *buffers) glDeleteBuffers - flag custom_decoder len buffers (n * sizeof(GLuint)) param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glDeleteFramebuffers(GLsizei n, GLuint *framebuffers) glDeleteFramebuffers - flag custom_decoder len framebuffers (n * sizeof(GLuint)) param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glDeleteRenderbuffers(GLsizei n, GLuint *renderbuffers) glDeleteRenderbuffers - flag custom_decoder len renderbuffers (n * sizeof(GLuint)) param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glDeleteTextures(GLsizei n, GLuint *textures) glDeleteTextures - flag custom_decoder len textures (n * sizeof(GLuint)) param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glDrawElements(GLenum mode, GLsizei count, GLenum type, GLvoid *indices) glDrawElements flag unsupported -glCreateShader - flag custom_decoder - -glCompileShader - flag custom_decoder - -glAttachShader - flag custom_decoder - -glDetachShader - flag custom_decoder - -glIsShader - flag custom_decoder - -glLinkProgram - flag custom_decoder - -glCreateProgram - flag custom_decoder - -#void glGenBuffers(GLsizei n, GLuint *buffers) glGenBuffers - flag custom_decoder len buffers (n * sizeof(GLuint)) dir buffers out param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glGenFramebuffers(GLsizei n, GLuint *framebuffers) glGenFramebuffers - flag custom_decoder len framebuffers (n * sizeof(GLuint)) dir framebuffers out param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers) glGenRenderbuffers - flag custom_decoder len renderbuffers (n * sizeof(GLuint)) dir renderbuffers out param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glGenTextures(GLsizei n, GLuint *textures) glGenTextures - flag custom_decoder len textures (n * sizeof(GLuint)) dir textures out param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) glGetActiveAttrib param_check bufsize if(bufsize<0){ ctx->setError(GL_INVALID_VALUE); return; } len name bufsize @@ -130,12 +78,11 @@ glGetActiveAttrib len type (sizeof(GLenum)) var_flag type nullAllowed -#void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) glGetActiveUniform param_check bufsize if(bufsize<0){ ctx->setError(GL_INVALID_VALUE); return; } len name bufsize dir name out - var_flag name nullAllowed + var_flag name nullAllowed dir length out len length (sizeof(GLsizei)) var_flag length nullAllowed @@ -146,8 +93,6 @@ glGetActiveUniform len type (sizeof(GLenum)) var_flag type nullAllowed - -#void glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei *count, GLuint *shaders) glGetAttachedShaders len shaders (maxcount*sizeof(GLuint)) dir shaders out @@ -155,44 +100,30 @@ glGetAttachedShaders var_flag count nullAllowed len count (sizeof(GLsizei)) -#int glGetAttribLocation(GLuint program, GLchar *name) glGetAttribLocation len name (strlen(name) + 1) -#void glGetBooleanv(GLenum pname, GLboolean *params) glGetBooleanv dir params out - len params (glUtilsParamSize(pname) * sizeof(GLboolean)) -#void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params) glGetBufferParameteriv len params (sizeof(GLint)) dir params out -#void glGetFloatv(GLenum pname, GLfloat *params) glGetFloatv dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) -#void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) glGetFramebufferAttachmentParameteriv dir params out len params (sizeof(GLint)) -#void glGetIntegerv(GLenum pname, GLint *params) glGetIntegerv dir params out - len params (glUtilsParamSize(pname) * sizeof(GLint)) -#void glGetProgramiv(GLuint program, GLenum pname, GLint *params) glGetProgramiv - flag custom_decoder dir params out - len params (glUtilsParamSize(pname) * sizeof(GLint)) -#void glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei *length, GLchar *infolog) glGetProgramInfoLog - flag custom_decoder dir infolog out len infolog bufsize param_check bufsize if(bufsize<0){ ctx->setError(GL_INVALID_VALUE); return; } @@ -200,22 +131,15 @@ glGetProgramInfoLog len length sizeof(GLsizei) var_flag length nullAllowed -#void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params) glGetRenderbufferParameteriv dir params out len params sizeof(GLint) -# XXX - might change if pname with value larger then one is added -#void glGetShaderiv(GLuint shader, GLenum pname, GLint *params) glGetShaderiv - flag custom_decoder dir params out len params sizeof(GLint) -# XXX - might change if pname with value larger then one is added -#void glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei *length, GLchar *infolog) glGetShaderInfoLog - flag custom_decoder dir length out len length (sizeof(GLsizei)) var_flag length nullAllowed @@ -223,16 +147,13 @@ glGetShaderInfoLog len infolog bufsize param_check bufsize if(bufsize<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision) glGetShaderPrecisionFormat dir range out len range (2 * sizeof(GLint)) dir precision out len precision (sizeof(GLint)) -#void glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei *length, GLchar *source) glGetShaderSource - flag custom_decoder dir length out len length (sizeof(GLsizei)) var_flag length nullAllowed @@ -240,428 +161,310 @@ glGetShaderSource len source bufsize param_check bufsize if(bufsize<0){ ctx->setError(GL_INVALID_VALUE); return; } -#GLubyte* glGetString(GLenum name) glGetString flag unsupported -#void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) glGetTexParameterfv dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) -#void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params) glGetTexParameteriv dir params out - len params (glUtilsParamSize(pname) * sizeof(GLint)) -#void glGetUniformfv(GLuint program, GLint location, GLfloat *params) glGetUniformfv dir params out len params glSizeof(glesv2_enc::uniformType(self, program, location)) -#void glGetUniformiv(GLuint program, GLint location, GLint *params) glGetUniformiv dir params out len params glSizeof(glesv2_enc::uniformType(self, program, location)) -#int glGetUniformLocation(GLuint program, GLchar *name) glGetUniformLocation len name (strlen(name) + 1) -# client-state shall be handled locally by the encoder in most cases. -# however, GL_CURRENT_VERTEX_ATTRIB and potential others are handled by the server side, -# thus we still need to implement it. -#void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params) glGetVertexAttribfv dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) -#see glGetVertexAttribfv for comments -#void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params) glGetVertexAttribiv dir params out - len params (glUtilsParamSize(pname) * sizeof(GLint)) -#void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) glReadPixels dir pixels out len pixels glesv2_enc::pixelDataSize(self, width, height, format, type, 1) glReadPixelsOffsetAEMU - flag custom_decoder flag not_api -#void glShaderBinary(GLsizei n, GLuint *shaders, GLenum binaryformat, GLvoid *binary, GLsizei length) glShaderBinary flag unsupported -#void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLvoid *pixels) glTexImage2D dir pixels in len pixels glesv2_enc::pixelDataSize(self, width, height, format, type, 0) var_flag pixels nullAllowed isLarge -#void glTexParameterfv(GLenum target, GLenum pname, GLfloat *params) -glTexParameterfv - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) -#void glTexParameteriv(GLenum target, GLenum pname, GLint *params) -glTexParameteriv - len params (glUtilsParamSize(pname) * sizeof(GLint)) - -#void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) glTexSubImage2D len pixels glesv2_enc::pixelDataSize(self, width, height, format, type, 0) var_flag pixels nullAllowed isLarge -#void glUniform1fv(GLint location, GLsizei count, GLfloat *v) glUniform1fv len v (count * sizeof(GLfloat)) -#void glUniform1iv(GLint location, GLsizei count, GLint *v) glUniform1iv len v (count * sizeof(GLint)) -#void glUniform2fv(GLint location, GLsizei count, GLfloat *v) glUniform2fv len v (count * 2 * sizeof(GLfloat)) -#void glUniform2iv(GLint location, GLsizei count, GLint *v) glUniform2iv len v (count * 2 * sizeof(GLint)) -#void glUniform3fv(GLint location, GLsizei count, GLfloat *v) glUniform3fv len v (count * 3 * sizeof(GLfloat)) -#void glUniform3iv(GLint location, GLsizei count, GLint *v) glUniform3iv len v (3 * count * sizeof(GLint)) -#void glUniform4fv(GLint location, GLsizei count, GLfloat *v) glUniform4fv len v (4 * count * sizeof(GLfloat)) -#void glUniform4iv(GLint location, GLsizei count, GLint *v) glUniform4iv len v (4 * count * sizeof(GLint)) -#void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, GLfloat *value) glUniformMatrix2fv len value (count * 4 * sizeof(GLfloat)) -#void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, GLfloat *value) glUniformMatrix3fv len value (count * 9 * sizeof(GLfloat)) -#void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, GLfloat *value) glUniformMatrix4fv len value (count * 16 * sizeof(GLfloat)) -#void glVertexAttrib1fv(GLuint indx, GLfloat *values) glVertexAttrib1fv len values (sizeof(GLfloat)) -#void glVertexAttrib2fv(GLuint indx, GLfloat *values) glVertexAttrib2fv len values (2 * sizeof(GLfloat)) -#void glVertexAttrib3fv(GLuint indx, GLfloat *values) glVertexAttrib3fv len values (3 * sizeof(GLfloat)) -#void glVertexAttrib4fv(GLuint indx, GLfloat *values) glVertexAttrib4fv len values (4 * sizeof(GLfloat)) -#void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLvoid *ptr) glVertexAttribPointer flag unsupported -#void glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary) glGetProgramBinaryOES flag unsupported -#void glProgramBinaryOES(GLuint program, GLenum binaryFormat, GLvoid *binary, GLint length) glProgramBinaryOES flag unsupported -#void* glMapBufferOES(GLenum target, GLenum access) glMapBufferOES flag unsupported -#void glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, GLvoid *pixels) glTexImage3DOES len pixels glesv2_enc::pixelDataSize3D(self, width, height, depth, format, type, 0) var_flag pixels nullAllowed isLarge -#void glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid *pixels) glTexSubImage3DOES len pixels glesv2_enc::pixelDataSize3D(self, width, height, depth, format, type, 0) var_flag pixels nullAllowed isLarge -#void glCompressedTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, GLvoid *data) glCompressedTexImage3DOES len data imageSize param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; } var_flag data nullAllowed isLarge -#void glCompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, GLvoid *data) glCompressedTexSubImage3DOES len data imageSize param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; } var_flag data nullAllowed isLarge -#void glDeleteVertexArraysOES(GLsizei n, GLuint *arrays) glDeleteVertexArraysOES - flag custom_decoder len arrays (n * sizeof(GLuint)) param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -#void glGenVertexArraysOES(GLsizei n, GLuint *arrays) glGenVertexArraysOES - flag custom_decoder len arrays (n * sizeof(GLuint)) dir arrays out param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } - -#void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, GLenum *attachments) glDiscardFramebufferEXT len attachments (numAttachments * sizeof(GLenum)) -#void glMultiDrawArraysEXT(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount) glMultiDrawArraysEXT flag unsupported -#void glMultiDrawElementsEXT(GLenum mode, GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei primcount) + glMultiDrawElementsEXT flag unsupported - -# handled by encoder -#void glShaderSource(GLuint shader, GLsizei count, GLstr *string, const GLint *length) glShaderSource flag unsupported - -#void glGetPerfMonitorGroupsAMD(GLint *numGroups, GLsizei groupsSize, GLuint *groups) glGetPerfMonitorGroupsAMD flag unsupported -#void glGetPerfMonitorCountersAMD(GLuint group, GLint *numCounters, GLint *maxActiveCounters, GLsizei counterSize, GLuint *counters) glGetPerfMonitorCountersAMD flag unsupported -#void glGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei *length, GLchar *groupString) glGetPerfMonitorGroupStringAMD flag unsupported -#void glGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei *length, GLchar *counterString) glGetPerfMonitorCounterStringAMD flag unsupported -#void glGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname, GLvoid *data) glGetPerfMonitorCounterInfoAMD flag unsupported -#void glGenPerfMonitorsAMD(GLsizei n, GLuint *monitors) glGenPerfMonitorsAMD flag unsupported -#void glDeletePerfMonitorsAMD(GLsizei n, GLuint *monitors) glDeletePerfMonitorsAMD flag unsupported -#void glSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint *countersList) glSelectPerfMonitorCountersAMD flag unsupported -#void glBeginPerfMonitorAMD(GLuint monitor) glBeginPerfMonitorAMD flag unsupported -#void glEndPerfMonitorAMD(GLuint monitor) glEndPerfMonitorAMD flag unsupported -#void glGetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint *data, GLint *bytesWritten) glGetPerfMonitorCounterDataAMD flag unsupported -#void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) glRenderbufferStorageMultisampleIMG flag unsupported -#void glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples) glFramebufferTexture2DMultisampleIMG flag unsupported -#void glDeleteFencesNV(GLsizei n, GLuint *fences) glDeleteFencesNV flag unsupported -#void glGenFencesNV(GLsizei n, GLuint *fences) glGenFencesNV flag unsupported -#GLboolean glIsFenceNV(GLuint fence) glIsFenceNV flag unsupported -#GLboolean glTestFenceNV(GLuint fence) glTestFenceNV flag unsupported -#void glGetFenceivNV(GLuint fence, GLenum pname, GLint *params) glGetFenceivNV flag unsupported -#void glFinishFenceNV(GLuint fence) glFinishFenceNV flag unsupported -#void glSetFenceNV(GLuint fence, GLenum condition) glSetFenceNV flag unsupported -#void glCoverageMaskNV(GLboolean mask) glCoverageMaskNV flag unsupported -#void glCoverageOperationNV(GLenum operation) glCoverageOperationNV flag unsupported -#void glGetDriverControlsQCOM(GLint *num, GLsizei size, GLuint *driverControls) glGetDriverControlsQCOM flag unsupported -#void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei *length, GLchar *driverControlString) glGetDriverControlStringQCOM flag unsupported -#void glEnableDriverControlQCOM(GLuint driverControl) glEnableDriverControlQCOM flag unsupported -#void glDisableDriverControlQCOM(GLuint driverControl) glDisableDriverControlQCOM flag unsupported -#void glExtGetTexturesQCOM(GLuint *textures, GLint maxTextures, GLint *numTextures) glExtGetTexturesQCOM flag unsupported -#void glExtGetBuffersQCOM(GLuint *buffers, GLint maxBuffers, GLint *numBuffers) glExtGetBuffersQCOM flag unsupported -#void glExtGetRenderbuffersQCOM(GLuint *renderbuffers, GLint maxRenderbuffers, GLint *numRenderbuffers) glExtGetRenderbuffersQCOM flag unsupported -#void glExtGetFramebuffersQCOM(GLuint *framebuffers, GLint maxFramebuffers, GLint *numFramebuffers) glExtGetFramebuffersQCOM flag unsupported -#void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint *params) glExtGetTexLevelParameterivQCOM flag unsupported -#void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param) glExtTexObjectStateOverrideiQCOM flag unsupported -#void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid *texels) glExtGetTexSubImageQCOM flag unsupported -#void glExtGetBufferPointervQCOM(GLenum target, GLvoidptr *params) glExtGetBufferPointervQCOM flag unsupported -#void glExtGetShadersQCOM(GLuint *shaders, GLint maxShaders, GLint *numShaders) glExtGetShadersQCOM flag unsupported -#void glExtGetProgramsQCOM(GLuint *programs, GLint maxPrograms, GLint *numPrograms) glExtGetProgramsQCOM flag unsupported -#GLboolean glExtIsProgramBinaryQCOM(GLuint program) glExtIsProgramBinaryQCOM flag unsupported -#void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar *source, GLint *length) glExtGetProgramBinarySourceQCOM flag unsupported -#void glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask) glStartTilingQCOM flag unsupported -#void glEndTilingQCOM(GLbitfield preserveMask) glEndTilingQCOM flag unsupported - -#void glVertexAttribPointerData(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void * data, GLuint datalen) glVertexAttribPointerData len data datalen - custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen) - flag custom_decoder flag not_api glVertexAttribPointerOffset - flag custom_decoder flag not_api -#client-state, handled by the encoder -#GL_ENTRY(void, glGetVertexAttribPointerv, GLuint index, GLenum pname, GLvoid** pointer) glGetVertexAttribPointerv flag unsupported glDrawElementsData len data datalen - flag custom_decoder flag not_api glDrawElementsOffset - flag custom_decoder flag not_api -#GL_ENTRY(void, glGetCompressedTextureFormats, int count, GLint *formats) glGetCompressedTextureFormats dir formats out len formats (count * sizeof(GLint)) - flag custom_decoder flag not_api -#GL_ENTRY(void, glShaderString, GLuint shader, GLchar *string, GLsizei len) glShaderString len string len - flag custom_decoder flag not_api glFinishRoundTrip - flag custom_decoder flag not_api -# GLES 3.0 - glGenVertexArrays - flag custom_decoder len arrays (n * sizeof(GLuint)) dir arrays out param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } glDeleteVertexArrays - flag custom_decoder len arrays (n * sizeof(GLuint)) param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } glMapBufferRange flag unsupported + glUnmapBuffer flag unsupported + glFlushMappedBufferRange flag unsupported @@ -669,7 +472,6 @@ glMapBufferRangeAEMU dir mapped out len mapped length var_flag mapped nullAllowed - flag custom_decoder flag not_api glUnmapBufferAEMU @@ -678,34 +480,27 @@ glUnmapBufferAEMU var_flag guest_buffer nullAllowed dir out_res out len out_res (sizeof(GLboolean)) - flag custom_decoder flag not_api glFlushMappedBufferRangeAEMU dir guest_buffer in len guest_buffer length var_flag guest_buffer nullAllowed - flag custom_decoder flag not_api glReadPixelsOffsetAEMU - flag custom_decoder flag not_api glCompressedTexImage2DOffsetAEMU - flag custom_decoder flag not_api glCompressedTexSubImage2DOffsetAEMU - flag custom_decoder flag not_api glTexImage2DOffsetAEMU - flag custom_decoder flag not_api glTexSubImage2DOffsetAEMU - flag custom_decoder flag not_api glCopyBufferSubData @@ -740,7 +535,6 @@ glGetUniformIndicesAEMU len packedUniformNames packedLen dir uniformIndices out len uniformIndices (uniformCount * sizeof(GLuint)) - flag custom_decoder flag not_api glGetActiveUniformBlockiv @@ -805,33 +599,26 @@ glVertexAttribIPointer flag unsupported glVertexAttribIPointerOffsetAEMU - flag custom_decoder flag not_api glVertexAttribIPointerDataAEMU len data datalen - custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen) - flag custom_decoder flag not_api glGetVertexAttribIiv dir params out - len params (glUtilsParamSize(pname) * sizeof(GLint)) glGetVertexAttribIuiv dir params out - len params (glUtilsParamSize(pname) * sizeof(GLuint)) glDrawElementsInstanced flag unsupported glDrawElementsInstancedDataAEMU len indices datalen - flag custom_decoder flag not_api glDrawElementsInstancedOffsetAEMU - flag custom_decoder flag not_api glDrawRangeElements @@ -839,11 +626,9 @@ glDrawRangeElements glDrawRangeElementsDataAEMU len indices datalen - flag custom_decoder flag not_api glDrawRangeElementsOffsetAEMU - flag custom_decoder flag not_api glFenceSync @@ -908,13 +693,11 @@ glInvalidateSubFramebuffer len attachments (numAttachments * sizeof(GLenum)) glGenTransformFeedbacks - flag custom_decoder dir ids out len ids (n * sizeof(GLuint)) param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } glDeleteTransformFeedbacks - flag custom_decoder len ids (n * sizeof(GLuint)) param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } @@ -924,7 +707,6 @@ glTransformFeedbackVaryings glTransformFeedbackVaryingsAEMU dir packedVaryings in len packedVaryings packedVaryingsLen - flag custom_decoder flag not_api glGetTransformFeedbackVarying @@ -943,48 +725,34 @@ glGetTransformFeedbackVarying var_flag type nullAllowed glGenSamplers - flag custom_decoder dir samplers out len samplers (n * sizeof(GLuint)) param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } glDeleteSamplers - flag custom_decoder len samplers (n * sizeof(GLuint)) param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } -glSamplerParameterfv - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) - -glSamplerParameteriv - len params (glUtilsParamSize(pname) * sizeof(GLint)) - glGetSamplerParameterfv dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) glGetSamplerParameteriv dir params out - len params (glUtilsParamSize(pname) * sizeof(GLint)) glGenQueries - flag custom_decoder dir queries out len queries (n * sizeof(GLuint)) param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } glDeleteQueries - flag custom_decoder len queries (n * sizeof(GLuint)) param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } glGetQueryiv dir params out - len params (glUtilsParamSize(pname) * sizeof(GLint)) glGetQueryObjectuiv dir params out - len params (glUtilsParamSize(pname) * sizeof(GLuint)) glProgramBinary len binary length @@ -1004,11 +772,7 @@ glGetFragDataLocation glGetInteger64v dir data out - len data (glUtilsParamSize(pname) * sizeof(GLint64)) -# No need to account for custom sizes since indexed variants -# are all on indxed buffers like transform feedback buffers, -# UBOs, or SSBOs, and querying their sizes and offsets. glGetIntegeri_v dir data out len data (sizeof(GLint)) @@ -1023,7 +787,6 @@ glTexImage3D var_flag data nullAllowed isLarge glTexImage3DOffsetAEMU - flag custom_decoder flag not_api glTexSubImage3D @@ -1031,7 +794,6 @@ glTexSubImage3D var_flag data nullAllowed isLarge glTexSubImage3DOffsetAEMU - flag custom_decoder flag not_api glCompressedTexImage3D @@ -1040,7 +802,6 @@ glCompressedTexImage3D var_flag data nullAllowed isLarge glCompressedTexImage3DOffsetAEMU - flag custom_decoder flag not_api glCompressedTexSubImage3D @@ -1049,31 +810,25 @@ glCompressedTexSubImage3D var_flag data nullAllowed isLarge glCompressedTexSubImage3DOffsetAEMU - flag custom_decoder flag not_api glGetStringi flag unsupported -# GLES 3.1 - glGetBooleani_v dir data out len data (sizeof(GLboolean)) glGenProgramPipelines - flag custom_decoder dir pipelines out len pipelines (n * sizeof(GLuint)) glDeleteProgramPipelines - flag custom_decoder len pipelines (n * sizeof(GLuint)) param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; } glGetProgramPipelineiv dir params out - len params (glUtilsParamSize(pname) * sizeof(GLint)) glGetProgramPipelineInfoLog dir infoLog out @@ -1088,7 +843,6 @@ glCreateShaderProgramv glCreateShaderProgramvAEMU len packedStrings packedLen - flag custom_decoder flag not_api glProgramUniform1fv @@ -1156,7 +910,6 @@ glProgramUniformMatrix4x3fv glGetProgramInterfaceiv dir params out - len params (glUtilsParamSize(pname) * sizeof(GLint)) glGetProgramResourceiv dir params out @@ -1186,11 +939,9 @@ glDrawArraysIndirect glDrawArraysIndirectDataAEMU len indirect datalen - flag custom_decoder flag not_api glDrawArraysIndirectOffsetAEMU - flag custom_decoder flag not_api glDrawElementsIndirect @@ -1198,218 +949,19 @@ glDrawElementsIndirect glDrawElementsIndirectDataAEMU len indirect datalen - flag custom_decoder flag not_api glDrawElementsIndirectOffsetAEMU - flag custom_decoder flag not_api glGetMultisamplefv dir val out - len val (glUtilsParamSize(pname) * sizeof(GLfloat)) glGetFramebufferParameteriv dir params out - len params (glUtilsParamSize(pname) * sizeof(GLint)) glGetTexLevelParameterfv dir params out - len params (glUtilsParamSize(pname) * sizeof(GLfloat)) glGetTexLevelParameteriv dir params out - len params (glUtilsParamSize(pname) * sizeof(GLint)) -glUseProgram - flag custom_decoder - -glValidateProgram - flag custom_decoder - -glIsProgram - flag custom_decoder - -glGetActiveAttrib - flag custom_decoder - -glGetActiveUniform - flag custom_decoder - -glGetAttachedShaders - flag custom_decoder - -glGetAttribLocation - flag custom_decoder - -glGetUniformfv - flag custom_decoder - -glGetUniformiv - flag custom_decoder - -glGetUniformLocation - flag custom_decoder - -glGetProgramBinaryOES - flag custom_decoder - -glProgramBinaryOES - flag custom_decoder - -glUniformBlockBinding - flag custom_decoder - -glGetUniformBlockIndex - flag custom_decoder - -glGetActiveUniformBlockiv - flag custom_decoder - -glGetActiveUniformBlockName - flag custom_decoder - -glGetUniformuiv - flag custom_decoder - -glGetActiveUniformsiv - flag custom_decoder - -glTransformFeedbackVaryings - flag custom_decoder - -glGetTransformFeedbackVarying - flag custom_decoder - -glProgramParameteri - flag custom_decoder - -glProgramBinary - flag custom_decoder - -glGetProgramBinary - flag custom_decoder - -glGetFragDataLocation - flag custom_decoder - -glUseProgramStages - flag custom_decoder - -glActiveShaderProgram - flag custom_decoder - -glProgramUniform1f - flag custom_decoder - -glProgramUniform2f - flag custom_decoder - -glProgramUniform3f - flag custom_decoder - -glProgramUniform4f - flag custom_decoder - -glProgramUniform1i - flag custom_decoder - -glProgramUniform2i - flag custom_decoder - -glProgramUniform3i - flag custom_decoder - -glProgramUniform4i - flag custom_decoder - -glProgramUniform1ui - flag custom_decoder - -glProgramUniform2ui - flag custom_decoder - -glProgramUniform3ui - flag custom_decoder - -glProgramUniform4ui - flag custom_decoder - -glProgramUniform1fv - flag custom_decoder - -glProgramUniform2fv - flag custom_decoder - -glProgramUniform3fv - flag custom_decoder - -glProgramUniform4fv - flag custom_decoder - -glProgramUniform1iv - flag custom_decoder - -glProgramUniform2iv - flag custom_decoder - -glProgramUniform3iv - flag custom_decoder - -glProgramUniform4iv - flag custom_decoder - -glProgramUniform1uiv - flag custom_decoder - -glProgramUniform2uiv - flag custom_decoder - -glProgramUniform3uiv - flag custom_decoder - -glProgramUniform4uiv - flag custom_decoder - -glProgramUniformMatrix2fv - flag custom_decoder - -glProgramUniformMatrix3fv - flag custom_decoder - -glProgramUniformMatrix4fv - flag custom_decoder - -glProgramUniformMatrix2x3fv - flag custom_decoder - -glProgramUniformMatrix3x2fv - flag custom_decoder - -glProgramUniformMatrix2x4fv - flag custom_decoder - -glProgramUniformMatrix4x2fv - flag custom_decoder - -glProgramUniformMatrix3x4fv - flag custom_decoder - -glProgramUniformMatrix4x3fv - flag custom_decoder - -glGetProgramInterfaceiv - flag custom_decoder - -glGetProgramResourceiv - flag custom_decoder - -glGetProgramResourceIndex - flag custom_decoder - -glGetProgramResourceLocation - flag custom_decoder - -glGetProgramResourceName - flag custom_decoder - - diff --git a/host/libs/virglrenderer/GLESv3_dec/gles3.in b/host/libs/virglrenderer/GLESv3_dec/gles3.in index 50d9406a3..33eb3b396 100644 --- a/host/libs/virglrenderer/GLESv3_dec/gles3.in +++ b/host/libs/virglrenderer/GLESv3_dec/gles3.in @@ -196,7 +196,7 @@ GL_ENTRY(void, glExtGetFramebuffersQCOM, GLuint *framebuffers, GLint maxFramebuf GL_ENTRY(void, glExtGetTexLevelParameterivQCOM, GLuint texture, GLenum face, GLint level, GLenum pname, GLint *params) GL_ENTRY(void, glExtTexObjectStateOverrideiQCOM, GLenum target, GLenum pname, GLint param) GL_ENTRY(void, glExtGetTexSubImageQCOM, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid *texels) -GL_ENTRY(void, glExtGetBufferPointervQCOM, GLenum target, GLvoidptr *params) +GL_ENTRY(void, glExtGetBufferPointervQCOM, GLenum target, GLvoid** params) GL_ENTRY(void, glExtGetShadersQCOM, GLuint *shaders, GLint maxShaders, GLint *numShaders) GL_ENTRY(void, glExtGetProgramsQCOM, GLuint *programs, GLint maxPrograms, GLint *numPrograms) GL_ENTRY(GLboolean, glExtIsProgramBinaryQCOM, GLuint program) @@ -309,7 +309,7 @@ GL_ENTRY(void, glUniformBlockBinding, GLuint program, GLuint uniformBlockIndex, GL_ENTRY(GLuint, glGetUniformBlockIndex, GLuint program, const GLchar *uniformBlockName) # Assume uniformNames packed into 1 buffer on the guest. -GL_ENTRY(void, glGetUniformIndices, GLuint program, GLsizei uniformCount, const GLchar ** uniformNames, GLuint* uniformIndices) +GL_ENTRY(void, glGetUniformIndices, GLuint program, GLsizei uniformCount, const GLchar*const* uniformNames, GLuint* uniformIndices) GL_ENTRY(void, glGetUniformIndicesAEMU, GLuint program, GLsizei uniformCount, const GLchar *packedUniformNames, GLsizei packedLen, GLuint *uniformIndices) GL_ENTRY(void, glGetActiveUniformBlockiv, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params) @@ -319,7 +319,7 @@ GL_ENTRY(void, glGetActiveUniformBlockName, GLuint program, GLuint uniformBlockI GL_ENTRY(void, glUniform1ui, GLint location, GLuint v0) GL_ENTRY(void, glUniform2ui, GLint location, GLuint v0, GLuint v1) GL_ENTRY(void, glUniform3ui, GLint location, GLuint v0, GLuint v1, GLuint v2) -GL_ENTRY(void, glUniform4ui, GLint location, GLint v0, GLuint v1, GLuint v2, GLuint v3) +GL_ENTRY(void, glUniform4ui, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) GL_ENTRY(void, glUniform1uiv, GLint location, GLsizei count, const GLuint *value) GL_ENTRY(void, glUniform2uiv, GLint location, GLsizei count, const GLuint *value) GL_ENTRY(void, glUniform3uiv, GLint location, GLsizei count, const GLuint *value) @@ -399,7 +399,7 @@ GL_ENTRY(void, glBindTransformFeedback, GLenum target, GLuint id) GL_ENTRY(void, glPauseTransformFeedback, void) GL_ENTRY(void, glResumeTransformFeedback, void) GL_ENTRY(GLboolean, glIsTransformFeedback, GLuint id) -GL_ENTRY(void, glTransformFeedbackVaryings, GLuint program, GLsizei count, const char ** varyings, GLenum bufferMode) +GL_ENTRY(void, glTransformFeedbackVaryings, GLuint program, GLsizei count, const GLchar*const* varyings, GLenum bufferMode) GL_ENTRY(void, glTransformFeedbackVaryingsAEMU, GLuint program, GLsizei count, const char* packedVaryings, GLuint packedVaryingsLen, GLenum bufferMode) GL_ENTRY(void, glGetTransformFeedbackVarying, GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, char * name) @@ -473,7 +473,7 @@ GL_ENTRY(void, glUseProgramStages, GLuint pipeline, GLbitfield stages, GLuint pr # Separable shader programs - may need to change how program objects are represented and shared! GL_ENTRY(void, glActiveShaderProgram, GLuint pipeline, GLuint program); -GL_ENTRY(GLuint, glCreateShaderProgramv, GLenum type, GLsizei count, const char ** strings) +GL_ENTRY(GLuint, glCreateShaderProgramv, GLenum type, GLsizei count, const GLchar*const* strings) GL_ENTRY(GLuint, glCreateShaderProgramvAEMU, GLenum type, GLsizei count, const char *packedStrings, GLuint packedLen) # Uniforms should work easily if any program object representation problems are solved. GL_ENTRY(void, glProgramUniform1f, GLuint program, GLint location, GLfloat v0) @@ -485,9 +485,9 @@ GL_ENTRY(void, glProgramUniform2i, GLuint program, GLint location, GLint v0, GLi GL_ENTRY(void, glProgramUniform3i, GLuint program, GLint location, GLint v0, GLint v1, GLint v2) GL_ENTRY(void, glProgramUniform4i, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) GL_ENTRY(void, glProgramUniform1ui, GLuint program, GLint location, GLuint v0) -GL_ENTRY(void, glProgramUniform2ui, GLuint program, GLint location, GLint v0, GLuint v1) -GL_ENTRY(void, glProgramUniform3ui, GLuint program, GLint location, GLint v0, GLint v1, GLuint v2) -GL_ENTRY(void, glProgramUniform4ui, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLuint v3) +GL_ENTRY(void, glProgramUniform2ui, GLuint program, GLint location, GLuint v0, GLuint v1) +GL_ENTRY(void, glProgramUniform3ui, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) +GL_ENTRY(void, glProgramUniform4ui, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) GL_ENTRY(void, glProgramUniform1fv, GLuint program, GLint location, GLsizei count, const GLfloat *value) GL_ENTRY(void, glProgramUniform2fv, GLuint program, GLint location, GLsizei count, const GLfloat *value) GL_ENTRY(void, glProgramUniform3fv, GLuint program, GLint location, GLsizei count, const GLfloat *value) @@ -529,7 +529,7 @@ GL_ENTRY(void, glDispatchComputeIndirect, GLintptr indirect) # Separate vertex format / buffer binding ### Requires us tp really clean up how draws work in the encoder currently. -GL_ENTRY(void, glBindVertexBuffer, GLuint bindingindex, GLuint buffer, GLintptr offset, GLintptr stride) +GL_ENTRY(void, glBindVertexBuffer, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride) GL_ENTRY(void, glVertexAttribBinding, GLuint attribindex, GLuint bindingindex); GL_ENTRY(void, glVertexAttribFormat, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset) GL_ENTRY(void, glVertexAttribIFormat, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) diff --git a/host/libs/virglrenderer/GLESv3_dec/gles3_types.h b/host/libs/virglrenderer/GLESv3_dec/gles3_types.h index bfff61de4..3347b9923 100644 --- a/host/libs/virglrenderer/GLESv3_dec/gles3_types.h +++ b/host/libs/virglrenderer/GLESv3_dec/gles3_types.h @@ -1,21 +1,19 @@ /* -* Copyright (C) 2011 The Android Open Source Project -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ -#ifndef _GL_2_TYPES_H_ -#define _GL_2_TYPES_H_ -#include "gl_base_types.h" + * Copyright (C) 2018 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 -typedef void *GLvoidptr; -#endif +#include <GLES3/gl31.h> +#include <GLES2/gl2ext.h> diff --git a/host/libs/virglrenderer/Gralloc1.cpp b/host/libs/virglrenderer/Gralloc1.cpp new file mode 100644 index 000000000..a2fcd8147 --- /dev/null +++ b/host/libs/virglrenderer/Gralloc1.cpp @@ -0,0 +1,145 @@ +/* + * Copyright (C) 2018 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 <cstdint> + +extern "C" { +#include "virgl_hw.h" +} + +#include "Resource.h" + +#include <android/sync.h> +#include <hardware/gralloc1.h> + +#include <cerrno> + +#define ALIGN(A, B) (((A) + (B)-1) / (B) * (B)) + +static int gralloc1_device_open(const hw_module_t*, const char*, hw_device_t**); + +static hw_module_methods_t g_gralloc1_methods = { + .open = gralloc1_device_open, +}; + +static hw_module_t g_gralloc1_module = { + .tag = HARDWARE_MODULE_TAG, + .module_api_version = GRALLOC_MODULE_API_VERSION_1_0, + .hal_api_version = HARDWARE_HAL_API_VERSION, + .id = GRALLOC_HARDWARE_MODULE_ID, + .name = "AVDVirglRenderer", + .author = "Google", + .methods = &g_gralloc1_methods, +}; + +static int gralloc1_device_close(hw_device_t*) { + // No-op + return 0; +} + +static void gralloc1_getCapabilities(gralloc1_device_t*, uint32_t* outCount, int32_t*) { + *outCount = 0U; +} + +static int32_t gralloc1_lock(gralloc1_device_t*, buffer_handle_t buffer, uint64_t producerUsage, + uint64_t consumerUsage, const gralloc1_rect_t* rect, void** outData, + int32_t) { + uint32_t resource_id = (uint32_t) reinterpret_cast<uintptr_t>(buffer); + std::map<uint32_t, Resource*>::iterator it; + it = Resource::map.find(resource_id); + if (it == Resource::map.end()) + return GRALLOC1_ERROR_BAD_HANDLE; + + Resource* res = it->second; + + // validate the lock rectangle + if (rect->width < 0 || rect->height < 0 || rect->left < 0 || rect->top < 0 || + (uint32_t)rect->width + (uint32_t)rect->left > res->args.width || + (uint32_t)rect->height + (uint32_t)rect->top > res->args.height) { + return GRALLOC1_ERROR_BAD_VALUE; + } + + uint32_t bpp; + switch (res->args.format) { + case VIRGL_FORMAT_R8_UNORM: + bpp = 1U; + break; + case VIRGL_FORMAT_B5G6R5_UNORM: + bpp = 2U; + break; + default: + bpp = 4U; + break; + } + uint32_t stride = ALIGN(res->args.width * bpp, 16U); + *outData = (char*)res->linear + rect->top * stride + rect->left * bpp; + return GRALLOC1_ERROR_NONE; +} + +static int32_t gralloc1_unlock(gralloc1_device_t*, buffer_handle_t buffer, + int32_t* outReleaseFence) { + uint32_t resource_id = (uint32_t) reinterpret_cast<uintptr_t>(buffer); + std::map<uint32_t, Resource*>::iterator it; + it = Resource::map.find(resource_id); + if (it == Resource::map.end()) + return GRALLOC1_ERROR_BAD_HANDLE; + if (outReleaseFence) + *outReleaseFence = -1; + + return GRALLOC1_ERROR_NONE; +} + +static gralloc1_function_pointer_t gralloc1_getFunction(gralloc1_device_t*, int32_t descriptor) { + switch (descriptor) { + case GRALLOC1_FUNCTION_LOCK: + return reinterpret_cast<gralloc1_function_pointer_t>(&gralloc1_lock); + case GRALLOC1_FUNCTION_UNLOCK: + return reinterpret_cast<gralloc1_function_pointer_t>(&gralloc1_unlock); + default: + return nullptr; + } +} + +static gralloc1_device_t g_gralloc1_device = { + .common = + { + .tag = HARDWARE_DEVICE_TAG, + .module = &g_gralloc1_module, + .close = gralloc1_device_close, + }, + .getCapabilities = gralloc1_getCapabilities, + .getFunction = gralloc1_getFunction, +}; + +static int gralloc1_device_open(const hw_module_t* module, const char* id, hw_device_t** device) { + if (module != &g_gralloc1_module) + return -EINVAL; + if (strcmp(id, g_gralloc1_module.id)) + return -EINVAL; + *device = &g_gralloc1_device.common; + return 0; +} + +int hw_get_module(const char* id, const hw_module_t** module) { + if (strcmp(id, g_gralloc1_module.id)) + return -EINVAL; + *module = const_cast<const hw_module_t*>(&g_gralloc1_module); + return 0; +} + +int sync_wait(int, int) { + return 0; +} diff --git a/host/libs/virglrenderer/OpenGLESDispatch/EGLDispatch.cpp b/host/libs/virglrenderer/OpenGLESDispatch/EGLDispatch.cpp index f3de1bff6..40cf7fc37 100644 --- a/host/libs/virglrenderer/OpenGLESDispatch/EGLDispatch.cpp +++ b/host/libs/virglrenderer/OpenGLESDispatch/EGLDispatch.cpp @@ -1,56 +1,51 @@ /* -* Copyright (C) 2011 The Android Open Source Project -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ -#include "OpenGLESDispatch/EGLDispatch.h" - -#include "emugl/common/shared_library.h" - + * Copyright (C) 2018 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 <OpenGLESDispatch/EGLDispatch.h> + +#include <dlfcn.h> #include <stdio.h> -#include <stdlib.h> EGLDispatch s_egl; -#define DEFAULT_EGL_LIB EMUGL_LIBNAME("EGL_translator") +#define DEFAULT_EGL_LIB "libEGL_swiftshader.so" -#define RENDER_EGL_LOAD_FIELD(return_type, function_name, signature) \ - s_egl. function_name = (function_name ## _t) lib->findSymbol(#function_name); \ +#define EGL_LOAD_FIELD(return_type, function_name, signature, callargs) \ + s_egl.function_name = (function_name##_t)dlsym(handle, #function_name); -#define RENDER_EGL_LOAD_FIELD_WITH_EGL(return_type, function_name, signature) \ - if ((!s_egl. function_name) && s_egl.eglGetProcAddress) s_egl. function_name = \ - (function_name ## _t) s_egl.eglGetProcAddress(#function_name); \ +#define EGL_LOAD_FIELD_WITH_EGL(return_type, function_name, signature, callargs) \ + if ((!s_egl.function_name) && s_egl.eglGetProcAddress) \ + s_egl.function_name = (function_name##_t)s_egl.eglGetProcAddress(#function_name); -#define RENDER_EGL_LOAD_OPTIONAL_FIELD(return_type, function_name, signature) \ - if (s_egl.eglGetProcAddress) s_egl. function_name = \ - (function_name ## _t) s_egl.eglGetProcAddress(#function_name); \ - if (!s_egl.function_name || !s_egl.eglGetProcAddress) \ - RENDER_EGL_LOAD_FIELD(return_type, function_name, signature) +#define EGL_LOAD_OPTIONAL_FIELD(return_type, function_name, signature, callargs) \ + if (s_egl.eglGetProcAddress) \ + s_egl.function_name = (function_name##_t)s_egl.eglGetProcAddress(#function_name); \ + if (!s_egl.function_name || !s_egl.eglGetProcAddress) \ + EGL_LOAD_FIELD(return_type, function_name, signature, callargs) -bool init_egl_dispatch() { - const char *libName = getenv("ANDROID_EGL_LIB"); - if (!libName) libName = DEFAULT_EGL_LIB; - char error[256]; - emugl::SharedLibrary *lib = emugl::SharedLibrary::open(libName, error, sizeof(error)); - if (!lib) { - printf("Failed to open %s: [%s]\n", libName, error); +bool egl_dispatch_init() { + void* handle = dlopen(DEFAULT_EGL_LIB, RTLD_NOW); + if (!handle) { + printf("Failed to open %s\n", dlerror()); return false; } - LIST_RENDER_EGL_FUNCTIONS(RENDER_EGL_LOAD_FIELD) - LIST_RENDER_EGL_FUNCTIONS(RENDER_EGL_LOAD_FIELD_WITH_EGL) - LIST_RENDER_EGL_EXTENSIONS_FUNCTIONS(RENDER_EGL_LOAD_OPTIONAL_FIELD) - LIST_RENDER_EGL_SNAPSHOT_FUNCTIONS(RENDER_EGL_LOAD_FIELD) + LIST_EGL_FUNCTIONS(EGL_LOAD_FIELD) + LIST_EGL_FUNCTIONS(EGL_LOAD_FIELD_WITH_EGL) + LIST_EGL_EXTENSIONS_FUNCTIONS(EGL_LOAD_OPTIONAL_FIELD) return true; } diff --git a/host/libs/virglrenderer/OpenGLESDispatch/EGLDispatch.h b/host/libs/virglrenderer/OpenGLESDispatch/EGLDispatch.h index 58102e95a..eb3cd880a 100644 --- a/host/libs/virglrenderer/OpenGLESDispatch/EGLDispatch.h +++ b/host/libs/virglrenderer/OpenGLESDispatch/EGLDispatch.h @@ -1,56 +1,41 @@ /* -* Copyright (C) 2011 The Android Open Source Project -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ -#pragma once - -#include "OpenGLESDispatch/RenderEGL_functions.h" -#include "OpenGLESDispatch/RenderEGL_extensions_functions.h" -#include "OpenGLESDispatch/RenderEGL_snapshot_functions.h" + * Copyright (C) 2018 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. + */ -// This header is used to define the EGLDispatch structure that contains -// pointers to the EGL shared library used by libOpenglRender. Normally, -// this will be our own libEGL_translator, but one could imagine a -// vendor-specific being used instead. +#pragma once -// There is a single global instance of this structure, named |s_egl|, -// which must be initialized by calling init_egl_dispatch() before use. +#include <EGL/egl.h> +#include <EGL/eglext.h> -// Note that our code requires the implementation of misc EGL extensions -// including eglSetSwapRectangleANDROID(), see RenderEGL_extensions_functions.h -// for a full list. +#include <OpenGLESDispatch/egl_functions.h> +#include <OpenGLESDispatch/egl_extensions_functions.h> -#define RENDER_EGL_DEFINE_TYPE(return_type, function_name, signature) \ - typedef return_type (EGLAPIENTRY *function_name ## _t) signature; +#define EGL_DEFINE_TYPE(return_type, function_name, signature, callargs) \ + typedef return_type(EGLAPIENTRY* function_name##_t) signature; -#define RENDER_EGL_DECLARE_MEMBER(return_type, function_name, signature) \ - function_name ## _t function_name; +#define EGL_DECLARE_MEMBER(return_type, function_name, signature, callargs) \ + function_name##_t function_name; -// Define function typedefs. -LIST_RENDER_EGL_FUNCTIONS(RENDER_EGL_DEFINE_TYPE) -LIST_RENDER_EGL_EXTENSIONS_FUNCTIONS(RENDER_EGL_DEFINE_TYPE) -LIST_RENDER_EGL_SNAPSHOT_FUNCTIONS(RENDER_EGL_DEFINE_TYPE) +LIST_EGL_FUNCTIONS(EGL_DEFINE_TYPE) +LIST_EGL_EXTENSIONS_FUNCTIONS(EGL_DEFINE_TYPE) -// Define EGLDispatch structure. struct EGLDispatch { - LIST_RENDER_EGL_FUNCTIONS(RENDER_EGL_DECLARE_MEMBER) - LIST_RENDER_EGL_EXTENSIONS_FUNCTIONS(RENDER_EGL_DECLARE_MEMBER) - LIST_RENDER_EGL_SNAPSHOT_FUNCTIONS(RENDER_EGL_DECLARE_MEMBER) + LIST_EGL_FUNCTIONS(EGL_DECLARE_MEMBER) + LIST_EGL_EXTENSIONS_FUNCTIONS(EGL_DECLARE_MEMBER) }; -// Initialize EGLDispatch function. Return true on success, false on failure. -bool init_egl_dispatch(); +bool egl_dispatch_init(); -// Global EGLDispatch instance. Call init_egl_dispatch() before using it. extern EGLDispatch s_egl; diff --git a/host/libs/virglrenderer/OpenGLESDispatch/GLESv1Dispatch.cpp b/host/libs/virglrenderer/OpenGLESDispatch/GLESv1Dispatch.cpp index fd520cb90..fd25afc5d 100644 --- a/host/libs/virglrenderer/OpenGLESDispatch/GLESv1Dispatch.cpp +++ b/host/libs/virglrenderer/OpenGLESDispatch/GLESv1Dispatch.cpp @@ -1,224 +1,42 @@ /* -* Copyright (C) 2011 The Android Open Source Project -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ -#include "OpenGLESDispatch/GLESv1Dispatch.h" - -#include "OpenGLESDispatch/EGLDispatch.h" - -#include "android/utils/debug.h" - + * Copyright (C) 2018 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 <OpenGLESDispatch/EGLDispatch.h> +#include <OpenGLESDispatch/GLESv1Dispatch.h> + +#include <dlfcn.h> #include <stdio.h> -#include <stdlib.h> -#include <string.h> - -#include "emugl/common/shared_library.h" - -#define DEBUG 0 - -#if DEBUG -#define DPRINT(...) do { \ - if (!VERBOSE_CHECK(gles1emu)) VERBOSE_ENABLE(gles1emu); \ - VERBOSE_PRINT(gles1emu, __VA_ARGS__); \ -} while (0) -#else -#define DPRINT(...) -#endif - -static emugl::SharedLibrary *s_gles1_lib = NULL; -static emugl::SharedLibrary *s_underlying_gles2_lib = NULL; - -// An unimplemented function which prints out an error message. -// To make it consistent with the guest, all GLES1 functions not supported by -// the guest driver should be redirected to this function. - -void gles1_unimplemented() { - fprintf(stderr, "Called unimplemented GLESv1 API\n"); -} - -#define DEFAULT_GLES_CM_LIB EMUGL_LIBNAME("GLES_CM_translator") -#define DEFAULT_UNDERLYING_GLES_V2_LIB EMUGL_LIBNAME("GLES_V2_translator") - -// This section of code (also in GLDispatch.cpp) -// initializes all GLESv1 functions to dummy ones; -// that is, in case we are using a library that doesn't -// have GLESv1, we will still have stubs available to -// signal that they are unsupported on the host. -#define RETURN_void return -#define RETURN_GLboolean return GL_FALSE -#define RETURN_GLint return 0 -#define RETURN_GLuint return 0U -#define RETURN_GLenum return 0 -#define RETURN_int return 0 -#define RETURN_GLconstubyteptr return NULL -#define RETURN_voidptr return NULL - -#define RETURN_(x) RETURN_ ## x - -#define DUMMY_MSG "Call to %s: host OpenGL driver does not support OpenGL ES v1. Skipping." - -#ifdef _WIN32 - -#define DEFINE_DUMMY_FUNCTION(return_type, func_name, signature, args) \ -static return_type __stdcall gles1_dummy_##func_name signature { \ - fprintf(stderr, DUMMY_MSG, #func_name); \ - RETURN_(return_type); \ -} - -#define DEFINE_DUMMY_EXTENSION_FUNCTION(return_type, func_name, signature, args) \ -static return_type __stdcall gles1_dummy_##func_name signature { \ - fprintf(stderr, DUMMY_MSG, #func_name); \ - RETURN_(return_type); \ -} - -#else - -#define DEFINE_DUMMY_FUNCTION(return_type, func_name, signature, args) \ -static return_type gles1_dummy_##func_name signature { \ - fprintf(stderr, DUMMY_MSG, #func_name); \ - RETURN_(return_type); \ -} - -#define DEFINE_DUMMY_EXTENSION_FUNCTION(return_type, func_name, signature, args) \ -static return_type gles1_dummy_##func_name signature { \ - fprintf(stderr, DUMMY_MSG, #func_name); \ - RETURN_(return_type); \ -} +#define DEFAULT_GLES_CM_LIB "libGLES_CM_swiftshader.so" -#endif +GLESv1Dispatch s_gles1; -LIST_GLES1_FUNCTIONS(DEFINE_DUMMY_FUNCTION, DEFINE_DUMMY_EXTENSION_FUNCTION); -LIST_GLES12_TR_FUNCTIONS(DEFINE_DUMMY_FUNCTION); +#define LOOKUP_SYMBOL(return_type, function_name, signature, callargs) \ + s_gles1.function_name = (function_name##_t)dlsym(handle, #function_name); \ + if ((!s_gles1.function_name) && s_egl.eglGetProcAddress) \ + s_gles1.function_name = (function_name##_t)s_egl.eglGetProcAddress(#function_name); -// -// This function is called only once during initialiation before -// any thread has been created - hence it should NOT be thread safe. -// - -// -// init dummy GLESv1 dispatch table -// -#define ASSIGN_DUMMY(return_type,function_name,signature,callargs) do { \ - dispatch_table-> function_name = gles1_dummy_##function_name; \ - } while(0); - -bool gles1_dispatch_init(GLESv1Dispatch* dispatch_table) { - - dispatch_table->underlying_gles2_api = NULL; - - const char* libName = getenv("ANDROID_GLESv1_LIB"); - if (!libName) { - libName = DEFAULT_GLES_CM_LIB; +bool gles1_dispatch_init() { + void* handle = dlopen(DEFAULT_GLES_CM_LIB, RTLD_NOW); + if (!handle) { + printf("Failed to open %s\n", dlerror()); + return false; } - // If emugl_config has detected specifically a backend - // that supports only GLESv2, set GLESv1 entry points - // to the dummy functions. - if (!strcmp(libName, "<gles2_only_backend>")) { - - LIST_GLES1_FUNCTIONS(ASSIGN_DUMMY,ASSIGN_DUMMY) - - DPRINT("assigning dummies because <gles2_only_backend>"); - return true; - } else { - - char error[256]; - s_gles1_lib = emugl::SharedLibrary::open(libName, error, sizeof(error)); - if (!s_gles1_lib) { - fprintf(stderr, "%s: Could not load %s [%s]\n", __FUNCTION__, - libName, error); - return false; - } - - // - // init the GLES dispatch table - // -#define LOOKUP_SYMBOL(return_type,function_name,signature,callargs) do { \ - dispatch_table-> function_name = reinterpret_cast< function_name ## _t >( \ - s_gles1_lib->findSymbol(#function_name)); \ - if ((!dispatch_table-> function_name) && s_egl.eglGetProcAddress) \ - dispatch_table-> function_name = reinterpret_cast< function_name ## _t >( \ - s_egl.eglGetProcAddress(#function_name)); \ - } while(0); \ - - LIST_GLES1_FUNCTIONS(LOOKUP_SYMBOL,LOOKUP_SYMBOL) - - DPRINT("successful"); - - LIST_GLES12_TR_FUNCTIONS(ASSIGN_DUMMY); - - // If we are using the translator, - // import the gles1->2 translator dll - if (strstr(libName, "GLES12Translator")) { + LIST_GLES1_FUNCTIONS(LOOKUP_SYMBOL, LOOKUP_SYMBOL) - DPRINT("trying to assign gles12-specific functions"); - LIST_GLES12_TR_FUNCTIONS(LOOKUP_SYMBOL); - DPRINT("hopefully, successfully assigned " - "12tr-specific functions..."); - - DPRINT("Now creating the underlying api"); - UnderlyingApis* gles2api = - (UnderlyingApis*)dispatch_table->create_underlying_api(); - dispatch_table->underlying_gles2_api = gles2api; - - DPRINT("api ptr:%p", dispatch_table->underlying_gles2_api); - -#define SET_UNDERLYING_GLES2_FUNC(rett, function_name, sig, callargs) do { \ - dispatch_table->underlying_gles2_api->angle-> function_name = \ - reinterpret_cast< function_name ## _t >( \ - s_underlying_gles2_lib->findSymbol(#function_name)); \ -} while(0); - - DPRINT("trying to initialize GLESv1->2 translation"); - const char* underlying_gles2_lib_name = - getenv("ANDROID_GLESv2_LIB"); - - if (!underlying_gles2_lib_name) { - underlying_gles2_lib_name = DEFAULT_UNDERLYING_GLES_V2_LIB; - } - s_underlying_gles2_lib = - emugl::SharedLibrary::open(underlying_gles2_lib_name, - error, sizeof(error)); - if (!s_underlying_gles2_lib) { - DPRINT("Could not load underlying gles2 lib %s [%s]", - libName, error); - return false; - } - DPRINT("done trying to get gles2 lib"); - - LIST_GLES2_FUNCTIONS(SET_UNDERLYING_GLES2_FUNC, - SET_UNDERLYING_GLES2_FUNC); - } - return true; - } -} - -// -// This function is called only during initialization of the decoder before -// any thread has been created - hence it should NOT be thread safe. -// -void *gles1_dispatch_get_proc_func(const char *name, void *userData) -{ - void* func = NULL; - if (s_gles1_lib) { - func = (void *)s_gles1_lib->findSymbol(name); - } - // To make it consistent with the guest, redirect any unsupported functions - // to gles1_unimplemented. - if (!func) { - func = (void *)gles1_unimplemented; - } - return func; + return true; } diff --git a/host/libs/virglrenderer/OpenGLESDispatch/GLESv1Dispatch.h b/host/libs/virglrenderer/OpenGLESDispatch/GLESv1Dispatch.h index ad71f81d2..b65b83cdc 100644 --- a/host/libs/virglrenderer/OpenGLESDispatch/GLESv1Dispatch.h +++ b/host/libs/virglrenderer/OpenGLESDispatch/GLESv1Dispatch.h @@ -1,49 +1,40 @@ /* -* Copyright (C) 2011 The Android Open Source Project -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ + * Copyright (C) 2018 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 "OpenGLESDispatch/gldefs.h" -#include "OpenGLESDispatch/gles_functions.h" -#include "KHR/khrplatform.h" +#include <GLES/gl.h> + +#include <OpenGLESDispatch/gles_functions.h> -#include "GLES12Translator/underlying_apis.h" +#define GLES1_DISPATCH_DEFINE_TYPE(return_type, func_name, signature, callargs) \ + typedef return_type(KHRONOS_APIENTRY* func_name##_t) signature; -// Define function pointer types. -#define GLES1_DISPATCH_DEFINE_TYPE(return_type,func_name,signature,callargs) \ - typedef return_type (KHRONOS_APIENTRY * func_name ## _t) signature; +#define GLES1_DISPATCH_DECLARE_POINTER(return_type, func_name, signature, callargs) \ + func_name##_t func_name; -LIST_GLES1_FUNCTIONS(GLES1_DISPATCH_DEFINE_TYPE,GLES1_DISPATCH_DEFINE_TYPE) - LIST_GLES12_TR_FUNCTIONS(GLES1_DISPATCH_DEFINE_TYPE) +LIST_GLES1_FUNCTIONS(GLES1_DISPATCH_DEFINE_TYPE, GLES1_DISPATCH_DEFINE_TYPE) struct GLESv1Dispatch { -#define GLES1_DISPATCH_DECLARE_POINTER(return_type,func_name,signature,callargs) \ - func_name ## _t func_name; - LIST_GLES1_FUNCTIONS(GLES1_DISPATCH_DECLARE_POINTER, - GLES1_DISPATCH_DECLARE_POINTER) - LIST_GLES12_TR_FUNCTIONS(GLES1_DISPATCH_DECLARE_POINTER) - UnderlyingApis* underlying_gles2_api; + LIST_GLES1_FUNCTIONS(GLES1_DISPATCH_DECLARE_POINTER, GLES1_DISPATCH_DECLARE_POINTER) }; -#undef GLES1_DISPATCH_DECLARE_POINTER #undef GLES1_DISPATCH_DEFINE_TYPE +#undef GLES1_DISPATCH_DECLARE_POINTER -bool gles1_dispatch_init(GLESv1Dispatch* dispatch_table); - -// Used to initialize the decoder. -void* gles1_dispatch_get_proc_func(const char* name, void* userData); +bool gles1_dispatch_init(); -// Used to check for unimplemented. -void gles1_unimplemented(); +extern GLESv1Dispatch s_gles1; diff --git a/host/libs/virglrenderer/OpenGLESDispatch/GLESv3Dispatch.cpp b/host/libs/virglrenderer/OpenGLESDispatch/GLESv3Dispatch.cpp index 24b73012d..4aaa5180c 100644 --- a/host/libs/virglrenderer/OpenGLESDispatch/GLESv3Dispatch.cpp +++ b/host/libs/virglrenderer/OpenGLESDispatch/GLESv3Dispatch.cpp @@ -1,88 +1,42 @@ /* -* Copyright (C) 2011 The Android Open Source Project -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ -#include "OpenGLESDispatch/GLESv2Dispatch.h" - -#include "OpenGLESDispatch/EGLDispatch.h" - + * Copyright (C) 2018 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 <OpenGLESDispatch/EGLDispatch.h> +#include <OpenGLESDispatch/GLESv3Dispatch.h> + +#include <dlfcn.h> #include <stdio.h> -#include <stdlib.h> -#include <string.h> - -#include "emugl/common/shared_library.h" -static emugl::SharedLibrary *s_gles2_lib = NULL; +#define DEFAULT_GLESv2_LIB "libGLESv2_swiftshader.so" -#define DEFAULT_GLES_V2_LIB EMUGL_LIBNAME("GLES_V2_translator") - -// An unimplemented function which prints out an error message. -// To make it consistent with the guest, all GLES2 functions not supported by -// the driver should be redirected to this function. - -void gles2_unimplemented() { - fprintf(stderr, "Called unimplemented GLES API\n"); -} +GLESv3Dispatch s_gles3; -// -// This function is called only once during initialiation before -// any thread has been created - hence it should NOT be thread safe. -// -bool gles2_dispatch_init(GLESv2Dispatch* dispatch_table) -{ - const char *libName = getenv("ANDROID_GLESv2_LIB"); - if (!libName) { - libName = DEFAULT_GLES_V2_LIB; - } +#define LOOKUP_SYMBOL(return_type, function_name, signature, callargs) \ + s_gles3.function_name = (function_name##_t)dlsym(handle, #function_name); \ + if ((!s_gles3.function_name) && s_egl.eglGetProcAddress) \ + s_gles3.function_name = (function_name##_t)s_egl.eglGetProcAddress(#function_name); - char error[256]; - s_gles2_lib = emugl::SharedLibrary::open(libName, error, sizeof(error)); - if (!s_gles2_lib) { - fprintf(stderr, "%s: Could not load %s [%s]\n", __FUNCTION__, - libName, error); +bool gles3_dispatch_init() { + void* handle = dlopen(DEFAULT_GLESv2_LIB, RTLD_NOW); + if (!handle) { + printf("Failed to open %s\n", dlerror()); return false; } - // - // init the GLES dispatch table - // -#define LOOKUP_SYMBOL(return_type,function_name,signature,callargs) \ - dispatch_table-> function_name = reinterpret_cast< function_name ## _t >( \ - s_gles2_lib->findSymbol(#function_name)); \ - if ((!dispatch_table-> function_name) && s_egl.eglGetProcAddress) \ - dispatch_table-> function_name = reinterpret_cast< function_name ## _t >( \ - s_egl.eglGetProcAddress(#function_name)); \ - - LIST_GLES2_FUNCTIONS(LOOKUP_SYMBOL,LOOKUP_SYMBOL) + LIST_GLES3_FUNCTIONS(LOOKUP_SYMBOL, LOOKUP_SYMBOL) return true; } - -// -// This function is called only during initialization before -// any thread has been created - hence it should NOT be thread safe. -// -void *gles2_dispatch_get_proc_func(const char *name, void *userData) -{ - void* func = NULL; - if (s_gles2_lib) { - func = (void *)s_gles2_lib->findSymbol(name); - } - // To make it consistent with the guest, redirect any unsupported functions - // to gles2_unimplemented. - if (!func) { - func = (void *)gles2_unimplemented; - } - return func; -} diff --git a/host/libs/virglrenderer/OpenGLESDispatch/GLESv3Dispatch.h b/host/libs/virglrenderer/OpenGLESDispatch/GLESv3Dispatch.h index 00841567f..afdd0007d 100644 --- a/host/libs/virglrenderer/OpenGLESDispatch/GLESv3Dispatch.h +++ b/host/libs/virglrenderer/OpenGLESDispatch/GLESv3Dispatch.h @@ -1,56 +1,41 @@ /* -* Copyright (C) 2011 The Android Open Source Project -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ + * Copyright (C) 2018 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 "OpenGLESDispatch/gldefs.h" -#include "OpenGLESDispatch/gles_functions.h" -#include "KHR/khrplatform.h" +#include <GLES3/gl31.h> + +#include <OpenGLESDispatch/gles_functions.h> // Define function pointer types. -#define GLES2_DISPATCH_DEFINE_TYPE(return_type,func_name,signature,callargs) \ - typedef return_type (KHRONOS_APIENTRY * func_name ## _t) signature; +#define GLES3_DISPATCH_DEFINE_TYPE(return_type, func_name, signature, callargs) \ + typedef return_type(KHRONOS_APIENTRY* func_name##_t) signature; -LIST_GLES2_FUNCTIONS(GLES2_DISPATCH_DEFINE_TYPE,GLES2_DISPATCH_DEFINE_TYPE) +#define GLES3_DISPATCH_DECLARE_POINTER(return_type, func_name, signature, callargs) \ + func_name##_t func_name; -struct GLESv2Dispatch { -#define GLES2_DISPATCH_DECLARE_POINTER(return_type,func_name,signature,callargs) \ - func_name ## _t func_name; - LIST_GLES2_FUNCTIONS(GLES2_DISPATCH_DECLARE_POINTER, - GLES2_DISPATCH_DECLARE_POINTER) -}; +LIST_GLES3_FUNCTIONS(GLES3_DISPATCH_DEFINE_TYPE, GLES3_DISPATCH_DEFINE_TYPE) -#undef GLES2_DISPATCH_DECLARE_POINTER -#undef GLES2_DISPATCH_DEFINE_TYPE - -bool gles2_dispatch_init(GLESv2Dispatch* dispatch_table); - -// Used to initialize the decoder. -void* gles2_dispatch_get_proc_func(const char* name, void* userData); -// Used to check for unimplemented. -void gles2_unimplemented(); - -// Used to query max GLES version support based on what the dispatch mechanism -// has found in the GLESv2 library. -// First, a enum for tracking the detected GLES version based on dispatch. -// We support 2 minimally. -enum GLESDispatchMaxVersion { - GLES_DISPATCH_MAX_VERSION_2 = 0, - GLES_DISPATCH_MAX_VERSION_3_0 = 1, - GLES_DISPATCH_MAX_VERSION_3_1 = 2, - GLES_DISPATCH_MAX_VERSION_3_2 = 3, +struct GLESv3Dispatch { + LIST_GLES3_FUNCTIONS(GLES3_DISPATCH_DECLARE_POINTER, GLES3_DISPATCH_DECLARE_POINTER) }; -GLESDispatchMaxVersion gles2_dispatch_get_max_version(); +#undef GLES3_DISPATCH_DEFINE_TYPE +#undef GLES3_DISPATCH_DECLARE_POINTER + +bool gles3_dispatch_init(); + +extern GLESv3Dispatch s_gles3; diff --git a/host/libs/virglrenderer/OpenGLESDispatch/egl.entries b/host/libs/virglrenderer/OpenGLESDispatch/egl.entries index e6279a3ed..46d4c0dd8 100644 --- a/host/libs/virglrenderer/OpenGLESDispatch/egl.entries +++ b/host/libs/virglrenderer/OpenGLESDispatch/egl.entries @@ -1,28 +1,44 @@ -# The list of EGL functions used by libOpenglRender, without extensions. -# This is only a subset of the full EGL API. +!egl -!Render_EGL %#include <EGL/egl.h> +%// Return types must be single words, see GLDispatch.cpp +%typedef const char* EGLconstcharptr; + +EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config); +EGLBoolean eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target); +EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list); +EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list); +EGLSurface eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list); +EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list); +EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx); +EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface); +EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value); +EGLBoolean eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config); +EGLDisplay eglGetCurrentDisplay(void); +EGLSurface eglGetCurrentSurface(EGLint readdraw); +EGLDisplay eglGetDisplay(EGLNativeDisplayType display_id); EGLint eglGetError(void); -EGLDisplay eglGetDisplay(EGLNativeDisplayType dpy); +void* eglGetProcAddress(const char *procname); +EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor); +EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx); +EGLBoolean eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value); +EGLconstcharptr eglQueryString(EGLDisplay dpy, EGLint name); +EGLBoolean eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value); +EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface); EGLBoolean eglTerminate(EGLDisplay dpy); -EGLBoolean eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor); -char* eglQueryString(EGLDisplay dpy, EGLint id); -EGLBoolean eglGetConfigs(EGLDisplay display, EGLConfig* configs, EGLint config_size, EGLint* num_config); -EGLBoolean eglChooseConfig(EGLDisplay display, const EGLint* attribs, EGLConfig* configs, EGLint config_size, EGLint* num_config); -EGLBoolean eglGetConfigAttrib(EGLDisplay display, EGLConfig config, EGLint attribute, EGLint* value); -EGLSurface eglCreateWindowSurface(EGLDisplay display, EGLConfig config, EGLNativeWindowType native_window, const EGLint* attrib_list); -EGLSurface eglCreatePbufferSurface(EGLDisplay display, EGLConfig config, const EGLint* attrib_list); -EGLBoolean eglDestroySurface(EGLDisplay display, EGLSurface surface); +EGLBoolean eglWaitGL(void); +EGLBoolean eglWaitNative(EGLint engine); + +EGLBoolean eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer); +EGLBoolean eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer); +EGLBoolean eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value); +EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval); + EGLBoolean eglBindAPI(EGLenum api); EGLenum eglQueryAPI(void); +EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list); EGLBoolean eglReleaseThread(void); -EGLContext eglCreateContext(EGLDisplay display, EGLConfig config, EGLContext share_context, const EGLint* attrib_list); -EGLBoolean eglDestroyContext(EGLDisplay display, EGLContext context); -EGLBoolean eglMakeCurrent(EGLDisplay display, EGLSurface draw, EGLSurface read, EGLContext context); +EGLBoolean eglWaitClient(void); + EGLContext eglGetCurrentContext(void); -EGLSurface eglGetCurrentSurface(EGLint readdraw); -EGLBoolean eglQuerySurface(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint *value); -EGLBoolean eglSwapBuffers(EGLDisplay display, EGLSurface surface); -void* eglGetProcAddress(const char* function_name); diff --git a/host/libs/virglrenderer/OpenGLESDispatch/egl_extensions.entries b/host/libs/virglrenderer/OpenGLESDispatch/egl_extensions.entries index 186f1f06e..e1e0bc7de 100644 --- a/host/libs/virglrenderer/OpenGLESDispatch/egl_extensions.entries +++ b/host/libs/virglrenderer/OpenGLESDispatch/egl_extensions.entries @@ -1,19 +1,11 @@ -# The list of EGL extension functions used by libOpenglRender. -# This is only a subset of the full EGL API. +!egl_extensions -!Render_EGL_extensions - -%#include <EGL/egl.h> -%#define EGL_EGLEXT_PROTOTYPES %#include <EGL/eglext.h> -EGLImageKHR eglCreateImageKHR(EGLDisplay display, EGLContext context, EGLenum target, EGLClientBuffer buffer, const EGLint* attrib_list); -EGLBoolean eglDestroyImageKHR(EGLDisplay display, EGLImageKHR image); -EGLSyncKHR eglCreateSyncKHR(EGLDisplay display, EGLenum type, const EGLint* attribs); -EGLint eglClientWaitSyncKHR(EGLDisplay display, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout); -EGLint eglWaitSyncKHR(EGLDisplay display, EGLSyncKHR sync, EGLint flags); -EGLBoolean eglDestroySyncKHR(EGLDisplay display, EGLSyncKHR sync); -EGLint eglGetMaxGLESVersion(EGLDisplay display); -void eglBlitFromCurrentReadBufferANDROID(EGLDisplay display, EGLImageKHR image); -void* eglSetImageFenceANDROID(EGLDisplay display, EGLImageKHR image); -void eglWaitImageFenceANDROID(EGLDisplay display, void* fence); +EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list); +EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync); +EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout); +EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value); + +EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list); +EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image); diff --git a/host/libs/virglrenderer/OpenGLESDispatch/gles1_core.entries b/host/libs/virglrenderer/OpenGLESDispatch/gles1_core.entries index f42e279f3..8c7f95376 100644 --- a/host/libs/virglrenderer/OpenGLESDispatch/gles1_core.entries +++ b/host/libs/virglrenderer/OpenGLESDispatch/gles1_core.entries @@ -1,16 +1,153 @@ -!gles12_tr +!gles1_core -# Functions which are needed ONLY for implementing GLES 1->2 translation +%#include <GLES/gl.h> -%typedef void* voidptr; +%// Return types must be single words, see GLDispatch.cpp +%typedef const GLubyte* GL1constubyteptr; -voidptr create_gles1_context(void* share, const void* underlying_apis); -voidptr get_current_gles_context(void); -void set_current_gles_context(void* ctx); -voidptr create_underlying_api(void); +void glAlphaFunc(GLenum func, GLclampf ref); +void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +void glClearDepthf(GLclampf depth); +void glClipPlanef(GLenum plane, const GLfloat *equation); +void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void glDepthRangef(GLclampf zNear, GLclampf zFar); +void glFogf(GLenum pname, GLfloat param); +void glFogfv(GLenum pname, const GLfloat *params); +void glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); +void glGetClipPlanef(GLenum pname, GLfloat *eqn); +void glGetFloatv(GLenum pname, GLfloat *params); +void glGetLightfv(GLenum light, GLenum pname, GLfloat *params); +void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params); +void glGetTexEnvfv(GLenum env, GLenum pname, GLfloat *params); +void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params); +void glLightModelf(GLenum pname, GLfloat param); +void glLightModelfv(GLenum pname, const GLfloat *params); +void glLightf(GLenum light, GLenum pname, GLfloat param); +void glLightfv(GLenum light, GLenum pname, const GLfloat *params); +void glLineWidth(GLfloat width); +void glLoadMatrixf(const GLfloat *m); +void glMaterialf(GLenum face, GLenum pname, GLfloat param); +void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params); +void glMultMatrixf(const GLfloat *m); +void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz); +void glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); +void glPointParameterf(GLenum pname, GLfloat param); +void glPointParameterfv(GLenum pname, const GLfloat *params); +void glPointSize(GLfloat size); +void glPolygonOffset(GLfloat factor, GLfloat units); +void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void glScalef(GLfloat x, GLfloat y, GLfloat z); +void glTexEnvf(GLenum target, GLenum pname, GLfloat param); +void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params); +void glTexParameterf(GLenum target, GLenum pname, GLfloat param); +void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params); +void glTranslatef(GLfloat x, GLfloat y, GLfloat z); +void glActiveTexture(GLenum texture); +void glAlphaFuncx(GLenum func, GLclampx ref); +void glBindBuffer(GLenum target, GLuint buffer); +void glBindTexture(GLenum target, GLuint texture); +void glBlendFunc(GLenum sfactor, GLenum dfactor); +void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage); +void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data); +void glClear(GLbitfield mask); +void glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha); +void glClearDepthx(GLclampx depth); +void glClearStencil(GLint s); +void glClientActiveTexture(GLenum texture); +void glClipPlanex(GLenum plane, const GLfixed *equation); +void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha); +void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); +void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data); +void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data); +void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void glCullFace(GLenum mode); +void glDeleteBuffers(GLsizei n, const GLuint *buffers); +void glDeleteTextures(GLsizei n, const GLuint *textures); +void glDepthFunc(GLenum func); +void glDepthMask(GLboolean flag); +void glDepthRangex(GLclampx zNear, GLclampx zFar); +void glDisable(GLenum cap); +void glDisableClientState(GLenum array); +void glDrawArrays(GLenum mode, GLint first, GLsizei count); +void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices); +void glEnable(GLenum cap); +void glEnableClientState(GLenum array); +void glFinish(void); +void glFlush(void); +void glFogx(GLenum pname, GLfixed param); +void glFogxv(GLenum pname, const GLfixed *params); +void glFrontFace(GLenum mode); +void glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); +void glGetBooleanv(GLenum pname, GLboolean *params); +void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params); +void glGetClipPlanex(GLenum pname, GLfixed *eqn); +void glGenBuffers(GLsizei n, GLuint *buffers); +void glGenTextures(GLsizei n, GLuint *textures); +GLenum glGetError(void); +void glGetFixedv(GLenum pname, GLfixed *params); +void glGetIntegerv(GLenum pname, GLint *params); +void glGetLightxv(GLenum light, GLenum pname, GLfixed *params); +void glGetMaterialxv(GLenum face, GLenum pname, GLfixed *params); +void glGetPointerv(GLenum pname, GLvoid **params); +GL1constubyteptr glGetString(GLenum name); +void glGetTexEnviv(GLenum env, GLenum pname, GLint *params); +void glGetTexEnvxv(GLenum env, GLenum pname, GLfixed *params); +void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params); +void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params); +void glHint(GLenum target, GLenum mode); +GLboolean glIsBuffer(GLuint buffer); +GLboolean glIsEnabled(GLenum cap); +GLboolean glIsTexture(GLuint texture); +void glLightModelx(GLenum pname, GLfixed param); +void glLightModelxv(GLenum pname, const GLfixed *params); +void glLightx(GLenum light, GLenum pname, GLfixed param); +void glLightxv(GLenum light, GLenum pname, const GLfixed *params); +void glLineWidthx(GLfixed width); +void glLoadIdentity(void); +void glLoadMatrixx(const GLfixed *m); +void glLogicOp(GLenum opcode); +void glMaterialx(GLenum face, GLenum pname, GLfixed param); +void glMaterialxv(GLenum face, GLenum pname, const GLfixed *params); +void glMatrixMode(GLenum mode); +void glMultMatrixx(const GLfixed *m); +void glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q); +void glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz); +void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer); +void glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); +void glPixelStorei(GLenum pname, GLint param); +void glPointParameterx(GLenum pname, GLfixed param); +void glPointParameterxv(GLenum pname, const GLfixed *params); +void glPointSizex(GLfixed size); +void glPolygonOffsetx(GLfixed factor, GLfixed units); +void glPopMatrix(void); +void glPushMatrix(void); +void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels); +void glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z); +void glSampleCoverage(GLclampf value, GLboolean invert); +void glSampleCoveragex(GLclampx value, GLboolean invert); +void glScalex(GLfixed x, GLfixed y, GLfixed z); +void glScissor(GLint x, GLint y, GLsizei width, GLsizei height); +void glShadeModel(GLenum mode); +void glStencilFunc(GLenum func, GLint ref, GLuint mask); +void glStencilMask(GLuint mask); +void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass); +void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); +void glTexEnvi(GLenum target, GLenum pname, GLint param); +void glTexEnvx(GLenum target, GLenum pname, GLfixed param); +void glTexEnviv(GLenum target, GLenum pname, const GLint *params); +void glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params); +void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels); +void glTexParameteri(GLenum target, GLenum pname, GLint param); +void glTexParameterx(GLenum target, GLenum pname, GLfixed param); +void glTexParameteriv(GLenum target, GLenum pname, const GLint *params); +void glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params); +void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); +void glTranslatex(GLfixed x, GLfixed y, GLfixed z); +void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); +void glViewport(GLint x, GLint y, GLsizei width, GLsizei height); -# Extra setup on making a emulated GLES1 context current -void make_current_setup(uint32_t surf_width, uint32_t surf_height); - -# destroying GLES1 contexts -void destroy_gles1_context(void* ctx); +void glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *pointer); diff --git a/host/libs/virglrenderer/OpenGLESDispatch/gles1_extensions.entries b/host/libs/virglrenderer/OpenGLESDispatch/gles1_extensions.entries index 2670bae7c..a2e990acf 100644 --- a/host/libs/virglrenderer/OpenGLESDispatch/gles1_extensions.entries +++ b/host/libs/virglrenderer/OpenGLESDispatch/gles1_extensions.entries @@ -1,17 +1,35 @@ !gles1_extensions -# OpenGL functions which are needed ONLY for implementing GLES 1.1 EXTENSIONS -void glCurrentPaletteMatrixARB(GLint index); -void glMatrixIndexuivARB(GLint size, GLuint * indices); -void glMatrixIndexPointerARB(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer); -void glWeightPointerARB(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer); -void glTexGenf(GLenum coord, GLenum pname, GLfloat param ); -void glTexGeni(GLenum coord, GLenum pname, GLint param ); -void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params ); -void glTexGeniv(GLenum coord, GLenum pname, const GLint *params ); -void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params ); -void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params ); -void glColorPointerWithDataSize(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer, GLsizei dataSize); -void glNormalPointerWithDataSize(GLenum type, GLsizei stride, const GLvoid *pointer, GLsizei dataSize); -void glTexCoordPointerWithDataSize(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer, GLsizei dataSize); -void glVertexPointerWithDataSize(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer, GLsizei dataSize); +%#include <GLES/glext.h> + +void glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha); +void glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +void glBlendEquationOES(GLenum mode); + +void glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height); +void glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height); +void glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height); +void glDrawTexsvOES(const GLshort *coords); +void glDrawTexivOES(const GLint *coords); +void glDrawTexxvOES(const GLfixed *coords); +void glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height); +void glDrawTexfvOES(const GLfloat *coords); + +void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image); +void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image); + +GLboolean glIsRenderbufferOES(GLuint renderbuffer); +void glBindRenderbufferOES(GLenum target, GLuint renderbuffer); +void glDeleteRenderbuffersOES(GLsizei n, const GLuint* renderbuffers); +void glGenRenderbuffersOES(GLsizei n, GLuint* renderbuffers); +void glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +void glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint* params); +GLboolean glIsFramebufferOES(GLuint framebuffer); +void glBindFramebufferOES(GLenum target, GLuint framebuffer); +void glDeleteFramebuffersOES(GLsizei n, const GLuint* framebuffers); +void glGenFramebuffersOES(GLsizei n, GLuint* framebuffers); +GLenum glCheckFramebufferStatusOES(GLenum target); +void glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint* params); +void glGenerateMipmapOES(GLenum target); diff --git a/host/libs/virglrenderer/OpenGLESDispatch/gles2_core.entries b/host/libs/virglrenderer/OpenGLESDispatch/gles2_core.entries index 0eaa0aec0..6cab5f8fa 100644 --- a/host/libs/virglrenderer/OpenGLESDispatch/gles2_core.entries +++ b/host/libs/virglrenderer/OpenGLESDispatch/gles2_core.entries @@ -1,85 +1,146 @@ -!gles2_only +!gles2_core -# OpenGL functions which are needed ONLY for implementing GLES 2.0 -void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); -void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask); -void glStencilMaskSeparate(GLenum face, GLuint mask); -void glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass); -GLboolean glIsProgram(GLuint program); -GLboolean glIsShader(GLuint shader); -void glVertexAttrib1f(GLuint indx, GLfloat x); -void glVertexAttrib1fv(GLuint indx, const GLfloat* values); -void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y); -void glVertexAttrib2fv(GLuint indx, const GLfloat* values); -void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z); -void glVertexAttrib3fv(GLuint indx, const GLfloat* values); -void glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w); -void glVertexAttrib4fv(GLuint indx, const GLfloat* values); -void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr); -void glDisableVertexAttribArray(GLuint index); -void glEnableVertexAttribArray(GLuint index); -void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params); -void glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params); -void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer); -void glUniform1f(GLint location, GLfloat x); -void glUniform1fv(GLint location, GLsizei count, const GLfloat* v); -void glUniform1i(GLint location, GLint x); -void glUniform1iv(GLint location, GLsizei count, const GLint* v); -void glUniform2f(GLint location, GLfloat x, GLfloat y); -void glUniform2fv(GLint location, GLsizei count, const GLfloat* v); -void glUniform2i(GLint location, GLint x, GLint y); -void glUniform2iv(GLint location, GLsizei count, const GLint* v); -void glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z); -void glUniform3fv(GLint location, GLsizei count, const GLfloat* v); -void glUniform3i(GLint location, GLint x, GLint y, GLint z); -void glUniform3iv(GLint location, GLsizei count, const GLint* v); -void glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w); -void glUniform4fv(GLint location, GLsizei count, const GLfloat* v); -void glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w); -void glUniform4iv(GLint location, GLsizei count, const GLint* v); -void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); -void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); -void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +%#include <GLES3/gl31.h> + +void glActiveTexture(GLenum texture); void glAttachShader(GLuint program, GLuint shader); -void glBindAttribLocation(GLuint program, GLuint index, const GLchar* name); +void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name); +void glBindBuffer(GLenum target, GLuint buffer); +void glBindFramebuffer(GLenum target, GLuint framebuffer); +void glBindRenderbuffer(GLenum target, GLuint renderbuffer); +void glBindTexture(GLenum target, GLuint texture); +void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void glBlendEquation(GLenum mode); +void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha); +void glBlendFunc(GLenum sfactor, GLenum dfactor); +void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage); +void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); +GLenum glCheckFramebufferStatus(GLenum target); +void glClear(GLbitfield mask); +void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void glClearDepthf(GLfloat d); +void glClearStencil(GLint s); +void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); void glCompileShader(GLuint shader); +void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); +void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); +void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); GLuint glCreateProgram(void); GLuint glCreateShader(GLenum type); +void glCullFace(GLenum mode); +void glDeleteBuffers(GLsizei n, const GLuint *buffers); +void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers); void glDeleteProgram(GLuint program); +void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers); void glDeleteShader(GLuint shader); +void glDeleteTextures(GLsizei n, const GLuint *textures); +void glDepthFunc(GLenum func); +void glDepthMask(GLboolean flag); +void glDepthRangef(GLfloat n, GLfloat f); void glDetachShader(GLuint program, GLuint shader); -void glLinkProgram(GLuint program); -void glUseProgram(GLuint program); -void glValidateProgram(GLuint program); -void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name); -void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name); -void glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders); -int glGetAttribLocation(GLuint program, const GLchar* name); -void glGetProgramiv(GLuint program, GLenum pname, GLint* params); -void glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog); -void glGetShaderiv(GLuint shader, GLenum pname, GLint* params); -void glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog); -void glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source); -void glGetUniformfv(GLuint program, GLint location, GLfloat* params); -void glGetUniformiv(GLuint program, GLint location, GLint* params); -int glGetUniformLocation(GLuint program, const GLchar* name); -void glShaderSource(GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length); - -# The following are not used by GLDispatch but by GLESv2Dispatch -void glBindFramebuffer(GLenum target, GLuint framebuffer); -void glGenFramebuffers(GLsizei n, GLuint* framebuffers); +void glDisable(GLenum cap); +void glDisableVertexAttribArray(GLuint index); +void glDrawArrays(GLenum mode, GLint first, GLsizei count); +void glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices); +void glEnable(GLenum cap); +void glEnableVertexAttribArray(GLuint index); +void glFinish(void); +void glFlush(void); +void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); -GLenum glCheckFramebufferStatus(GLenum target); +void glFrontFace(GLenum mode); +void glGenBuffers(GLsizei n, GLuint *buffers); +void glGenerateMipmap(GLenum target); +void glGenFramebuffers(GLsizei n, GLuint *framebuffers); +void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers); +void glGenTextures(GLsizei n, GLuint *textures); +void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); +GLint glGetAttribLocation(GLuint program, const GLchar *name); +void glGetBooleanv(GLenum pname, GLboolean *data); +void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params); +GLenum glGetError(void); +void glGetFloatv(GLenum pname, GLfloat *data); +void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params); +void glGetIntegerv(GLenum pname, GLint *data); +void glGetProgramiv(GLuint program, GLenum pname, GLint *params); +void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params); +void glGetShaderiv(GLuint shader, GLenum pname, GLint *params); +void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision); +void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +const GLubyte *glGetString(GLenum name); +void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params); +void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params); +void glGetUniformfv(GLuint program, GLint location, GLfloat *params); +void glGetUniformiv(GLuint program, GLint location, GLint *params); +GLint glGetUniformLocation(GLuint program, const GLchar *name); +void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params); +void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params); +void glGetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer); +void glHint(GLenum target, GLenum mode); +GLboolean glIsBuffer(GLuint buffer); +GLboolean glIsEnabled(GLenum cap); GLboolean glIsFramebuffer(GLuint framebuffer); -void glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers); - +GLboolean glIsProgram(GLuint program); GLboolean glIsRenderbuffer(GLuint renderbuffer); -void glBindRenderbuffer(GLenum target, GLuint renderbuffer); -void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers); -void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers); +GLboolean glIsShader(GLuint shader); +GLboolean glIsTexture(GLuint texture); +void glLineWidth(GLfloat width); +void glLinkProgram(GLuint program); +void glPixelStorei(GLenum pname, GLint param); +void glPolygonOffset(GLfloat factor, GLfloat units); +void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); +void glReleaseShaderCompiler(void); void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); -void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params); -void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); -void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params); - -void glGenerateMipmap(GLenum target); +void glSampleCoverage(GLfloat value, GLboolean invert); +void glScissor(GLint x, GLint y, GLsizei width, GLsizei height); +void glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length); +void glShaderSource(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); +void glStencilFunc(GLenum func, GLint ref, GLuint mask); +void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask); +void glStencilMask(GLuint mask); +void glStencilMaskSeparate(GLenum face, GLuint mask); +void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass); +void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); +void glTexParameterf(GLenum target, GLenum pname, GLfloat param); +void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params); +void glTexParameteri(GLenum target, GLenum pname, GLint param); +void glTexParameteriv(GLenum target, GLenum pname, const GLint *params); +void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +void glUniform1f(GLint location, GLfloat v0); +void glUniform1fv(GLint location, GLsizei count, const GLfloat *value); +void glUniform1i(GLint location, GLint v0); +void glUniform1iv(GLint location, GLsizei count, const GLint *value); +void glUniform2f(GLint location, GLfloat v0, GLfloat v1); +void glUniform2fv(GLint location, GLsizei count, const GLfloat *value); +void glUniform2i(GLint location, GLint v0, GLint v1); +void glUniform2iv(GLint location, GLsizei count, const GLint *value); +void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void glUniform3fv(GLint location, GLsizei count, const GLfloat *value); +void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2); +void glUniform3iv(GLint location, GLsizei count, const GLint *value); +void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void glUniform4fv(GLint location, GLsizei count, const GLfloat *value); +void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void glUniform4iv(GLint location, GLsizei count, const GLint *value); +void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUseProgram(GLuint program); +void glValidateProgram(GLuint program); +void glVertexAttrib1f(GLuint index, GLfloat x); +void glVertexAttrib1fv(GLuint index, const GLfloat *v); +void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y); +void glVertexAttrib2fv(GLuint index, const GLfloat *v); +void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z); +void glVertexAttrib3fv(GLuint index, const GLfloat *v); +void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void glVertexAttrib4fv(GLuint index, const GLfloat *v); +void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); +void glViewport(GLint x, GLint y, GLsizei width, GLsizei height); diff --git a/host/libs/virglrenderer/OpenGLESDispatch/gles2_extensions.entries b/host/libs/virglrenderer/OpenGLESDispatch/gles2_extensions.entries index 99abf3c13..1453e8744 100644 --- a/host/libs/virglrenderer/OpenGLESDispatch/gles2_extensions.entries +++ b/host/libs/virglrenderer/OpenGLESDispatch/gles2_extensions.entries @@ -1,7 +1,20 @@ !gles2_extensions -# GLES 2.0 extensions -void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision); -void glReleaseShaderCompiler(void); -void glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length); -void glVertexAttribPointerWithDataSize(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr, GLsizei dataSize); +%#include <GLES2/gl2ext.h> + +void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image); +void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image); + +void glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +void glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); +void glCopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void glCompressedTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +void glCompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); +void glFramebufferTexture3DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); + +void glDrawBuffersEXT(GLsizei n, const GLenum *bufs); + +void glDrawArraysInstancedEXT(GLenum mode, GLint start, GLsizei count, GLsizei primcount); +void glDrawElementsInstancedEXT(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount); + +void glVertexAttribDivisorEXT(GLuint index, GLuint divisor); diff --git a/host/libs/virglrenderer/OpenGLESDispatch/gles31_only.entries b/host/libs/virglrenderer/OpenGLESDispatch/gles31_only.entries index d6062f28d..53cc1e199 100644 --- a/host/libs/virglrenderer/OpenGLESDispatch/gles31_only.entries +++ b/host/libs/virglrenderer/OpenGLESDispatch/gles31_only.entries @@ -1,51 +1,38 @@ !gles31_only -# GLES 3.1 functions required by the translator library. - -%#include <GLES/gl.h> -%#include <GLES3/gl3.h> %#include <GLES3/gl31.h> -## New gets -void glGetBooleani_v(GLenum target, GLuint index, GLboolean * data); - -## Memory barriers -void glMemoryBarrier(GLbitfield barriers); -void glMemoryBarrierByRegion(GLbitfield barriers); - -## Program pipelines -void glGenProgramPipelines(GLsizei n, GLuint *pipelines); -void glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines); -void glBindProgramPipeline(GLuint pipeline); - -void glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params); -void glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog); - -void glValidateProgramPipeline(GLuint pipeline); -GLboolean glIsProgramPipeline(GLuint pipeline); +void glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z); +void glDispatchComputeIndirect(GLintptr indirect); +void glDrawArraysIndirect(GLenum mode, const void *indirect); +void glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect); +void glFramebufferParameteri(GLenum target, GLenum pname, GLint param); +void glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params); +void glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params); +GLuint glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name); +void glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name); +void glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params); +GLint glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name); void glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program); - -## Separable shader programs void glActiveShaderProgram(GLuint pipeline, GLuint program); - -GLuint glCreateShaderProgramv(GLenum type, GLsizei count, const char **strings); - -void glProgramUniform1f(GLuint program, GLint location, GLfloat v0); -void glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1); -void glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); -void glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +GLuint glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const*strings); +void glBindProgramPipeline(GLuint pipeline); +void glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines); +void glGenProgramPipelines(GLsizei n, GLuint *pipelines); +GLboolean glIsProgramPipeline(GLuint pipeline); +void glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params); void glProgramUniform1i(GLuint program, GLint location, GLint v0); void glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1); void glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2); void glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); void glProgramUniform1ui(GLuint program, GLint location, GLuint v0); -void glProgramUniform2ui(GLuint program, GLint location, GLint v0, GLuint v1); -void glProgramUniform3ui(GLuint program, GLint location, GLint v0, GLint v1, GLuint v2); -void glProgramUniform4ui(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLuint v3); -void glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value); -void glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value); -void glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value); -void glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value); +void glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1); +void glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2); +void glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void glProgramUniform1f(GLuint program, GLint location, GLfloat v0); +void glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1); +void glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); void glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value); void glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value); void glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value); @@ -54,6 +41,10 @@ void glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const G void glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value); void glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value); void glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value); +void glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value); +void glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value); +void glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value); +void glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value); void glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); void glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); void glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); @@ -63,40 +54,19 @@ void glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, void glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); void glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); void glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); - -void glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint * params); -void glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum * props, GLsizei bufSize, GLsizei * length, GLint * params); - -GLuint glGetProgramResourceIndex(GLuint program, GLenum programInterface, const char * name); -GLint glGetProgramResourceLocation(GLuint program, GLenum programInterface, const char * name); -void glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei * length, char * name); - -## Compute shaders +void glValidateProgramPipeline(GLuint pipeline); +void glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog); void glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format); -void glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z); -void glDispatchComputeIndirect(GLintptr indirect); - -## Separate vertex format / buffer binding -void glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLintptr stride); -void glVertexAttribBinding(GLuint attribindex, GLuint bindingindex); +void glGetBooleani_v(GLenum target, GLuint index, GLboolean *data); +void glMemoryBarrier(GLbitfield barriers); +void glMemoryBarrierByRegion(GLbitfield barriers); +void glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val); +void glSampleMaski(GLuint maskNumber, GLbitfield mask); +void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params); +void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params); +void glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride); void glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset); void glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset); +void glVertexAttribBinding(GLuint attribindex, GLuint bindingindex); void glVertexBindingDivisor(GLuint bindingindex, GLuint divisor); - -## Indirect draws -void glDrawArraysIndirect(GLenum mode, const void *indirect); -void glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect); - -## Multisampling -void glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); -void glSampleMaski(GLuint maskNumber, GLbitfield mask); -void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val); - -## New framebuffer parameters -void glFramebufferParameteri(GLenum target, GLenum pname, GLint param); -void glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint * params); - -## Texture LOD queries -# Already used in Translator's validations. -# void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat * params); -# void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint * params); diff --git a/host/libs/virglrenderer/OpenGLESDispatch/gles31_only_functions.h b/host/libs/virglrenderer/OpenGLESDispatch/gles31_only_functions.h deleted file mode 100644 index a89faf760..000000000 --- a/host/libs/virglrenderer/OpenGLESDispatch/gles31_only_functions.h +++ /dev/null @@ -1,78 +0,0 @@ -// Auto-generated with: android/scripts/gen-entries.py --mode=funcargs android/android-emugl/host/libs/libOpenGLESDispatch/gles31_only.entries --output=android/android-emugl/host/include/OpenGLESDispatch/gles31_only_functions.h -// DO NOT EDIT THIS FILE - -#ifndef GLES31_ONLY_FUNCTIONS_H -#define GLES31_ONLY_FUNCTIONS_H - -#include <GLES/gl.h> -#include <GLES3/gl3.h> -#include <GLES3/gl31.h> -#define LIST_GLES31_ONLY_FUNCTIONS(X) \ - X(void, glGetBooleani_v, (GLenum target, GLuint index, GLboolean * data), (target, index, data)) \ - X(void, glMemoryBarrier, (GLbitfield barriers), (barriers)) \ - X(void, glMemoryBarrierByRegion, (GLbitfield barriers), (barriers)) \ - X(void, glGenProgramPipelines, (GLsizei n, GLuint * pipelines), (n, pipelines)) \ - X(void, glDeleteProgramPipelines, (GLsizei n, const GLuint * pipelines), (n, pipelines)) \ - X(void, glBindProgramPipeline, (GLuint pipeline), (pipeline)) \ - X(void, glGetProgramPipelineiv, (GLuint pipeline, GLenum pname, GLint * params), (pipeline, pname, params)) \ - X(void, glGetProgramPipelineInfoLog, (GLuint pipeline, GLsizei bufSize, GLsizei * length, GLchar * infoLog), (pipeline, bufSize, length, infoLog)) \ - X(void, glValidateProgramPipeline, (GLuint pipeline), (pipeline)) \ - X(GLboolean, glIsProgramPipeline, (GLuint pipeline), (pipeline)) \ - X(void, glUseProgramStages, (GLuint pipeline, GLbitfield stages, GLuint program), (pipeline, stages, program)) \ - X(GLuint, glCreateShaderProgramv, (GLenum type, GLsizei count, const char ** strings), (type, count, strings)) \ - X(void, glProgramUniform1f, (GLuint program, GLint location, GLfloat v0), (program, location, v0)) \ - X(void, glProgramUniform2f, (GLuint program, GLint location, GLfloat v0, GLfloat v1), (program, location, v0, v1)) \ - X(void, glProgramUniform3f, (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2), (program, location, v0, v1, v2)) \ - X(void, glProgramUniform4f, (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3), (program, location, v0, v1, v2, v3)) \ - X(void, glProgramUniform1i, (GLuint program, GLint location, GLint v0), (program, location, v0)) \ - X(void, glProgramUniform2i, (GLuint program, GLint location, GLint v0, GLint v1), (program, location, v0, v1)) \ - X(void, glProgramUniform3i, (GLuint program, GLint location, GLint v0, GLint v1, GLint v2), (program, location, v0, v1, v2)) \ - X(void, glProgramUniform4i, (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3), (program, location, v0, v1, v2, v3)) \ - X(void, glProgramUniform1ui, (GLuint program, GLint location, GLuint v0), (program, location, v0)) \ - X(void, glProgramUniform2ui, (GLuint program, GLint location, GLint v0, GLuint v1), (program, location, v0, v1)) \ - X(void, glProgramUniform3ui, (GLuint program, GLint location, GLint v0, GLint v1, GLuint v2), (program, location, v0, v1, v2)) \ - X(void, glProgramUniform4ui, (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLuint v3), (program, location, v0, v1, v2, v3)) \ - X(void, glProgramUniform1fv, (GLuint program, GLint location, GLsizei count, const GLfloat * value), (program, location, count, value)) \ - X(void, glProgramUniform2fv, (GLuint program, GLint location, GLsizei count, const GLfloat * value), (program, location, count, value)) \ - X(void, glProgramUniform3fv, (GLuint program, GLint location, GLsizei count, const GLfloat * value), (program, location, count, value)) \ - X(void, glProgramUniform4fv, (GLuint program, GLint location, GLsizei count, const GLfloat * value), (program, location, count, value)) \ - X(void, glProgramUniform1iv, (GLuint program, GLint location, GLsizei count, const GLint * value), (program, location, count, value)) \ - X(void, glProgramUniform2iv, (GLuint program, GLint location, GLsizei count, const GLint * value), (program, location, count, value)) \ - X(void, glProgramUniform3iv, (GLuint program, GLint location, GLsizei count, const GLint * value), (program, location, count, value)) \ - X(void, glProgramUniform4iv, (GLuint program, GLint location, GLsizei count, const GLint * value), (program, location, count, value)) \ - X(void, glProgramUniform1uiv, (GLuint program, GLint location, GLsizei count, const GLuint * value), (program, location, count, value)) \ - X(void, glProgramUniform2uiv, (GLuint program, GLint location, GLsizei count, const GLuint * value), (program, location, count, value)) \ - X(void, glProgramUniform3uiv, (GLuint program, GLint location, GLsizei count, const GLuint * value), (program, location, count, value)) \ - X(void, glProgramUniform4uiv, (GLuint program, GLint location, GLsizei count, const GLuint * value), (program, location, count, value)) \ - X(void, glProgramUniformMatrix2fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value), (program, location, count, transpose, value)) \ - X(void, glProgramUniformMatrix3fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value), (program, location, count, transpose, value)) \ - X(void, glProgramUniformMatrix4fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value), (program, location, count, transpose, value)) \ - X(void, glProgramUniformMatrix2x3fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value), (program, location, count, transpose, value)) \ - X(void, glProgramUniformMatrix3x2fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value), (program, location, count, transpose, value)) \ - X(void, glProgramUniformMatrix2x4fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value), (program, location, count, transpose, value)) \ - X(void, glProgramUniformMatrix4x2fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value), (program, location, count, transpose, value)) \ - X(void, glProgramUniformMatrix3x4fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value), (program, location, count, transpose, value)) \ - X(void, glProgramUniformMatrix4x3fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value), (program, location, count, transpose, value)) \ - X(void, glGetProgramInterfaceiv, (GLuint program, GLenum programInterface, GLenum pname, GLint * params), (program, programInterface, pname, params)) \ - X(void, glGetProgramResourceiv, (GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum * props, GLsizei bufSize, GLsizei * length, GLint * params), (program, programInterface, index, propCount, props, bufSize, length, params)) \ - X(GLuint, glGetProgramResourceIndex, (GLuint program, GLenum programInterface, const char * name), (program, programInterface, name)) \ - X(GLint, glGetProgramResourceLocation, (GLuint program, GLenum programInterface, const char * name), (program, programInterface, name)) \ - X(void, glGetProgramResourceName, (GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei * length, char * name), (program, programInterface, index, bufSize, length, name)) \ - X(void, glBindImageTexture, (GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format), (unit, texture, level, layered, layer, access, format)) \ - X(void, glDispatchCompute, (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z), (num_groups_x, num_groups_y, num_groups_z)) \ - X(void, glDispatchComputeIndirect, (GLintptr indirect), (indirect)) \ - X(void, glBindVertexBuffer, (GLuint bindingindex, GLuint buffer, GLintptr offset, GLintptr stride), (bindingindex, buffer, offset, stride)) \ - X(void, glVertexAttribBinding, (GLuint attribindex, GLuint bindingindex), (attribindex, bindingindex)) \ - X(void, glVertexAttribFormat, (GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset), (attribindex, size, type, normalized, relativeoffset)) \ - X(void, glVertexAttribIFormat, (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset), (attribindex, size, type, relativeoffset)) \ - X(void, glVertexBindingDivisor, (GLuint bindingindex, GLuint divisor), (bindingindex, divisor)) \ - X(void, glDrawArraysIndirect, (GLenum mode, const void * indirect), (mode, indirect)) \ - X(void, glDrawElementsIndirect, (GLenum mode, GLenum type, const void * indirect), (mode, type, indirect)) \ - X(void, glTexStorage2DMultisample, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations), (target, samples, internalformat, width, height, fixedsamplelocations)) \ - X(void, glSampleMaski, (GLuint maskNumber, GLbitfield mask), (maskNumber, mask)) \ - X(void, glGetMultisamplefv, (GLenum pname, GLuint index, GLfloat * val), (pname, index, val)) \ - X(void, glFramebufferParameteri, (GLenum target, GLenum pname, GLint param), (target, pname, param)) \ - X(void, glGetFramebufferParameteriv, (GLenum target, GLenum pname, GLint * params), (target, pname, params)) \ - - -#endif // GLES31_ONLY_FUNCTIONS_H diff --git a/host/libs/virglrenderer/OpenGLESDispatch/gles3_only.entries b/host/libs/virglrenderer/OpenGLESDispatch/gles3_only.entries index 89103fea9..9742d382e 100644 --- a/host/libs/virglrenderer/OpenGLESDispatch/gles3_only.entries +++ b/host/libs/virglrenderer/OpenGLESDispatch/gles3_only.entries @@ -1,149 +1,111 @@ !gles3_only -# GLES 3.0 functions required by the translator library. +%#include <GLES3/gl31.h> -%#include <GLES/gl.h> -%#include <GLES3/gl3.h> -%#include <GLES3/gl3ext.h> +%// Return types must be single words, see GLDispatch.cpp +%typedef const GLubyte* GL3constubyteptr; -# glGetStringi -GLconstubyteptr glGetStringi(GLenum name, GLint index); - -# VAOs -void glGenVertexArrays(GLsizei n, GLuint* arrays); +void glReadBuffer(GLenum src); +void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); +void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); +void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); +void glGenQueries(GLsizei n, GLuint *ids); +void glDeleteQueries(GLsizei n, const GLuint *ids); +GLboolean glIsQuery(GLuint id); +void glBeginQuery(GLenum target, GLuint id); +void glEndQuery(GLenum target); +void glGetQueryiv(GLenum target, GLenum pname, GLint *params); +void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params); +GLboolean glUnmapBuffer(GLenum target); +void glGetBufferPointerv(GLenum target, GLenum pname, void **params); +void glDrawBuffers(GLsizei n, const GLenum *bufs); +void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +void* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length); void glBindVertexArray(GLuint array); void glDeleteVertexArrays(GLsizei n, const GLuint *arrays); +void glGenVertexArrays(GLsizei n, GLuint *arrays); GLboolean glIsVertexArray(GLuint array); - -# Buffers -void *glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); -GLboolean glUnmapBuffer(GLenum target); -void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length); - +void glGetIntegeri_v(GLenum target, GLuint index, GLint *data); +void glBeginTransformFeedback(GLenum primitiveMode); +void glEndTransformFeedback(void); void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); void glBindBufferBase(GLenum target, GLuint index, GLuint buffer); - -void glCopyBufferSubData(GLenum readtarget, GLenum writetarget, GLintptr readoffset, GLintptr writeoffset, GLsizeiptr size); - -void glClearBufferiv(GLenum buffer, GLint drawBuffer, const GLint * value); -void glClearBufferuiv(GLenum buffer, GLint drawBuffer, const GLuint * value); -void glClearBufferfv(GLenum buffer, GLint drawBuffer, const GLfloat * value); -void glClearBufferfi(GLenum buffer, GLint drawBuffer, GLfloat depth, GLint stencil); - -void glGetBufferParameteri64v(GLenum target, GLenum value, GLint64 * data); -void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid ** params); - -# UBOs -void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); - -GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName); -void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar **uniformNames, GLuint *uniformIndices); - -void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); -void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); - -# More uniform setters +void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode); +void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); +void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); +void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params); +void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params); +void glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w); +void glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +void glVertexAttribI4iv(GLuint index, const GLint *v); +void glVertexAttribI4uiv(GLuint index, const GLuint *v); +void glGetUniformuiv(GLuint program, GLint location, GLuint *params); +GLint glGetFragDataLocation(GLuint program, const GLchar *name); void glUniform1ui(GLint location, GLuint v0); void glUniform2ui(GLint location, GLuint v0, GLuint v1); void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2); -void glUniform4ui(GLint location, GLint v0, GLuint v1, GLuint v2, GLuint v3); +void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); void glUniform1uiv(GLint location, GLsizei count, const GLuint *value); void glUniform2uiv(GLint location, GLsizei count, const GLuint *value); void glUniform3uiv(GLint location, GLsizei count, const GLuint *value); void glUniform4uiv(GLint location, GLsizei count, const GLuint *value); -void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); -void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); -void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); -void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); -void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); -void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); - -void glGetUniformuiv(GLuint program, GLint location, GLuint *params); +void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value); +void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value); +void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value); +void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +GL3constubyteptr glGetStringi(GLenum name, GLuint index); +void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices); void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); - -# More vertex attribute setters / queries -void glVertexAttribI4i(GLuint index, GLint v0, GLint v1, GLint v2, GLint v3); -void glVertexAttribI4ui(GLuint index, GLuint v0, GLuint v1, GLuint v2, GLuint v3); -void glVertexAttribI4iv(GLuint index, const GLint *v); -void glVertexAttribI4uiv(GLuint index, const GLuint *v); -void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); -void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params); -void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params); - -# Instanced draws -void glVertexAttribDivisor(GLuint index, GLuint divisor); -void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei primcount); -void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei primcount); - -# Draw with known index range -void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices); - -# Sync +GLuint glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName); +void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); +void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); +void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount); GLsync glFenceSync(GLenum condition, GLbitfield flags); -GLenum glClientWaitSync(GLsync wait_on, GLbitfield flags, GLuint64 timeout); -void glWaitSync(GLsync wait_on, GLbitfield flags, GLuint64 timeout); -void glDeleteSync(GLsync to_delete); GLboolean glIsSync(GLsync sync); +void glDeleteSync(GLsync sync); +GLenum glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout); +void glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout); +void glGetInteger64v(GLenum pname, GLint64 *data); void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values); - -# MRT / MSAA render buffer -void glDrawBuffers(GLsizei n, const GLenum *bufs); -void glReadBuffer(GLenum src); -void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); -void glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments); -void glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height); -void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); -void glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params); -void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); - -# Transform feedback -void glBeginTransformFeedback(GLenum primitiveMode); -void glEndTransformFeedback(void); -void glGenTransformFeedbacks(GLsizei n, GLuint *ids); -void glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids); +void glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data); +void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params); +void glGenSamplers(GLsizei count, GLuint *samplers); +void glDeleteSamplers(GLsizei count, const GLuint *samplers); +GLboolean glIsSampler(GLuint sampler); +void glBindSampler(GLuint unit, GLuint sampler); +void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param); +void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param); +void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param); +void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param); +void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params); +void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params); +void glVertexAttribDivisor(GLuint index, GLuint divisor); void glBindTransformFeedback(GLenum target, GLuint id); +void glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids); +void glGenTransformFeedbacks(GLsizei n, GLuint *ids); +GLboolean glIsTransformFeedback(GLuint id); void glPauseTransformFeedback(void); void glResumeTransformFeedback(void); -GLboolean glIsTransformFeedback(GLuint id); -void glTransformFeedbackVaryings(GLuint program, GLsizei count, const char ** varyings, GLenum bufferMode); -void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, char * name); - -# Sampler objects -void glGenSamplers(GLsizei n, GLuint *samplers); -void glDeleteSamplers(GLsizei n, const GLuint * samplers); -void glBindSampler(GLuint unit, GLuint sampler); -void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param); -void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param); -void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat * params); -void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint * params); -void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat * params); -void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint * params); -GLboolean glIsSampler(GLuint sampler); - -# Query objects -void glGenQueries(GLsizei n, GLuint * queries); -void glDeleteQueries(GLsizei n, const GLuint * queries); -void glBeginQuery(GLenum target, GLuint query); -void glEndQuery(GLenum target); -void glGetQueryiv(GLenum target, GLenum pname, GLint * params); -void glGetQueryObjectuiv(GLuint query, GLenum pname, GLuint * params); -GLboolean glIsQuery(GLuint query); - -# Shader binary objects -void glProgramParameteri(GLuint program, GLenum pname, GLint value); +void glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary); void glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length); -void glGetProgramBinary(GLuint program, GLsizei bufsize, GLsizei *length, GLenum *binaryFormat, void *binary); - -# New glGets -GLint glGetFragDataLocation(GLuint program, const char * name); -void glGetInteger64v(GLenum pname, GLint64 * data); -void glGetIntegeri_v(GLenum target, GLuint index, GLint * data); -void glGetInteger64i_v(GLenum target, GLuint index, GLint64 * data); - -# Array/3D textures -void glTexImage3D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * data); +void glProgramParameteri(GLuint program, GLenum pname, GLint value); +void glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments); +void glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height); +void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); void glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); -void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * data); -void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data); -void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data); -void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params); diff --git a/host/libs/virglrenderer/OpenGLESDispatch/gles_functions.h b/host/libs/virglrenderer/OpenGLESDispatch/gles_functions.h new file mode 100644 index 000000000..d45dda39c --- /dev/null +++ b/host/libs/virglrenderer/OpenGLESDispatch/gles_functions.h @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2018 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 "OpenGLESDispatch/gles1_core_functions.h" +#include "OpenGLESDispatch/gles1_extensions_functions.h" +#include "OpenGLESDispatch/gles2_core_functions.h" +#include "OpenGLESDispatch/gles2_extensions_functions.h" +#include "OpenGLESDispatch/gles3_only_functions.h" +#include "OpenGLESDispatch/gles31_only_functions.h" + +#define LIST_GLES1_FUNCTIONS(X, Y) \ + LIST_GLES1_CORE_FUNCTIONS(X) \ + LIST_GLES1_EXTENSIONS_FUNCTIONS(Y) \ + +#define LIST_GLES3_FUNCTIONS(X, Y) \ + LIST_GLES2_CORE_FUNCTIONS(X) \ + LIST_GLES2_EXTENSIONS_FUNCTIONS(Y) \ + LIST_GLES3_ONLY_FUNCTIONS(X) \ + LIST_GLES31_ONLY_FUNCTIONS(X) diff --git a/host/libs/virglrenderer/OpenglRender/IOStream.h b/host/libs/virglrenderer/OpenglRender/IOStream.h index ab561ec1d..82e5bdea5 100644 --- a/host/libs/virglrenderer/OpenglRender/IOStream.h +++ b/host/libs/virglrenderer/OpenglRender/IOStream.h @@ -1,105 +1,63 @@ /* -* Copyright (C) 2011 The Android Open Source Project -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ -#pragma once + * Copyright (C) 2018 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 "ErrorLog.h" -#include "android/base/files/Stream.h" +#pragma once -#include <assert.h> -#include <inttypes.h> -#include <stdlib.h> -#include <stdio.h> +#include <cstdint> +#include <cstdio> +#include <cstdlib> class IOStream { -protected: - explicit IOStream(size_t bufSize) : m_bufsize(bufSize) {} - - ~IOStream() { - // NOTE: m_buf was owned by the child class thus we expect it to be - // released before the object destruction. - } - -public: - size_t read(void* buf, size_t bufLen) { - if (!readRaw(buf, &bufLen)) { - return 0; - } - return bufLen; + public: + IOStream(unsigned char* buf, size_t bufSize) : m_buf(buf), m_bufSize(bufSize) { } unsigned char* alloc(size_t len) { - if (m_buf && len > m_free) { - if (flush() < 0) { - ERR("Failed to flush in alloc\n"); - return NULL; // we failed to flush so something is wrong - } + if (m_allocSize + len > m_bufSize) { + printf("Command response is too large.\n"); + return nullptr; } - - if (!m_buf || len > m_bufsize) { - int allocLen = m_bufsize < len ? len : m_bufsize; - m_buf = (unsigned char *)allocBuffer(allocLen); - if (!m_buf) { - ERR("Alloc (%u bytes) failed\n", allocLen); - return NULL; - } - m_bufsize = m_free = allocLen; - } - - unsigned char* ptr = m_buf + (m_bufsize - m_free); - m_free -= len; - - return ptr; + unsigned char* buf = m_buf + m_allocSize; + m_allocSize += len; + return buf; } int flush() { - if (!m_buf || m_free == m_bufsize) return 0; - - int stat = commitBuffer(m_bufsize - m_free); - m_buf = NULL; - m_free = 0; - return stat; + m_flushSize = m_allocSize; + return 0; } - void save(android::base::Stream* stream) { - stream->putBe32(m_bufsize); - stream->putBe32(m_free); - stream->putByte(m_buf != nullptr); - onSave(stream); + void* getDmaForReading(uint64_t guest_paddr) { + // GLDMA is not supported, so we don't have to implement this. Just keep + // a stub here to keep the generated decoder stubs happy + return nullptr; } - void load(android::base::Stream* stream) { - m_bufsize = stream->getBe32(); - m_free = stream->getBe32(); - const bool haveBuf = stream->getByte(); - const auto buf = onLoad(stream); - m_buf = haveBuf ? buf : nullptr; + void unlockDma(uint64_t guest_paddr) { + // GLDMA is not supported, so we don't have to implement this. Just keep + // a stub here to keep the generated decoder stubs happy } - virtual void* getDmaForReading(uint64_t guest_paddr) = 0; - virtual void unlockDma(uint64_t guest_paddr) = 0; - -protected: - virtual void *allocBuffer(size_t minSize) = 0; - virtual int commitBuffer(size_t size) = 0; - virtual const unsigned char *readRaw(void *buf, size_t *inout_len) = 0; - virtual void onSave(android::base::Stream* stream) = 0; - virtual unsigned char* onLoad(android::base::Stream* stream) = 0; + size_t getFlushSize() { + return m_flushSize; + } -private: - unsigned char* m_buf = nullptr; - size_t m_bufsize; - size_t m_free = 0; + private: + size_t m_allocSize = 0U; + size_t m_flushSize = 0U; + unsigned char* m_buf; + size_t m_bufSize; }; diff --git a/host/libs/virglrenderer/ProtocolUtils.h b/host/libs/virglrenderer/ProtocolUtils.h index 7c323c979..fd0bebef3 100644 --- a/host/libs/virglrenderer/ProtocolUtils.h +++ b/host/libs/virglrenderer/ProtocolUtils.h @@ -1,3 +1,19 @@ +/* + * Copyright (C) 2016 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 <assert.h> diff --git a/host/libs/virglrenderer/README.md b/host/libs/virglrenderer/README.md new file mode 100644 index 000000000..e9b13789c --- /dev/null +++ b/host/libs/virglrenderer/README.md @@ -0,0 +1,112 @@ +# AVDVirglRenderer + +This project implements an alternative for 'virglrenderer', a part of the +Virgil 3D GPU project that normally implements the translation from the +virtio-gpu-3d command stream & tgsi/gallium shaders, to desktop OpenGL. + +This version of the library keeps translation to a minimum and only works with +a true EGL/GLES driver implementation on the host. It won't intercept and +translate shaders, and no part of the GL state machine is processed in the +emulated guest. + +The wire protocol used between the virtio-gpu DRM driver and QEMU's +virtio-gpu-3d device is the same as that used by goldfish (the classic Android +emulator). Submits (writes) are made with an `DRM_VIRTGPU_EXECBUFFER` call; the +response comes back through a separate memory mapped buffer. Responses are very +expensive and are minimized where possible, as they involve a pipeline flush and +roundtrip to the host. + +## Structure + +### [`AVDVirglRenderer`](AVDVirglRenderer.cpp)[](#AVDVirglRenderer) + +Provides the entrypoints expected by QEMU for its libvirglrenderer integration. + +This is where contexts, resources and fences are monitored. + +### [`RenderControl`](RenderControl.cpp) [`Header`](RenderControl.h) [`Decoder`](renderControl_dec)[](#RenderControl) + +The RenderControl is analogous to EGL on the guest side. It has a similar API to +EGL, except that not every EGL function can be implemented as one API call, and +instead multiple RenderControl calls are made. The RenderControl architecture +was precipitated by goldfish's requirement that EGL window surfaces and images +would be directly mapped to GL texture names, but in AVDVirglRenderer we +preserve them as EGL objects on the host side. + +This component contains a decoder for the wire protocol, and stubs for any +functions that we do not need to implement. The wire protocol is completely +unmodified. + +### [`GLESv1`](GLESv1.cpp) [`Header`](GLESv1.h) [`Decoder`](GLESv1_dec)[](#GLESv1) + +This component contains a decoder for the wire protocol, and stubs for any +functions that we do not need to implement. Only the GL ES 1.1 extensions +implemented by SwiftShader are implemented, and only if they are needed by +Android. Any extensions provided by the wire protocol that are not supported by +either are intentionally stubbed. + +### [`GLESv3`](GLESv3.cpp) [`Header`](GLESv3.h) [`Decoder`](GLESv3_dec)[](#GLESv3) + +This component contains a decoder for the wire protocol, and stubs for any +functions that we do not need to implement. Only the core GL ES 3.0 API is +implemented; no ES 2.0 extensions are supported, unless they are remappable to +GL ES 3.0 features. GL ES 3.1 is not currently supported. Any extensions +provided by the wire protocol that are not supported by either Android or +SwiftShader are intentionally stubbed. + +Note that we are *not* stubbing ES 3.1 functions; these will crash if called. + +### [`ChecksumCalculator`](OpenglRenderer/ChecksumCalculator.cpp)[`Header`](ChecksumCalculator.h)[](#ChecksumCalculator) + +This code was taken from the Android emulator. The header has been slightly +trimmed but its functionality has not been changed. + +### [`ChecksumCalculatorThreadInfo`](ChecksumCalculatorThreadInfo.h)[](#ChecksumCalculatorThreadInfo) + +This header has been added for compatibility with the decoder code generated by +the `emugen_cuttlefish` tool. Unlike the original implementation, it is not +thread safe. We do not require thread safety because no decoder state is shared +between threads in AVDVirglRenderer without its own locking. + +### [`Context`](Context.h)[](#Context) + +The Context structure represents a virglrenderer context assigned by QEMU. Each +time the driver's device node is opened by the guest, a new context is created. +In the design of AVDVirglRenderer, there are two kinds of context. The first +kind of context is for `gralloc`, and there is one of these contexts per guest +process. The second kind of context is per-thread, used by the EGL/GLES +implementation. This second kind of context can receive 3D commands, which are +processed in their own thread by AVDVirglRenderer so as to minimize the number +of synthetic calls we have to make (such as eglMakeCurrent()). + +### [`Resource`](Resource.h)[](#Resource) + +The Resource structure represents a virglrenderer resource assigned by QEMU. +Each time the driver allocates memory through the device driver's interface, a +new resource is created. Resources can be owned by the kernel (for example, the +primary framebuffer surfaces), Gralloc (EGL window surfaces or images), or used +for other purposes such as the Context response buffer and fencing. + +### [`EglConfig`](EglConfig.h)[](EglConfig) + +The EglConfig structure maintains a list of available EGLConfigs. + +### [`EglContext`](EglContext.h)[](EglContext) + +The EglContext structure maintains a list of active EGLContexts, and decides +when they can be disposed of. + +### [`EglImage`](EglImage.h)[](EglImage) + +The EglImage structure maintains a list of active EGLImageKHRs, and decides +when they can be disposed of. + +### [`EglSurface`](EglSurface.h)[](EglSurface) + +The EglSurface structure maintains a list of active EGLSurfaces, and decides +when they can be disposed of. + +### [`EglSync`](EglSync.h)[](EglSync) + +The EglSync structure maintains a list of active EGLSyncKHRs, and decides +when they can be disposed of. diff --git a/host/libs/virglrenderer/RenderControl.cpp b/host/libs/virglrenderer/RenderControl.cpp new file mode 100644 index 000000000..fd84eb548 --- /dev/null +++ b/host/libs/virglrenderer/RenderControl.cpp @@ -0,0 +1,868 @@ +/* + * Copyright (C) 2018 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. + */ +#undef NDEBUG + +#include "Context.h" +#include "EglConfig.h" +#include "EglContext.h" +#include "EglImage.h" +#include "EglSurface.h" +#include "EglSync.h" + +#include <cassert> +#include <cerrno> +#include <cstring> +#include <string> + +#include <unistd.h> + +#include <GLES/gl.h> +#include <GLES/glext.h> + +#include <OpenGLESDispatch/EGLDispatch.h> +#include <OpenGLESDispatch/GLESv1Dispatch.h> +#include <OpenGLESDispatch/GLESv3Dispatch.h> + +#include "virgl_hw.h" + +#include "RenderControl.h" + +#include <hardware/gralloc.h> +#include <hardware/gralloc1.h> +#include <nativebase/nativebase.h> +#include <system/window.h> + +static void incRefANWB(android_native_base_t* base) { + ANativeWindowBuffer* anwb = reinterpret_cast<ANativeWindowBuffer*>(base); + anwb->layerCount++; +} + +static void decRefANWB(android_native_base_t* base) { + ANativeWindowBuffer* anwb = reinterpret_cast<ANativeWindowBuffer*>(base); + if (anwb->layerCount > 0) { + anwb->layerCount--; + if (anwb->layerCount == 0) + delete anwb; + } +} +struct FakeANativeWindowBuffer : public ANativeWindowBuffer { + FakeANativeWindowBuffer() { + ANativeWindowBuffer(); + + common.incRef = incRefANWB; + common.decRef = decRefANWB; + layerCount = 0U; + } +}; + +static void incRefANW(android_native_base_t* base) { + ANativeWindow* anw = reinterpret_cast<ANativeWindow*>(base); + anw->oem[0]++; +} + +static void decRefANW(android_native_base_t* base) { + ANativeWindow* anw = reinterpret_cast<ANativeWindow*>(base); + if (anw->oem[0] > 0) { + anw->oem[0]--; + if (anw->oem[0] == 0) + delete anw; + } +} + +static int setSwapInterval(ANativeWindow*, int) { + printf("%s: not implemented\n", __func__); + return 0; +} + +static int dequeueBuffer_DEPRECATED(ANativeWindow* window, ANativeWindowBuffer** buffer) { + if (!window->oem[1]) + return -EINVAL; + *buffer = reinterpret_cast<ANativeWindowBuffer*>(window->oem[1]); + window->oem[1] = 0; + return 0; +} + +static int lockBuffer_DEPRECATED(ANativeWindow*, ANativeWindowBuffer*) { + printf("%s: not implemented\n", __func__); + return 0; +} + +static int queueBuffer_DEPRECATED(ANativeWindow*, ANativeWindowBuffer*) { + printf("%s: not implemented\n", __func__); + return 0; +} + +static int query(const ANativeWindow* window, int what, int* value) { + switch (what) { + case NATIVE_WINDOW_WIDTH: + return static_cast<int>(window->oem[2]); + case NATIVE_WINDOW_HEIGHT: + return static_cast<int>(window->oem[3]); + default: + return -EINVAL; + } +} + +static int perform(ANativeWindow*, int, ...) { + printf("%s: not implemented\n", __func__); + return 0; +} + +static int cancelBuffer_DEPRECATED(ANativeWindow*, ANativeWindowBuffer*) { + printf("%s: not implemented\n", __func__); + return 0; +} + +static int dequeueBuffer(ANativeWindow* window, ANativeWindowBuffer** buffer, int* fenceFd) { + *fenceFd = -1; + return dequeueBuffer_DEPRECATED(window, buffer); +} + +static int queueBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd) { + if (fenceFd >= 0) + close(fenceFd); + return queueBuffer_DEPRECATED(window, buffer); +} + +static int cancelBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd) { + if (fenceFd >= 0) + close(fenceFd); + return cancelBuffer_DEPRECATED(window, buffer); +} + +struct FakeANativeWindow : public ANativeWindow { + FakeANativeWindow(uint32_t width, uint32_t height) { + ANativeWindow(); + + common.incRef = incRefANW; + common.decRef = decRefANW; + oem[0] = 0; + oem[2] = static_cast<intptr_t>(width); + oem[3] = static_cast<intptr_t>(height); + + this->setSwapInterval = ::setSwapInterval; + this->dequeueBuffer_DEPRECATED = ::dequeueBuffer_DEPRECATED; + this->lockBuffer_DEPRECATED = ::lockBuffer_DEPRECATED; + this->queueBuffer_DEPRECATED = ::queueBuffer_DEPRECATED; + this->query = ::query; + this->perform = ::perform; + this->cancelBuffer_DEPRECATED = ::cancelBuffer_DEPRECATED; + this->dequeueBuffer = ::dequeueBuffer; + this->queueBuffer = ::queueBuffer; + this->cancelBuffer = ::cancelBuffer; + } +}; + +// Helpers + +static ANativeWindowBuffer* resourceToANWB(Resource* res) { + ANativeWindowBuffer* buffer = new (std::nothrow) FakeANativeWindowBuffer(); + if (!buffer) + return nullptr; + + buffer->width = res->args.width; + buffer->height = res->args.height; + buffer->stride = res->args.width; + buffer->handle = reinterpret_cast<const native_handle_t*>(res->args.handle); + buffer->usage_deprecated = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN | + GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER; + buffer->usage = + GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN | GRALLOC1_CONSUMER_USAGE_CPU_WRITE_OFTEN | + GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE | GRALLOC1_PRODUCER_USAGE_CPU_READ_OFTEN | + GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN | GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET; + + switch (res->args.format) { + case VIRGL_FORMAT_B8G8R8A8_UNORM: + buffer->format = HAL_PIXEL_FORMAT_BGRA_8888; + break; + case VIRGL_FORMAT_B5G6R5_UNORM: + buffer->format = HAL_PIXEL_FORMAT_RGB_565; + break; + case VIRGL_FORMAT_R8G8B8A8_UNORM: + buffer->format = HAL_PIXEL_FORMAT_RGBA_8888; + break; + case VIRGL_FORMAT_R8G8B8X8_UNORM: + buffer->format = HAL_PIXEL_FORMAT_RGBX_8888; + break; + default: + delete buffer; + return nullptr; + } + + return buffer; +} + +// RenderControl + +static GLint rcGetRendererVersion() { + return 1; // seems to be hard-coded +} + +static EGLint rcGetEGLVersion(void* ctx_, EGLint* major, EGLint* minor) { + RenderControl* rc = static_cast<RenderControl*>(ctx_); + return s_egl.eglInitialize(rc->dpy, major, minor); +} + +static EGLint rcQueryEGLString(void* ctx_, EGLenum name, void* buffer, EGLint bufferSize) { + RenderControl* rc = static_cast<RenderControl*>(ctx_); + const char* str = s_egl.eglQueryString(rc->dpy, name); + if (!str) + str = ""; + + if (strlen(str) > (size_t)bufferSize) { + memset(buffer, 0, bufferSize); + return -strlen(str); + } + + char* strOut = static_cast<char*>(buffer); + strncpy(strOut, str, bufferSize - 1); + strOut[bufferSize - 1] = 0; + + return strlen(strOut) + 1U; +} + +static std::string replaceESVersionString(const std::string& prev, const char* const newver) { + // Do not touch ES 1.x contexts (they will all be 1.1 anyway) + if (prev.find("ES-CM") != std::string::npos) + return prev; + + size_t esStart = prev.find("ES "); + size_t esEnd = prev.find(" ", esStart + 3); + + // Do not change out-of-spec version strings. + if (esStart == std::string::npos || esEnd == std::string::npos) + return prev; + + std::string res = prev.substr(0, esStart + 3); + res += newver; + res += prev.substr(esEnd); + return res; +} + +static EGLint rcGetGLString(void* ctx_, EGLenum name, void* buffer, EGLint bufferSize) { + std::string glStr; + + RenderControl* rc = static_cast<RenderControl*>(ctx_); + if (rc->ctx->ctx) { + const char* str = nullptr; + switch (rc->ctx->ctx->api) { + case EglContext::GLESApi::GLESApi_CM: + str = reinterpret_cast<const char*>(s_gles1.glGetString(name)); + break; + default: + str = reinterpret_cast<const char*>(s_gles3.glGetString(name)); + break; + } + if (str) + glStr += str; + } + + // FIXME: Should probably filter the extensions list like the emulator + // does. We need to handle ES2 on ES3 compatibility for older + // Android versions, as well as filter out unsupported features. + + if (name == GL_EXTENSIONS) { + glStr += ChecksumCalculator::getMaxVersionStr(); + glStr += " "; + + // FIXME: Hard-coded to 3.0 for now. We should attempt to detect 3.1. + glStr += "ANDROID_EMU_gles_max_version_3_0"; + glStr += " "; + } + + // FIXME: Add support for async swap and the fence_sync extensions + + // We don't support GLDMA; use VIRTGPU_RESOURCE_CREATE and a combination of + // VIRTGPU_TRANSFER_TO_HOST and VIRTGPU_TRANSFER_FROM_HOST. + + // FIXME: Add support for 'no host error' + + if (name == GL_VERSION) + glStr = replaceESVersionString(glStr, "3.0"); + + int nextBufferSize = glStr.size() + 1; + + if (!buffer || nextBufferSize > bufferSize) + return -nextBufferSize; + + snprintf((char*)buffer, nextBufferSize, "%s", glStr.c_str()); + return nextBufferSize; +} + +static EGLint rcGetNumConfigs(uint32_t* numAttribs) { + *numAttribs = EglConfig::kNumAttribs; + return EglConfig::vec.size(); +} + +static EGLint rcGetConfigs(uint32_t bufSize, GLuint* buffer) { + size_t configAttribBytes = sizeof(EglConfig::kAttribs); + size_t nConfigs = EglConfig::vec.size(); + size_t sizeNeeded = configAttribBytes + nConfigs * configAttribBytes; + + if (bufSize < sizeNeeded) + return -sizeNeeded; + + memcpy(buffer, &EglConfig::kAttribs, configAttribBytes); + size_t offset = EglConfig::kNumAttribs; + for (auto const& config : EglConfig::vec) { + memcpy(&buffer[offset], config->attribs, configAttribBytes); + offset += EglConfig::kNumAttribs; + } + + return nConfigs; +} + +static EGLint rcChooseConfig(void* ctx_, EGLint* attribs, uint32_t, uint32_t* config_ints, + uint32_t configs_size) { + EGLint num_config; + EGLConfig configs[configs_size]; + RenderControl* rc = static_cast<RenderControl*>(ctx_); + EGLBoolean ret = s_egl.eglChooseConfig(rc->dpy, attribs, configs, configs_size, &num_config); + if (!ret) + num_config = 0; + + if (configs_size) { + for (EGLint i = 0; i < num_config; i++) { + config_ints[i] = ~0U; + EGLint config_id; + if (s_egl.eglGetConfigAttrib(rc->dpy, configs[i], EGL_CONFIG_ID, &config_id)) { + for (size_t i = 0; i < EglConfig::vec.size(); i++) { + if (EglConfig::vec[i]->attribs[4] == config_id) + config_ints[i] = i; + } + } + if (config_ints[i] == ~0U) { + num_config = 0; + break; + } + } + if (!num_config) + memset(config_ints, 0, configs_size * sizeof(uint32_t)); + } + + return num_config; +} + +static EGLint rcGetFBParam(EGLint) { + printf("%s: not implemented\n", __func__); + return 0; +} + +static uint32_t rcCreateContext(void* ctx_, uint32_t config_, uint32_t share_, uint32_t glVersion) { + // clang-format off + EGLint attrib_list[] = { + EGL_CONTEXT_CLIENT_VERSION, 0, + EGL_CONTEXT_MINOR_VERSION_KHR, 0, + EGL_NONE + }; + // clang-format on + switch (glVersion) { + case EglContext::GLESApi::GLESApi_CM: + attrib_list[1] = 1; + attrib_list[3] = 1; + break; + case EglContext::GLESApi::GLESApi_2: + attrib_list[1] = 2; + break; + case EglContext::GLESApi::GLESApi_3_0: + attrib_list[1] = 3; + break; + case EglContext::GLESApi::GLESApi_3_1: + attrib_list[1] = 3; + attrib_list[3] = 1; + break; + } + if (!attrib_list[1]) + return 0U; + + if (config_ > EglConfig::vec.size()) + return 0U; + EglConfig const* config = EglConfig::vec[config_]; + + EGLContext share_context = EGL_NO_CONTEXT; + if (share_ > 0) { + std::map<uint32_t, EglContext*>::iterator context_it; + context_it = EglContext::map.find(share_); + if (context_it == EglContext::map.end()) + return 0U; + + EglContext const* share = context_it->second; + share_context = share->context; + } + + RenderControl* rc = static_cast<RenderControl*>(ctx_); + EGLContext context_ = + s_egl.eglCreateContext(rc->dpy, config->config, share_context, attrib_list); + if (context_ == EGL_NO_CONTEXT) + return 0U; + + EglContext* context = new (std::nothrow) + EglContext(context_, rc->ctx->handle, (enum EglContext::GLESApi)glVersion); + if (!context) { + s_egl.eglDestroyContext(rc->dpy, context_); + return 0U; + } + + return context->id; +} + +static void rcDestroyContext(void* ctx_, uint32_t ctx) { + std::map<uint32_t, EglContext*>::iterator it; + it = EglContext::map.find(ctx); + if (it == EglContext::map.end()) + return; + + EglContext* context = it->second; + + RenderControl* rc = static_cast<RenderControl*>(ctx_); + s_egl.eglDestroyContext(rc->dpy, context->context); + context->context = EGL_NO_CONTEXT; + if (context->disposable()) + delete context; +} + +static uint32_t rcCreateWindowSurface(void* ctx_, uint32_t config_, uint32_t width, + uint32_t height) { + if (config_ > EglConfig::vec.size()) + return 0U; + + EglConfig const* config = EglConfig::vec[config_]; + + RenderControl* rc = static_cast<RenderControl*>(ctx_); + EglSurface* surface = + new (std::nothrow) EglSurface(config->config, rc->ctx->handle, width, height); + if (!surface) + return 0U; + + return surface->id; +} + +static void rcDestroyWindowSurface(void* ctx_, uint32_t surface_) { + std::map<uint32_t, EglSurface*>::iterator it; + it = EglSurface::map.find(surface_); + if (it == EglSurface::map.end()) + return; + + EglSurface* surface = it->second; + + RenderControl* rc = static_cast<RenderControl*>(ctx_); + s_egl.eglDestroySurface(rc->dpy, surface->surface); + surface->surface = EGL_NO_SURFACE; + if (surface->disposable()) { + delete surface->window; + delete surface; + } +} + +static uint32_t rcCreateColorBuffer(uint32_t, uint32_t, GLenum) { + // NOTE: This CreateColorBuffer implementation is a no-op which returns a + // special surface ID to indicate that a pbuffer surface should be + // created. This is necessary because the emulator does not create a + // true pbuffer, it always creates a fake one. We don't want this. + return ~1U; +} + +static void rcOpenColorBuffer(uint32_t) { + printf("%s: not implemented\n", __func__); +} + +static void rcCloseColorBuffer(uint32_t) { + printf("%s: not implemented\n", __func__); +} + +static void rcSetWindowColorBuffer(void* ctx_, uint32_t windowSurface, uint32_t colorBuffer) { + std::map<uint32_t, EglSurface*>::iterator surface_it; + surface_it = EglSurface::map.find(windowSurface); + if (surface_it == EglSurface::map.end()) + return; + + EglSurface* surface = surface_it->second; + + RenderControl* rc = static_cast<RenderControl*>(ctx_); + + if (colorBuffer == ~1U) { + EGLint const attrib_list[] = { EGL_WIDTH, (EGLint)surface->width, EGL_HEIGHT, + (EGLint)surface->height, EGL_NONE }; + assert(surface->surface == EGL_NO_SURFACE && "Pbuffer set twice"); + surface->surface = s_egl.eglCreatePbufferSurface(rc->dpy, surface->config, attrib_list); + } else { + std::map<uint32_t, Resource*>::iterator resource_it; + resource_it = Resource::map.find(colorBuffer); + if (resource_it == Resource::map.end()) + return; + + Resource* res = resource_it->second; + ANativeWindowBuffer* buffer = resourceToANWB(res); + if (!buffer) + return; + + if (surface->surface == EGL_NO_SURFACE) { + surface->window = + new (std::nothrow) FakeANativeWindow(res->args.width, res->args.height); + if (!surface->window) + return; + + NativeWindowType native_window = reinterpret_cast<NativeWindowType>(surface->window); + surface->window->oem[1] = (intptr_t)buffer; + surface->surface = + s_egl.eglCreateWindowSurface(rc->dpy, surface->config, native_window, nullptr); + } else { + surface->window->oem[1] = (intptr_t)buffer; + s_egl.eglSwapBuffers(rc->dpy, surface->surface); + } + } +} + +static int rcFlushWindowColorBuffer(uint32_t windowSurface) { + std::map<uint32_t, EglSurface*>::iterator it; + it = EglSurface::map.find(windowSurface); + return it == EglSurface::map.end() ? -1 : 0; +} + +static EGLint rcMakeCurrent(void* ctx_, uint32_t context_, uint32_t drawSurf, uint32_t readSurf) { + std::map<uint32_t, EglContext*>::iterator context_it; + context_it = EglContext::map.find(context_); + if (context_it == EglContext::map.end()) + return EGL_FALSE; + + EglContext* context = context_it->second; + + std::map<uint32_t, EglSurface*>::iterator surface_it; + surface_it = EglSurface::map.find(drawSurf); + if (surface_it == EglSurface::map.end()) + return EGL_FALSE; + + EglSurface* draw_surface = surface_it->second; + + surface_it = EglSurface::map.find(readSurf); + if (surface_it == EglSurface::map.end()) + return EGL_FALSE; + + EglSurface* read_surface = surface_it->second; + + RenderControl* rc = static_cast<RenderControl*>(ctx_); + + EglSurface* old_draw_surface = draw_surface->bind(rc->ctx->handle, false); + if (old_draw_surface) + old_draw_surface->unbind(false); + + EglSurface* old_read_surface = read_surface->bind(rc->ctx->handle, true); + if (old_read_surface) + old_read_surface->unbind(true); + + EglContext* old_context = context->bind(rc->ctx->handle); + if (old_context) + old_context->unbind(); + + EGLBoolean ret = s_egl.eglMakeCurrent(rc->dpy, draw_surface->surface, read_surface->surface, + context->context); + if (!ret) { + // If eglMakeCurrent fails, it's specified *not* to have unbound the + // previous contexts or surfaces, but many implementations do. This bug + // isn't worked around here, and we just assume the implementations obey + // the spec. + context->unbind(); + if (old_context) + old_context->bind(rc->ctx->handle); + read_surface->unbind(true); + if (old_read_surface) + old_read_surface->bind(rc->ctx->handle, true); + draw_surface->unbind(false); + if (old_draw_surface) + old_draw_surface->bind(rc->ctx->handle, false); + } else { + if (old_context && old_context->disposable()) + delete old_context; + if (old_read_surface && old_read_surface->disposable()) + delete old_read_surface; + if (old_draw_surface && old_draw_surface->disposable()) + delete old_draw_surface; + rc->ctx->unbind(); + rc->ctx->bind(context); + } + + return (EGLint)ret; +} + +static void rcFBPost(uint32_t) { + printf("%s: not implemented\n", __func__); +} + +static void rcFBSetSwapInterval(void* ctx_, EGLint interval) { + RenderControl* rc = static_cast<RenderControl*>(ctx_); + s_egl.eglSwapInterval(rc->dpy, interval); +} + +static void rcBindTexture(void* ctx_, uint32_t colorBuffer) { + std::map<uint32_t, Resource*>::iterator it; + it = Resource::map.find(colorBuffer); + if (it == Resource::map.end()) + return; + + RenderControl* rc = static_cast<RenderControl*>(ctx_); + Resource* res = it->second; + if (!res->image) { + ANativeWindowBuffer* buffer = resourceToANWB(res); + if (!buffer) + return; + + EGLClientBuffer client_buffer = static_cast<EGLClientBuffer>(buffer); + EGLImageKHR image = s_egl.eglCreateImageKHR( + rc->dpy, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID, client_buffer, nullptr); + if (image == EGL_NO_IMAGE_KHR) + return; + + EglImage* img = new (std::nothrow) EglImage(rc->dpy, image, s_egl.eglDestroyImageKHR); + if (!img) { + s_egl.eglDestroyImageKHR(rc->dpy, image); + return; + } + + // FIXME: House keeping, because we won't get asked to delete the image + // object otherwise, so we need to keep a reference to it.. + res->image = img; + } + + if (rc->ctx->ctx->api == EglContext::GLESApi::GLESApi_CM) { + // FIXME: Unconditional use of GL_TEXTURE_2D here is wrong + s_gles1.glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, res->image->image); + } else { + // FIXME: Unconditional use of GL_TEXTURE_2D here is wrong + s_gles3.glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, res->image->image); + } +} + +static void rcBindRenderbuffer(void* ctx_, uint32_t colorBuffer) { + std::map<uint32_t, Resource*>::iterator it; + it = Resource::map.find(colorBuffer); + if (it == Resource::map.end()) + return; + + RenderControl* rc = static_cast<RenderControl*>(ctx_); + Resource* res = it->second; + if (!res->image) { + ANativeWindowBuffer* buffer = resourceToANWB(res); + if (!buffer) + return; + + EGLClientBuffer client_buffer = static_cast<EGLClientBuffer>(buffer); + EGLImageKHR image = s_egl.eglCreateImageKHR( + rc->dpy, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID, client_buffer, nullptr); + if (image == EGL_NO_IMAGE_KHR) + return; + + EglImage* img = new (std::nothrow) EglImage(rc->dpy, image, s_egl.eglDestroyImageKHR); + if (!img) { + s_egl.eglDestroyImageKHR(rc->dpy, image); + return; + } + + // FIXME: House keeping, because we won't get asked to delete the image + // object otherwise, so we need to keep a reference to it.. + res->image = img; + } + + if (rc->ctx->ctx->api == EglContext::GLESApi::GLESApi_CM) { + s_gles1.glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER_OES, res->image->image); + } else { + s_gles3.glEGLImageTargetRenderbufferStorageOES(GL_RENDERBUFFER_OES, res->image->image); + } +} + +static EGLint rcColorBufferCacheFlush(uint32_t, EGLint, int) { + printf("%s: not implemented\n", __func__); + return 0; +} + +static void rcReadColorBuffer(uint32_t, GLint, GLint, GLint, GLint, GLenum, GLenum, void*) { + printf("%s: not implemented\n", __func__); +} + +static int rcUpdateColorBuffer(uint32_t, GLint, GLint, GLint, GLint, GLenum, GLenum, void*) { + printf("%s: not implemented\n", __func__); + return 0; +} + +static int rcOpenColorBuffer2(uint32_t) { + printf("%s: not implemented\n", __func__); + return 0; +} + +static uint32_t rcCreateClientImage(void* ctx_, uint32_t context_, EGLenum target, GLuint buffer_) { + std::map<uint32_t, EglContext*>::iterator it; + it = EglContext::map.find(context_); + if (it == EglContext::map.end()) + return 0U; + + EglContext* context = it->second; + + RenderControl* rc = static_cast<RenderControl*>(ctx_); + EGLClientBuffer buffer = reinterpret_cast<EGLClientBuffer>(buffer_); + EGLImageKHR image = s_egl.eglCreateImageKHR(rc->dpy, context, target, buffer, nullptr); + EglImage* img = new (std::nothrow) EglImage(rc->dpy, image, s_egl.eglDestroyImageKHR); + if (!img) { + s_egl.eglDestroyImageKHR(rc->dpy, image); + return 0U; + } + + return img->id; +} + +static int rcDestroyClientImage(uint32_t image_) { + std::map<uint32_t, EglImage*>::iterator it; + it = EglImage::map.find(image_); + if (it == EglImage::map.end()) + return EGL_FALSE; + + EglImage* image = it->second; + + delete image; + return EGL_TRUE; +} + +static void rcSelectChecksumHelper(void* ctx_, uint32_t protocol, uint32_t) { + RenderControl* rc = static_cast<RenderControl*>(ctx_); + rc->ctx->checksum_calc.setVersion(protocol); +} + +static void rcCreateSyncKHR(void* ctx_, EGLenum type, EGLint* attribs, uint32_t, int, + uint64_t* glsync_out, uint64_t* syncthread_out) { + *syncthread_out = 0ULL; + + RenderControl* rc = static_cast<RenderControl*>(ctx_); + EGLSyncKHR sync = s_egl.eglCreateSyncKHR(rc->dpy, type, attribs); + if (sync == EGL_NO_SYNC_KHR) { + *glsync_out = 0ULL; + return; + } + + EglSync* syn = new (std::nothrow) EglSync(sync); + if (!syn) { + s_egl.eglDestroySyncKHR(rc->dpy, sync); + *glsync_out = 0ULL; + return; + } + + *glsync_out = syn->id; +} + +static EGLint rcClientWaitSyncKHR(void* ctx_, uint64_t sync_, EGLint flags, uint64_t timeout) { + std::map<uint64_t, EglSync*>::iterator it; + it = EglSync::map.find(sync_); + if (it == EglSync::map.end()) + return EGL_CONDITION_SATISFIED_KHR; + + EglSync* sync = it->second; + RenderControl* rc = static_cast<RenderControl*>(ctx_); + return s_egl.eglClientWaitSyncKHR(rc->dpy, sync->sync, flags, timeout); +} + +static void rcFlushWindowColorBufferAsync(uint32_t windowSurface) { + // No-op +} + +static int rcDestroySyncKHR(void* ctx_, uint64_t sync_) { + std::map<uint64_t, EglSync*>::iterator it; + it = EglSync::map.find(sync_); + if (it == EglSync::map.end()) + return EGL_FALSE; + + EglSync* sync = it->second; + RenderControl* rc = static_cast<RenderControl*>(ctx_); + return s_egl.eglDestroySyncKHR(rc->dpy, sync->sync); +} + +static void rcSetPuid(void* ctx_, uint64_t proto) { + union { + uint64_t proto; + struct { + int pid; + int tid; + } id; + } puid; + + puid.proto = proto; + + RenderControl* rc = static_cast<RenderControl*>(ctx_); + rc->ctx->setPidTid(puid.id.pid, puid.id.tid); +} + +static int rcUpdateColorBufferDMA(uint32_t, GLint, GLint, GLint, GLint, GLenum, GLenum, void*, + uint32_t) { + printf("%s: not implemented\n", __func__); + return 0; +} + +static uint32_t rcCreateColorBufferDMA(uint32_t, uint32_t, GLenum, int) { + printf("%s: not implemented\n", __func__); + return 0U; +} + +static void rcWaitSyncKHR(void* ctx_, uint64_t sync_, EGLint flags) { + std::map<uint64_t, EglSync*>::iterator it; + it = EglSync::map.find(sync_); + if (it == EglSync::map.end()) + return; + + EglSync* sync = it->second; + RenderControl* rc = static_cast<RenderControl*>(ctx_); + // FIXME: No eglWaitSyncKHR support in SwiftShader + // This call will BLOCK when it should be asynchronous! + s_egl.eglClientWaitSyncKHR(rc->dpy, sync->sync, flags, EGL_FOREVER_KHR); +} + +RenderControl::RenderControl(Context* ctx_, EGLDisplay dpy_) { + rcGetRendererVersion = ::rcGetRendererVersion; + rcGetEGLVersion_dec = ::rcGetEGLVersion; + rcQueryEGLString_dec = ::rcQueryEGLString; + rcGetGLString_dec = ::rcGetGLString; + rcGetNumConfigs = ::rcGetNumConfigs; + rcGetConfigs = ::rcGetConfigs; + rcChooseConfig_dec = ::rcChooseConfig; + rcGetFBParam = ::rcGetFBParam; + rcCreateContext_dec = ::rcCreateContext; + rcDestroyContext_dec = ::rcDestroyContext; + rcCreateWindowSurface_dec = ::rcCreateWindowSurface; + rcDestroyWindowSurface_dec = ::rcDestroyWindowSurface; + rcCreateColorBuffer = ::rcCreateColorBuffer; + rcOpenColorBuffer = ::rcOpenColorBuffer; + rcCloseColorBuffer = ::rcCloseColorBuffer; + rcSetWindowColorBuffer_dec = ::rcSetWindowColorBuffer; + rcFlushWindowColorBuffer = ::rcFlushWindowColorBuffer; + rcMakeCurrent_dec = ::rcMakeCurrent; + rcFBPost = ::rcFBPost; + rcFBSetSwapInterval_dec = ::rcFBSetSwapInterval; + rcBindTexture_dec = ::rcBindTexture; + rcBindRenderbuffer_dec = ::rcBindRenderbuffer; + rcColorBufferCacheFlush = ::rcColorBufferCacheFlush; + rcReadColorBuffer = ::rcReadColorBuffer; + rcUpdateColorBuffer = ::rcUpdateColorBuffer; + rcOpenColorBuffer2 = ::rcOpenColorBuffer2; + rcCreateClientImage_dec = ::rcCreateClientImage; + rcDestroyClientImage = ::rcDestroyClientImage; + rcSelectChecksumHelper_dec = ::rcSelectChecksumHelper; + rcCreateSyncKHR_dec = ::rcCreateSyncKHR; + rcClientWaitSyncKHR_dec = ::rcClientWaitSyncKHR; + rcFlushWindowColorBufferAsync = ::rcFlushWindowColorBufferAsync; + rcDestroySyncKHR_dec = ::rcDestroySyncKHR; + rcSetPuid_dec = ::rcSetPuid; + rcUpdateColorBufferDMA = ::rcUpdateColorBufferDMA; + rcCreateColorBufferDMA = ::rcCreateColorBufferDMA; + rcWaitSyncKHR_dec = ::rcWaitSyncKHR; + + dpy = dpy_; + ctx = ctx_; +} diff --git a/host/libs/virglrenderer/RenderControl.h b/host/libs/virglrenderer/RenderControl.h new file mode 100644 index 000000000..146adf49e --- /dev/null +++ b/host/libs/virglrenderer/RenderControl.h @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2018 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 "renderControl_dec/renderControl_dec.h" + +typedef void* EGLDisplay; + +struct Context; + +struct RenderControl : public renderControl_decoder_context_t { + RenderControl(Context* ctx_, EGLDisplay dpy_); + EGLDisplay dpy; + Context* ctx; +}; diff --git a/host/libs/virglrenderer/Resource.h b/host/libs/virglrenderer/Resource.h new file mode 100644 index 000000000..eb127827d --- /dev/null +++ b/host/libs/virglrenderer/Resource.h @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2018 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 + +extern "C" { +#include <virgl/virglrenderer.h> +} + +#include <cstdint> +#include <cstdlib> +#include <map> + +#include <GLES/gl.h> + +#include <sys/uio.h> + +#include "EglImage.h" + +struct Context; + +struct Resource { + static std::map<uint32_t, Resource*> map; + + Resource(virgl_renderer_resource_create_args* args_, uint32_t num_iovs_, iovec* iov_) + : args(*args_), num_iovs(num_iovs_), tex_id(0U), iov(iov_) { + reallocLinear(); + map.emplace(args.handle, this); + } + + ~Resource() { + map.erase(args.handle); + delete image; + } + + void reallocLinear() { + if (linearShadow && num_iovs <= 1) + free(linear); + linearShadow = num_iovs > 1 ? true : false; + if (linearShadow) { + uint32_t i; + for (i = 0, linearSize = 0U; i < num_iovs; i++) + linearSize += iov[i].iov_len; + linear = realloc(linear, linearSize); + } else if (num_iovs == 1) { + linearSize = iov[0].iov_len; + linear = iov[0].iov_base; + } else { + linearSize = 0U; + linear = nullptr; + } + } + + std::map<uint32_t, Context*> context_map; + virgl_renderer_resource_create_args args; + EglImage* image = nullptr; + size_t linearSize = 0U; + void* linear = nullptr; + uint32_t num_iovs; + GLuint tex_id; + iovec* iov; + + private: + bool linearShadow = false; +}; diff --git a/host/libs/virglrenderer/emugl/common/logging.h b/host/libs/virglrenderer/emugl/common/logging.h index e5c77ef17..081df6132 100644 --- a/host/libs/virglrenderer/emugl/common/logging.h +++ b/host/libs/virglrenderer/emugl/common/logging.h @@ -1,22 +1,22 @@ /* -* Copyright (C) 2016 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. -*/ + * Copyright (C) 2018 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 "OpenglRender/render_api_types.h" +typedef void (*emugl_logger_t)(const char* fmt, ...); extern emugl_logger_t emugl_logger; extern emugl_logger_t emugl_cxt_logger; diff --git a/host/libs/virglrenderer/include/VirtioGpuCmd.h b/host/libs/virglrenderer/include/VirtioGpuCmd.h new file mode 100644 index 000000000..6ffacd3fc --- /dev/null +++ b/host/libs/virglrenderer/include/VirtioGpuCmd.h @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2018 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 + +struct VirtioGpuCmd { + uint32_t op; + uint32_t cmdSize; + unsigned char buf[0]; +} __attribute__((packed)); diff --git a/host/libs/virglrenderer/include/android/api-level.h b/host/libs/virglrenderer/include/android/api-level.h new file mode 100644 index 000000000..2d2f0968c --- /dev/null +++ b/host/libs/virglrenderer/include/android/api-level.h @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * All rights reserved. + * + * 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. + */ + +#ifndef ANDROID_API_LEVEL_H +#define ANDROID_API_LEVEL_H + +/* + * Magic version number for a current development build, which has + * not yet turned into an official release. + */ +#define __ANDROID_API__ 10000 + +#endif /* ANDROID_API_LEVEL_H */ diff --git a/host/libs/virglrenderer/include/android/sync.h b/host/libs/virglrenderer/include/android/sync.h new file mode 100644 index 000000000..1ae728a5a --- /dev/null +++ b/host/libs/virglrenderer/include/android/sync.h @@ -0,0 +1,21 @@ +/* + * Copyright (C) 2018 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 + +extern "C" { +int sync_wait(int fd, int timeout); +}; diff --git a/host/libs/virglrenderer/include/cutils/native_handle.h b/host/libs/virglrenderer/include/cutils/native_handle.h new file mode 100644 index 000000000..b92a66385 --- /dev/null +++ b/host/libs/virglrenderer/include/cutils/native_handle.h @@ -0,0 +1,21 @@ +/* + * Copyright (C) 2018 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 + +struct native_handle_t; + +typedef const struct native_handle_t* buffer_handle_t; diff --git a/host/libs/virglrenderer/include/hardware/gralloc.h b/host/libs/virglrenderer/include/hardware/gralloc.h new file mode 100644 index 000000000..8446ba4ea --- /dev/null +++ b/host/libs/virglrenderer/include/hardware/gralloc.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2018 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 <cutils/native_handle.h> + +#include <hardware/hardware.h> + +struct android_ycbcr; + +enum { + GRALLOC_USAGE_SW_READ_OFTEN = 0x00000003U, + GRALLOC_USAGE_SW_WRITE_OFTEN = 0x00000030U, + GRALLOC_USAGE_HW_TEXTURE = 0x00000100U, + GRALLOC_USAGE_HW_RENDER = 0x00000200U, +}; + +struct gralloc_module_t { + hw_module_t common; + int (*registerBuffer)(gralloc_module_t const*, buffer_handle_t); + int (*unregisterBuffer)(gralloc_module_t const*, buffer_handle_t); + int (*lock)(gralloc_module_t const*, buffer_handle_t, int, int, int, int, int, void**); + int (*unlock)(gralloc_module_t const*, buffer_handle_t); + int (*perform)(gralloc_module_t const*, int, ...); + int (*lock_ycbcr)(gralloc_module_t const*, buffer_handle_t, int, int, int, int, int, + android_ycbcr*); + int (*lockAsync)(gralloc_module_t const*, buffer_handle_t, int, int, int, int, int, void**, int); + int (*unlockAsync)(gralloc_module_t const*, buffer_handle_t, int*); + int (*lockAsync_ycbcr)(gralloc_module_t const*, buffer_handle_t, int, int, int, int, int, + android_ycbcr*, int); + void* reserved_proc[3]; +}; diff --git a/host/libs/virglrenderer/include/hardware/gralloc1.h b/host/libs/virglrenderer/include/hardware/gralloc1.h new file mode 100644 index 000000000..b02decfa0 --- /dev/null +++ b/host/libs/virglrenderer/include/hardware/gralloc1.h @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2018 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 <hardware/hardware.h> + +#include <cutils/native_handle.h> + +#define GRALLOC_MODULE_API_VERSION_1_0 HARDWARE_MAKE_API_VERSION(1, 0) + +#define GRALLOC_HARDWARE_MODULE_ID "gralloc" + +enum { + GRALLOC1_ERROR_NONE = 0, + GRALLOC1_ERROR_BAD_HANDLE = 2, + GRALLOC1_ERROR_BAD_VALUE = 3, + GRALLOC1_ERROR_UNDEFINED = 6, +}; + +enum { + GRALLOC1_FUNCTION_LOCK = 18, + GRALLOC1_FUNCTION_UNLOCK = 20, +}; + +enum { + GRALLOC1_CONSUMER_USAGE_CPU_READ = 1ULL << 1, + GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN = 1ULL << 2 | GRALLOC1_CONSUMER_USAGE_CPU_READ, + GRALLOC1_CONSUMER_USAGE_CPU_WRITE = 1ULL << 5, + GRALLOC1_CONSUMER_USAGE_CPU_WRITE_OFTEN = 1ULL << 6 | GRALLOC1_CONSUMER_USAGE_CPU_WRITE, + GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE = 1ULL << 8, +}; + +enum { + GRALLOC1_PRODUCER_USAGE_CPU_READ = 1ULL << 1, + GRALLOC1_PRODUCER_USAGE_CPU_READ_OFTEN = 1ULL << 2 | GRALLOC1_PRODUCER_USAGE_CPU_READ, + GRALLOC1_PRODUCER_USAGE_CPU_WRITE = 1ULL << 5, + GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN = 1ULL << 6 | GRALLOC1_PRODUCER_USAGE_CPU_WRITE, + GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET = 1ULL << 9, +}; + +typedef void (*gralloc1_function_pointer_t)(); + +struct gralloc1_rect_t { + int32_t left; + int32_t top; + int32_t width; + int32_t height; +}; + +struct gralloc1_device_t { + hw_device_t common; + void (*getCapabilities)(gralloc1_device_t*, uint32_t*, int32_t*); + gralloc1_function_pointer_t (*getFunction)(gralloc1_device_t*, int32_t); +}; + +typedef int32_t (*GRALLOC1_PFN_LOCK)(gralloc1_device_t*, buffer_handle_t, uint64_t, uint64_t, + const gralloc1_rect_t*, void**, int32_t); +typedef int32_t (*GRALLOC1_PFN_UNLOCK)(gralloc1_device_t*, buffer_handle_t, int32_t*); + +static inline int gralloc1_open(const hw_module_t* module, gralloc1_device_t** device) { + return module->methods->open(module, GRALLOC_HARDWARE_MODULE_ID, + reinterpret_cast<hw_device_t**>(device)); +} diff --git a/host/libs/virglrenderer/include/hardware/hardware.h b/host/libs/virglrenderer/include/hardware/hardware.h new file mode 100644 index 000000000..21d6dc4ab --- /dev/null +++ b/host/libs/virglrenderer/include/hardware/hardware.h @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2018 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 <cstdint> + +#define MAKE_TAG_CONSTANT(A, B, C, D) (((A) << 24) | ((B) << 16) | ((C) << 8) | (D)) + +#define HARDWARE_MODULE_TAG MAKE_TAG_CONSTANT('H', 'W', 'M', 'T') +#define HARDWARE_DEVICE_TAG MAKE_TAG_CONSTANT('H', 'W', 'D', 'T') + +#define HARDWARE_MAKE_API_VERSION(maj, min) ((((maj)&0xff) << 8) | ((min)&0xff)) + +#define HARDWARE_HAL_API_VERSION HARDWARE_MAKE_API_VERSION(1, 0) + +struct hw_module_methods_t; + +struct hw_module_t { + uint32_t tag; + uint16_t module_api_version; + uint16_t hal_api_version; + const char* id; + const char* name; + const char* author; + hw_module_methods_t* methods; + void* dso; +#ifdef __LP64__ + uint64_t reserved[32 - 7]; +#else + uint32_t reserved[32 - 7]; +#endif +}; + +struct hw_device_t { + uint32_t tag; + uint32_t version; + struct hw_module_t* module; +#ifdef __LP64__ + uint64_t reserved[12]; +#else + uint32_t reserved[12]; +#endif + int (*close)(hw_device_t* device); +}; + +struct hw_module_methods_t { + int (*open)(const hw_module_t*, const char*, hw_device_t**); +}; + +extern "C" { +int hw_get_module(const char* id, const hw_module_t** module); +}; diff --git a/host/libs/virglrenderer/include/nativebase/nativebase.h b/host/libs/virglrenderer/include/nativebase/nativebase.h new file mode 100644 index 000000000..c2e84d79a --- /dev/null +++ b/host/libs/virglrenderer/include/nativebase/nativebase.h @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2018 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 <cutils/native_handle.h> + +#include <cstdint> +#include <cstring> + +// clang-format off +#define ANDROID_NATIVE_MAKE_CONSTANT(a, b, c, d) \ + ((static_cast<unsigned int>(a) << 24) | \ + (static_cast<unsigned int>(b) << 16) | \ + (static_cast<unsigned int>(c) << 8) | \ + (static_cast<unsigned int>(d) << 0)) +// clang-format on + +struct android_native_base_t { + int magic; + int version; + void* reserved[4]; + void (*incRef)(android_native_base_t*); + void (*decRef)(android_native_base_t*); +}; + +#define ANDROID_NATIVE_BUFFER_MAGIC ANDROID_NATIVE_MAKE_CONSTANT('_', 'b', 'f', 'r') + +struct ANativeWindowBuffer { + ANativeWindowBuffer() { + common.magic = ANDROID_NATIVE_BUFFER_MAGIC; + common.version = sizeof(ANativeWindowBuffer); + memset(common.reserved, 0, sizeof(common.reserved)); + } + + android_native_base_t common; + + int width; + int height; + int stride; + int format; + int usage_deprecated; + uintptr_t layerCount; + + void* reserved[1]; + + const native_handle_t* handle; + uint64_t usage; + + void* reserved_proc[8 - (sizeof(uint64_t) / sizeof(void*))]; +}; diff --git a/host/libs/virglrenderer/include/sync/sync.h b/host/libs/virglrenderer/include/sync/sync.h new file mode 100644 index 000000000..1ae728a5a --- /dev/null +++ b/host/libs/virglrenderer/include/sync/sync.h @@ -0,0 +1,21 @@ +/* + * Copyright (C) 2018 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 + +extern "C" { +int sync_wait(int fd, int timeout); +}; diff --git a/host/libs/virglrenderer/include/system/graphics.h b/host/libs/virglrenderer/include/system/graphics.h new file mode 100644 index 000000000..884db9cc2 --- /dev/null +++ b/host/libs/virglrenderer/include/system/graphics.h @@ -0,0 +1,27 @@ +/* + * Copyright (C) 2018 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 + +enum { + HAL_PIXEL_FORMAT_RGBA_8888 = 1, + HAL_PIXEL_FORMAT_RGBX_8888 = 2, + HAL_PIXEL_FORMAT_RGB_888 = 3, + HAL_PIXEL_FORMAT_RGB_565 = 4, + HAL_PIXEL_FORMAT_BGRA_8888 = 5, + HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED = 34, + HAL_PIXEL_FORMAT_YV12 = 842094169, +}; diff --git a/host/libs/virglrenderer/include/system/window.h b/host/libs/virglrenderer/include/system/window.h new file mode 100644 index 000000000..f986274c1 --- /dev/null +++ b/host/libs/virglrenderer/include/system/window.h @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2018 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 <nativebase/nativebase.h> +#include <system/graphics.h> + +#define ANDROID_NATIVE_WINDOW_MAGIC ANDROID_NATIVE_MAKE_CONSTANT('_', 'w', 'n', 'd') + +enum { + NATIVE_WINDOW_WIDTH = 0, + NATIVE_WINDOW_HEIGHT = 1, +}; + +struct ANativeWindow { + ANativeWindow() : flags(0), minSwapInterval(0), maxSwapInterval(0), xdpi(0), ydpi(0) { + common.magic = ANDROID_NATIVE_BUFFER_MAGIC; + common.version = sizeof(ANativeWindowBuffer); + memset(common.reserved, 0, sizeof(common.reserved)); + } + + android_native_base_t common; + + const uint32_t flags; + const int minSwapInterval; + const int maxSwapInterval; + const float xdpi; + const float ydpi; + intptr_t oem[4]; + + int (*setSwapInterval)(ANativeWindow*, int); + int (*dequeueBuffer_DEPRECATED)(ANativeWindow*, ANativeWindowBuffer**); + int (*lockBuffer_DEPRECATED)(ANativeWindow*, ANativeWindowBuffer*); + int (*queueBuffer_DEPRECATED)(ANativeWindow*, ANativeWindowBuffer*); + int (*query)(const ANativeWindow*, int, int*); + int (*perform)(ANativeWindow*, int, ...); + int (*cancelBuffer_DEPRECATED)(ANativeWindow*, ANativeWindowBuffer*); + int (*dequeueBuffer)(ANativeWindow*, ANativeWindowBuffer**, int*); + int (*queueBuffer)(ANativeWindow*, ANativeWindowBuffer*, int); + int (*cancelBuffer)(ANativeWindow*, ANativeWindowBuffer*, int); +}; + +static inline int native_window_set_usage(ANativeWindow*, uint64_t) { + // No-op + return 0; +} + +static inline int native_window_dequeue_buffer_and_wait(ANativeWindow* anw, + ANativeWindowBuffer** anwb) { + return anw->dequeueBuffer_DEPRECATED(anw, anwb); +} diff --git a/host/libs/virglrenderer/libvirglrenderer.lds b/host/libs/virglrenderer/libvirglrenderer.lds new file mode 100644 index 000000000..9fc62d540 --- /dev/null +++ b/host/libs/virglrenderer/libvirglrenderer.lds @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2018 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. + */ + +{ +global: + # virglrenderer API + virgl_renderer_init; + virgl_renderer_poll; + virgl_renderer_get_cursor_data; + virgl_renderer_resource_create; + virgl_renderer_resource_unref; + virgl_renderer_context_create; + virgl_renderer_context_destroy; + virgl_renderer_submit_cmd; + virgl_renderer_transfer_read_iov; + virgl_renderer_transfer_write_iov; + virgl_renderer_get_cap_set; + virgl_renderer_fill_caps; + virgl_renderer_resource_attach_iov; + virgl_renderer_resource_detach_iov; + virgl_renderer_create_fence; + virgl_renderer_force_ctx_0; + virgl_renderer_ctx_attach_resource; + virgl_renderer_ctx_detach_resource; + virgl_renderer_resource_get_info; + + # fake gralloc1 implementation + hw_get_module; + + # fake libsync implementation + sync_wait; + + # Type-strings and type-infos required by sanitizers + _ZTS*; + _ZTI*; + +local: + *; +}; diff --git a/host/libs/virglrenderer/renderControl_dec/renderControl.attrib b/host/libs/virglrenderer/renderControl_dec/renderControl.attrib index 7e06ce419..6ff20b66e 100644 --- a/host/libs/virglrenderer/renderControl_dec/renderControl.attrib +++ b/host/libs/virglrenderer/renderControl_dec/renderControl.attrib @@ -1,21 +1,20 @@ -# For documentation on the .attrib file format, see: -# android/android-emugl/host/tools/emugen/README - GLOBAL - base_opcode 10000 - encoder_headers <stdint.h> <EGL/egl.h> "glUtils.h" + base_opcode 10000 rcGetEGLVersion + flag custom_decoder dir major out len major sizeof(EGLint) dir minor out len minor sizeof(EGLint) rcQueryEGLString + flag custom_decoder dir buffer out len buffer bufferSize rcGetGLString + flag custom_decoder dir buffer out len buffer bufferSize @@ -28,34 +27,79 @@ rcGetConfigs len buffer bufSize rcChooseConfig + flag custom_decoder dir attribs in len attribs attribs_size dir configs out var_flag configs nullAllowed len configs configs_size*sizeof(uint32_t) +rcCreateContext + flag custom_decoder + +rcDestroyContext + flag custom_decoder + +rcCreateWindowSurface + flag custom_decoder + +rcDestroyWindowSurface + flag custom_decoder + +rcCloseColorBuffer + flag flushOnEncode + +rcSetWindowColorBuffer + flag custom_decoder + +rcMakeCurrent + flag custom_decoder + +rcFBSetSwapInterval + flag custom_decoder + +rcBindTexture + flag custom_decoder + +rcBindRenderbuffer + flag custom_decoder + rcReadColorBuffer dir pixels out - len pixels (((glUtilsPixelBitSize(format, type) * width) >> 3) * height) rcUpdateColorBuffer dir pixels in - len pixels (((glUtilsPixelBitSize(format, type) * width) >> 3) * height) var_flag pixels isLarge -rcUpdateColorBufferDMA - dir pixels in - len pixels pixels_size - var_flag pixels DMA - flag flushOnEncode +rcCreateClientImage + flag custom_decoder -rcCloseColorBuffer - flag flushOnEncode +rcSelectChecksumHelper + flag custom_decoder rcCreateSyncKHR + flag custom_decoder dir attribs in len attribs num_attribs dir glsync_out out len glsync_out sizeof(uint64_t) dir syncthread_out out len syncthread_out sizeof(uint64_t) + +rcClientWaitSyncKHR + flag custom_decoder + +rcDestroySyncKHR + flag custom_decoder + +rcSetPuid + flag custom_decoder + +rcUpdateColorBufferDMA + dir pixels in + len pixels pixels_size + var_flag pixels DMA + flag flushOnEncode + +rcWaitSyncKHR + flag custom_decoder diff --git a/host/libs/virglrenderer/renderControl_dec/renderControl.in b/host/libs/virglrenderer/renderControl_dec/renderControl.in index 0cf77f653..e1dea92c1 100644 --- a/host/libs/virglrenderer/renderControl_dec/renderControl.in +++ b/host/libs/virglrenderer/renderControl_dec/renderControl.in @@ -20,7 +20,7 @@ GL_ENTRY(void, rcFBPost, uint32_t colorBuffer) GL_ENTRY(void, rcFBSetSwapInterval, EGLint interval) GL_ENTRY(void, rcBindTexture, uint32_t colorBuffer) GL_ENTRY(void, rcBindRenderbuffer, uint32_t colorBuffer) -GL_ENTRY(EGLint, rcColorBufferCacheFlush, uint32_t colorbuffer, EGLint postCount,int forRead) +GL_ENTRY(EGLint, rcColorBufferCacheFlush, uint32_t colorbuffer, EGLint postCount, int forRead) GL_ENTRY(void, rcReadColorBuffer, uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void *pixels) GL_ENTRY(int, rcUpdateColorBuffer, uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void *pixels) GL_ENTRY(int, rcOpenColorBuffer2, uint32_t colorbuffer) diff --git a/host/libs/virglrenderer/renderControl_dec/renderControl_types.h b/host/libs/virglrenderer/renderControl_dec/renderControl_types.h new file mode 100644 index 000000000..dd6b41271 --- /dev/null +++ b/host/libs/virglrenderer/renderControl_dec/renderControl_types.h @@ -0,0 +1,20 @@ +/* + * Copyright 2018 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 <EGL/egl.h> + +#include <GLES/gl.h> |