diff options
64 files changed, 1652 insertions, 886 deletions
diff --git a/cmds/atrace/atrace.cpp b/cmds/atrace/atrace.cpp index 8f2dee180f..14eff03705 100644 --- a/cmds/atrace/atrace.cpp +++ b/cmds/atrace/atrace.cpp @@ -1284,7 +1284,7 @@ int main(int argc, char **argv) fflush(stdout); int outFd = STDOUT_FILENO; if (g_outputFile) { - outFd = open(g_outputFile, O_WRONLY | O_CREAT, 0644); + outFd = open(g_outputFile, O_WRONLY | O_CREAT | O_TRUNC, 0644); } if (outFd == -1) { printf("Failed to open '%s', err=%d", g_outputFile, errno); diff --git a/cmds/dumpstate/dumpstate.cpp b/cmds/dumpstate/dumpstate.cpp index 349bbedc6d..ab323bbfb3 100644 --- a/cmds/dumpstate/dumpstate.cpp +++ b/cmds/dumpstate/dumpstate.cpp @@ -960,7 +960,7 @@ static void dumpstate() { {"ps", "-A", "-T", "-Z", "-O", "pri,nice,rtprio,sched,pcy"}); RunCommand("LIBRANK", {"librank"}, CommandOptions::AS_ROOT); - RunCommand("HARDWARE HALS", {"lshal"}); + RunCommand("HARDWARE HALS", {"lshal"}, CommandOptions::AS_ROOT); RunCommand("PRINTENV", {"printenv"}); RunCommand("NETSTAT", {"netstat", "-nW"}); @@ -1059,7 +1059,7 @@ static void dumpstate() { #endif DumpFile("INTERRUPTS (2)", "/proc/interrupts"); - print_properties(); + RunCommand("SYSTEM PROPERTIES", {"getprop"}); RunCommand("VOLD DUMP", {"vdc", "dump"}); RunCommand("SECURE CONTAINERS", {"vdc", "asec", "list"}); @@ -1161,7 +1161,7 @@ void Dumpstate::DumpstateBoard() { printf("== Board\n"); printf("========================================================\n"); - ::android::sp<IDumpstateDevice> dumpstate_device(IDumpstateDevice::getService("dumpstate")); + ::android::sp<IDumpstateDevice> dumpstate_device(IDumpstateDevice::getService()); if (dumpstate_device == nullptr) { MYLOGE("No IDumpstateDevice implementation\n"); return; diff --git a/cmds/dumpstate/dumpstate.h b/cmds/dumpstate/dumpstate.h index d988429fe1..7fcb9800bf 100644 --- a/cmds/dumpstate/dumpstate.h +++ b/cmds/dumpstate/dumpstate.h @@ -363,9 +363,6 @@ int dump_file_from_fd(const char *title, const char *path, int fd); int dump_files(const std::string& title, const char* dir, bool (*skip)(const char* path), int (*dump_from_fd)(const char* title, const char* path, int fd)); -/* prints all the system properties */ -void print_properties(); - /** opens a socket and returns its file descriptor */ int open_socket(const char *service); diff --git a/cmds/dumpstate/utils.cpp b/cmds/dumpstate/utils.cpp index baa6458283..4655d33763 100644 --- a/cmds/dumpstate/utils.cpp +++ b/cmds/dumpstate/utils.cpp @@ -710,40 +710,6 @@ void Dumpstate::RunDumpsys(const std::string& title, const std::vector<std::stri RunCommand(title, dumpsys, options); } -size_t num_props = 0; -static char* props[2000]; - -static void print_prop(const char *key, const char *name, void *user) { - (void) user; - if (num_props < sizeof(props) / sizeof(props[0])) { - char buf[PROPERTY_KEY_MAX + PROPERTY_VALUE_MAX + 10]; - snprintf(buf, sizeof(buf), "[%s]: [%s]\n", key, name); - props[num_props++] = strdup(buf); - } -} - -static int compare_prop(const void *a, const void *b) { - return strcmp(*(char * const *) a, *(char * const *) b); -} - -/* prints all the system properties */ -void print_properties() { - const char* title = "SYSTEM PROPERTIES"; - DurationReporter duration_reporter(title); - printf("------ %s ------\n", title); - if (PropertiesHelper::IsDryRun()) return; - size_t i; - num_props = 0; - property_list(print_prop, NULL); - qsort(&props, num_props, sizeof(props[0]), compare_prop); - - for (i = 0; i < num_props; ++i) { - fputs(props[i], stdout); - free(props[i]); - } - printf("\n"); -} - int open_socket(const char *service) { int s = android_get_control_socket(service); if (s < 0) { diff --git a/cmds/lshal/Android.bp b/cmds/lshal/Android.bp index 5aab35a450..39e0ba3468 100644 --- a/cmds/lshal/Android.bp +++ b/cmds/lshal/Android.bp @@ -18,8 +18,10 @@ cc_binary { "libbase", "libutils", "libhidlbase", - "android.hidl.manager@1.0", "libhidltransport", + "libhidl-gen-utils", + "libvintf", + "android.hidl.manager@1.0", ], srcs: [ "Lshal.cpp" diff --git a/cmds/lshal/Lshal.cpp b/cmds/lshal/Lshal.cpp index 6fd9b21368..e953dedea2 100644 --- a/cmds/lshal/Lshal.cpp +++ b/cmds/lshal/Lshal.cpp @@ -28,6 +28,9 @@ #include <android-base/parseint.h> #include <android/hidl/manager/1.0/IServiceManager.h> #include <hidl/ServiceManagement.h> +#include <hidl-util/FQName.h> +#include <vintf/HalManifest.h> +#include <vintf/parse_xml.h> #include "Timeout.h" @@ -58,12 +61,13 @@ static std::string toHexString(uint64_t t) { return os.str(); } -static std::pair<hidl_string, hidl_string> split(const hidl_string &s, char c) { +template<typename String> +static std::pair<String, String> splitFirst(const String &s, char c) { const char *pos = strchr(s.c_str(), c); if (pos == nullptr) { return {s, {}}; } - return {hidl_string(s.c_str(), pos - s.c_str()), hidl_string(pos + 1)}; + return {String(s.c_str(), pos - s.c_str()), String(pos + 1)}; } static std::vector<std::string> split(const std::string &s, char c) { @@ -81,6 +85,14 @@ static std::vector<std::string> split(const std::string &s, char c) { return components; } +static void replaceAll(std::string *s, char from, char to) { + for (size_t i = 0; i < s->size(); ++i) { + if (s->at(i) == from) { + s->at(i) = to; + } + } +} + std::string getCmdline(pid_t pid) { std::ifstream ifs("/proc/" + std::to_string(pid) + "/cmdline"); std::string cmdline; @@ -189,7 +201,78 @@ void Lshal::printLine( mOut << std::endl; } -void Lshal::dump() const { +void Lshal::dumpVintf() const { + vintf::HalManifest manifest; + for (const TableEntry &entry : mTable) { + + std::string fqInstanceName = entry.interfaceName; + + if (entry.source == LIST_DLLIB) { + // Quick hack to work around *'s + replaceAll(&fqInstanceName, '*', 'D'); + } + auto splittedFqInstanceName = splitFirst(fqInstanceName, '/'); + FQName fqName(splittedFqInstanceName.first); + if (!fqName.isValid()) { + mErr << "Warning: '" << splittedFqInstanceName.first + << "' is not a valid FQName." << std::endl; + continue; + } + // Strip out system libs. + // TODO(b/34772739): might want to add other framework HAL packages + if (fqName.inPackage("android.hidl")) { + continue; + } + std::string interfaceName = + entry.source == LIST_DLLIB ? "" : fqName.name(); + std::string instanceName = + entry.source == LIST_DLLIB ? "" : splittedFqInstanceName.second; + + vintf::Transport transport; + if (entry.transport == "hwbinder") { + transport = vintf::Transport::HWBINDER; + } else if (entry.transport == "passthrough") { + transport = vintf::Transport::PASSTHROUGH; + } else { + mErr << "Warning: '" << entry.transport << "' is not a valid transport." << std::endl; + continue; + } + + vintf::ManifestHal *hal = manifest.getHal(fqName.package()); + if (hal == nullptr) { + if (!manifest.add(vintf::ManifestHal{ + .format = vintf::HalFormat::HIDL, + .name = fqName.package(), + .impl = {.implLevel = vintf::ImplLevel::GENERIC, .impl = ""}, + .transport = transport + })) { + mErr << "Warning: cannot add hal '" << fqInstanceName << "'" << std::endl; + continue; + } + hal = manifest.getHal(fqName.package()); + } + if (hal == nullptr) { + mErr << "Warning: cannot get hal '" << fqInstanceName + << "' after adding it" << std::endl; + continue; + } + vintf::Version version{fqName.getPackageMajorVersion(), fqName.getPackageMinorVersion()}; + if (std::find(hal->versions.begin(), hal->versions.end(), version) == hal->versions.end()) { + hal->versions.push_back(version); + } + if (entry.source != LIST_DLLIB) { + auto it = hal->interfaces.find(interfaceName); + if (it == hal->interfaces.end()) { + hal->interfaces.insert({interfaceName, {interfaceName, {{instanceName}}}}); + } else { + it->second.instances.insert(instanceName); + } + } + } + mOut << vintf::gHalManifestConverter(manifest); +} + +void Lshal::dumpTable() const { mOut << "All services:" << std::endl; mOut << std::left; printLine("Interface", "Transport", "Server", "Server CMD", "PTR", "Clients", "Clients CMD"); @@ -204,6 +287,20 @@ void Lshal::dump() const { } } +void Lshal::dump() { + if (mVintf) { + dumpVintf(); + if (!!mFileOutput) { + mFileOutput.buf().close(); + delete &mFileOutput.buf(); + mFileOutput = nullptr; + } + mOut = std::cout; + } else { + dumpTable(); + } +} + void Lshal::putEntry(TableEntry &&entry) { mTable.push_back(std::forward<TableEntry>(entry)); } @@ -219,7 +316,8 @@ Status Lshal::fetchAllLibraries(const sp<IServiceManager> &manager) { .transport = "passthrough", .serverPid = NO_PID, .serverObjectAddress = NO_PTR, - .clientPids = {} + .clientPids = {}, + .source = LIST_DLLIB }); } }); @@ -244,7 +342,8 @@ Status Lshal::fetchPassthrough(const sp<IServiceManager> &manager) { .transport = "passthrough", .serverPid = info.clientPids.size() == 1 ? info.clientPids[0] : NO_PID, .serverObjectAddress = NO_PTR, - .clientPids = info.clientPids + .clientPids = info.clientPids, + .source = PTSERVICEMANAGER_REG_CLIENT }); } }); @@ -262,79 +361,85 @@ Status Lshal::fetchBinderized(const sp<IServiceManager> &manager) { using namespace ::android::hidl::manager::V1_0; using namespace ::android::hidl::base::V1_0; const std::string mode = "hwbinder"; + + hidl_vec<hidl_string> fqInstanceNames; + // copying out for timeoutIPC + auto listRet = timeoutIPC(manager, &IServiceManager::list, [&] (const auto &names) { + fqInstanceNames = names; + }); + if (!listRet.isOk()) { + mErr << "Error: Failed to list services for " << mode << ": " + << listRet.description() << std::endl; + return DUMP_BINDERIZED_ERROR; + } + Status status = OK; - auto listRet = timeoutIPC(manager, &IServiceManager::list, [&] (const auto &fqInstanceNames) { - // server pid, .ptr value of binder object, child pids - std::map<std::string, DebugInfo> allDebugInfos; - std::map<pid_t, std::map<uint64_t, Pids>> allPids; - for (const auto &fqInstanceName : fqInstanceNames) { - const auto pair = split(fqInstanceName, '/'); - const auto &serviceName = pair.first; - const auto &instanceName = pair.second; - auto getRet = timeoutIPC(manager, &IServiceManager::get, serviceName, instanceName); - if (!getRet.isOk()) { - mErr << "Warning: Skipping \"" << fqInstanceName << "\": " - << "cannot be fetched from service manager:" - << getRet.description() << std::endl; - status |= DUMP_BINDERIZED_ERROR; - continue; - } - sp<IBase> service = getRet; - if (service == nullptr) { - mErr << "Warning: Skipping \"" << fqInstanceName << "\": " - << "cannot be fetched from service manager (null)"; - status |= DUMP_BINDERIZED_ERROR; - continue; - } - auto debugRet = timeoutIPC(service, &IBase::getDebugInfo, [&] (const auto &debugInfo) { - allDebugInfos[fqInstanceName] = debugInfo; - if (debugInfo.pid >= 0) { - allPids[static_cast<pid_t>(debugInfo.pid)].clear(); - } - }); - if (!debugRet.isOk()) { - mErr << "Warning: Skipping \"" << fqInstanceName << "\": " - << "debugging information cannot be retrieved:" - << debugRet.description() << std::endl; - status |= DUMP_BINDERIZED_ERROR; - } + // server pid, .ptr value of binder object, child pids + std::map<std::string, DebugInfo> allDebugInfos; + std::map<pid_t, std::map<uint64_t, Pids>> allPids; + for (const auto &fqInstanceName : fqInstanceNames) { + const auto pair = splitFirst(fqInstanceName, '/'); + const auto &serviceName = pair.first; + const auto &instanceName = pair.second; + auto getRet = timeoutIPC(manager, &IServiceManager::get, serviceName, instanceName); + if (!getRet.isOk()) { + mErr << "Warning: Skipping \"" << fqInstanceName << "\": " + << "cannot be fetched from service manager:" + << getRet.description() << std::endl; + status |= DUMP_BINDERIZED_ERROR; + continue; } - for (auto &pair : allPids) { - pid_t serverPid = pair.first; - if (!getReferencedPids(serverPid, &allPids[serverPid])) { - mErr << "Warning: no information for PID " << serverPid - << ", are you root?" << std::endl; - status |= DUMP_BINDERIZED_ERROR; - } + sp<IBase> service = getRet; + if (service == nullptr) { + mErr << "Warning: Skipping \"" << fqInstanceName << "\": " + << "cannot be fetched from service manager (null)"; + status |= DUMP_BINDERIZED_ERROR; + continue; } - for (const auto &fqInstanceName : fqInstanceNames) { - auto it = allDebugInfos.find(fqInstanceName); - if (it == allDebugInfos.end()) { - putEntry({ - .interfaceName = fqInstanceName, - .transport = mode, - .serverPid = NO_PID, - .serverObjectAddress = NO_PTR, - .clientPids = {} - }); - continue; + auto debugRet = timeoutIPC(service, &IBase::getDebugInfo, [&] (const auto &debugInfo) { + allDebugInfos[fqInstanceName] = debugInfo; + if (debugInfo.pid >= 0) { + allPids[static_cast<pid_t>(debugInfo.pid)].clear(); } - const DebugInfo &info = it->second; + }); + if (!debugRet.isOk()) { + mErr << "Warning: Skipping \"" << fqInstanceName << "\": " + << "debugging information cannot be retrieved:" + << debugRet.description() << std::endl; + status |= DUMP_BINDERIZED_ERROR; + } + } + for (auto &pair : allPids) { + pid_t serverPid = pair.first; + if (!getReferencedPids(serverPid, &allPids[serverPid])) { + mErr << "Warning: no information for PID " << serverPid + << ", are you root?" << std::endl; + status |= DUMP_BINDERIZED_ERROR; + } + } + for (const auto &fqInstanceName : fqInstanceNames) { + auto it = allDebugInfos.find(fqInstanceName); + if (it == allDebugInfos.end()) { putEntry({ .interfaceName = fqInstanceName, .transport = mode, - .serverPid = info.pid, - .serverObjectAddress = info.ptr, - .clientPids = info.pid == NO_PID || info.ptr == NO_PTR - ? Pids{} : allPids[info.pid][info.ptr] + .serverPid = NO_PID, + .serverObjectAddress = NO_PTR, + .clientPids = {}, + .source = HWSERVICEMANAGER_LIST }); + continue; } - - }); - if (!listRet.isOk()) { - mErr << "Error: Failed to list services for " << mode << ": " - << listRet.description() << std::endl; - status |= DUMP_BINDERIZED_ERROR; + const DebugInfo &info = it->second; + putEntry({ + .interfaceName = fqInstanceName, + .transport = mode, + .serverPid = info.pid, + .serverObjectAddress = info.ptr, + .clientPids = info.pid == NO_PID || info.ptr == NO_PTR + ? Pids{} : allPids[info.pid][info.ptr], + .source = HWSERVICEMANAGER_LIST + }); } return status; } @@ -367,7 +472,7 @@ void Lshal::usage() const { << " Dump all hals with default ordering and columns [-itpc]." << std::endl << " lshal [--interface|-i] [--transport|-t]" << std::endl << " [--pid|-p] [--address|-a] [--clients|-c] [--cmdline|-m]" << std::endl - << " [--sort={interface|i|pid|p}]" << std::endl + << " [--sort={interface|i|pid|p}] [--init-vintf[=path]]" << std::endl << " -i, --interface: print the interface name column" << std::endl << " -n, --instance: print the instance name column" << std::endl << " -t, --transport: print the transport mode column" << std::endl @@ -378,6 +483,8 @@ void Lshal::usage() const { << " -m, --cmdline: print cmdline instead of PIDs" << std::endl << " --sort=i, --sort=interface: sort by interface name" << std::endl << " --sort=p, --sort=pid: sort by server pid" << std::endl + << " --init-vintf=path: form a skeleton HAL manifest to specified file " << std::endl + << " (stdout if no file specified)" << std::endl << " lshal [-h|--help]" << std::endl << " -h, --help: show this help information." << std::endl; } @@ -395,6 +502,7 @@ Status Lshal::parseArgs(int argc, char **argv) { // long options without short alternatives {"sort", required_argument, 0, 's' }, + {"init-vintf",optional_argument, 0, 'v' }, { 0, 0, 0, 0 } }; @@ -420,6 +528,17 @@ Status Lshal::parseArgs(int argc, char **argv) { } break; } + case 'v': { + if (optarg) { + mFileOutput = new std::ofstream{optarg}; + mOut = mFileOutput; + if (!mFileOutput.buf().is_open()) { + mErr << "Could not open file '" << optarg << "'." << std::endl; + return IO_ERROR; + } + } + mVintf = true; + } case 'i': { mSelectedColumns |= ENABLE_INTERFACE_NAME; break; diff --git a/cmds/lshal/Lshal.h b/cmds/lshal/Lshal.h index ead99dc068..1c30908189 100644 --- a/cmds/lshal/Lshal.h +++ b/cmds/lshal/Lshal.h @@ -19,12 +19,13 @@ #include <stdint.h> -#include <iostream> +#include <fstream> #include <string> #include <vector> #include <android/hidl/manager/1.0/IServiceManager.h> +#include "NullableOStream.h" #include "TableEntry.h" namespace android { @@ -38,6 +39,7 @@ enum : unsigned int { DUMP_BINDERIZED_ERROR = 1 << 3, DUMP_PASSTHROUGH_ERROR = 1 << 4, DUMP_ALL_LIBS_ERROR = 1 << 5, + IO_ERROR = 1 << 6, }; using Status = unsigned int; @@ -49,7 +51,7 @@ private: Status parseArgs(int argc, char **argv); Status fetch(); void postprocess(); - void dump() const; + void dump(); void usage() const; void putEntry(TableEntry &&entry); Status fetchPassthrough(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager); @@ -57,6 +59,8 @@ private: Status fetchAllLibraries(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager); bool getReferencedPids( pid_t serverPid, std::map<uint64_t, Pids> *objects) const; + void dumpTable() const; + void dumpVintf() const; void printLine( const std::string &interfaceName, const std::string &transport, const std::string &server, @@ -70,12 +74,14 @@ private: void removeDeadProcesses(Pids *pids); Table mTable{}; - std::ostream &mErr = std::cerr; - std::ostream &mOut = std::cout; + NullableOStream<std::ostream> mErr = std::cerr; + NullableOStream<std::ostream> mOut = std::cout; + NullableOStream<std::ofstream> mFileOutput = nullptr; TableEntryCompare mSortColumn = nullptr; TableEntrySelect mSelectedColumns = 0; // If true, cmdlines will be printed instead of pid. - bool mEnableCmdlines; + bool mEnableCmdlines = false; + bool mVintf = false; // If an entry does not exist, need to ask /proc/{pid}/cmdline to get it. // If an entry exist but is an empty string, process might have died. // If an entry exist and not empty, it contains the cached content of /proc/{pid}/cmdline. diff --git a/cmds/lshal/NullableOStream.h b/cmds/lshal/NullableOStream.h new file mode 100644 index 0000000000..ab37a04c56 --- /dev/null +++ b/cmds/lshal/NullableOStream.h @@ -0,0 +1,73 @@ +/* + * 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. + */ + +#ifndef FRAMEWORK_NATIVE_CMDS_LSHAL_NULLABLE_O_STREAM_H_ +#define FRAMEWORK_NATIVE_CMDS_LSHAL_NULLABLE_O_STREAM_H_ + +#include <iostream> + +namespace android { +namespace lshal { + +template<typename S> +class NullableOStream { +public: + NullableOStream(S &os) : mOs(&os) {} + NullableOStream(S *os) : mOs(os) {} + NullableOStream &operator=(S &os) { + mOs = &os; + return *this; + } + NullableOStream &operator=(S *os) { + mOs = os; + return *this; + } + template<typename Other> + NullableOStream &operator=(const NullableOStream<Other> &other) { + mOs = other.mOs; + return *this; + } + + const NullableOStream &operator<<(std::ostream& (*pf)(std::ostream&)) const { + if (mOs) { + (*mOs) << pf; + } + return *this; + } + template<typename T> + const NullableOStream &operator<<(const T &rhs) const { + if (mOs) { + (*mOs) << rhs; + } + return *this; + } + S& buf() const { + return *mOs; + } + operator bool() const { + return mOs != nullptr; + } +private: + template<typename> + friend class NullableOStream; + + S *mOs = nullptr; +}; + +} // namespace lshal +} // namespace android + +#endif // FRAMEWORK_NATIVE_CMDS_LSHAL_NULLABLE_O_STREAM_H_ diff --git a/cmds/lshal/TableEntry.h b/cmds/lshal/TableEntry.h index 4ec3a0ced1..e55806e2b6 100644 --- a/cmds/lshal/TableEntry.h +++ b/cmds/lshal/TableEntry.h @@ -28,6 +28,13 @@ namespace lshal { using Pids = std::vector<int32_t>; +enum : unsigned int { + HWSERVICEMANAGER_LIST, // through defaultServiceManager()->list() + PTSERVICEMANAGER_REG_CLIENT, // through registerPassthroughClient + LIST_DLLIB, // through listing dynamic libraries +}; +using TableEntrySource = unsigned int; + struct TableEntry { std::string interfaceName; std::string transport; @@ -36,6 +43,7 @@ struct TableEntry { uint64_t serverObjectAddress; Pids clientPids; std::vector<std::string> clientCmdlines; + TableEntrySource source; static bool sortByInterfaceName(const TableEntry &a, const TableEntry &b) { return a.interfaceName < b.interfaceName; diff --git a/cmds/surfacereplayer/replayer/Replayer.cpp b/cmds/surfacereplayer/replayer/Replayer.cpp index a49da37edf..35b63ec5c3 100644 --- a/cmds/surfacereplayer/replayer/Replayer.cpp +++ b/cmds/surfacereplayer/replayer/Replayer.cpp @@ -22,8 +22,6 @@ #include <android-base/file.h> -#include <binder/IMemory.h> - #include <gui/BufferQueue.h> #include <gui/ISurfaceComposer.h> #include <gui/Surface.h> diff --git a/include/android/multinetwork.h b/include/android/multinetwork.h index be0151881a..97892f8a74 100644 --- a/include/android/multinetwork.h +++ b/include/android/multinetwork.h @@ -56,12 +56,10 @@ typedef uint64_t net_handle_t; /** * Set the network to be used by the given socket file descriptor. * - * To clear a previous socket binding invoke with NETWORK_UNSPECIFIED. + * To clear a previous socket binding, invoke with NETWORK_UNSPECIFIED. * - * This is the equivalent of: + * This is the equivalent of: [android.net.Network#bindSocket()](https://developer.android.com/reference/android/net/Network.html#bindSocket(java.net.Socket)) * - * [ android.net.Network#bindSocket() ] - * https://developer.android.com/reference/android/net/Network.html#bindSocket(java.net.Socket) */ int android_setsocknetwork(net_handle_t network, int fd); @@ -75,12 +73,10 @@ int android_setsocknetwork(net_handle_t network, int fd); * resolutions will fail. This is by design so an application doesn't * accidentally use sockets it thinks are still bound to a particular network. * - * To clear a previous process binding invoke with NETWORK_UNSPECIFIED. + * To clear a previous process binding, invoke with NETWORK_UNSPECIFIED. * - * This is the equivalent of: + * This is the equivalent of: [android.net.ConnectivityManager#setProcessDefaultNetwork()](https://developer.android.com/reference/android/net/ConnectivityManager.html#setProcessDefaultNetwork(android.net.Network)) * - * [ android.net.ConnectivityManager#setProcessDefaultNetwork() ] - * https://developer.android.com/reference/android/net/ConnectivityManager.html#setProcessDefaultNetwork(android.net.Network) */ int android_setprocnetwork(net_handle_t network); @@ -96,10 +92,8 @@ int android_setprocnetwork(net_handle_t network); * - either |node| or |service| may be NULL, but not both * - |res| must not be NULL * - * This is the equivalent of: + * This is the equivalent of: [android.net.Network#getAllByName()](https://developer.android.com/reference/android/net/Network.html#getAllByName(java.lang.String)) * - * [ android.net.Network#getAllByName() ] - * https://developer.android.com/reference/android/net/Network.html#getAllByName(java.lang.String) */ int android_getaddrinfofornetwork(net_handle_t network, const char *node, const char *service, diff --git a/include/android/sharedmem.h b/include/android/sharedmem.h new file mode 100644 index 0000000000..8f8a9314c2 --- /dev/null +++ b/include/android/sharedmem.h @@ -0,0 +1,120 @@ +/* + * 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. + */ + +/** + * @addtogroup Memory + * @{ + */ + +/** + * @file sharedmem.h + */ + +#ifndef ANDROID_SHARED_MEMORY_H +#define ANDROID_SHARED_MEMORY_H + +#include <stddef.h> + +/****************************************************************** + * + * IMPORTANT NOTICE: + * + * This file is part of Android's set of stable system headers + * exposed by the Android NDK (Native Development Kit). + * + * Third-party source AND binary code relies on the definitions + * here to be FROZEN ON ALL UPCOMING PLATFORM RELEASES. + * + * - DO NOT MODIFY ENUMS (EXCEPT IF YOU ADD NEW 32-BIT VALUES) + * - DO NOT MODIFY CONSTANTS OR FUNCTIONAL MACROS + * - DO NOT CHANGE THE SIGNATURE OF FUNCTIONS IN ANY WAY + * - DO NOT CHANGE THE LAYOUT OR SIZE OF STRUCTURES + */ + +/** + * Structures and functions for a shared memory buffer that can be shared across process. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#if __ANDROID_API__ >= __ANDROID_API_O__ + +/** + * Create a shared memory region. + * + * Create shared memory region and returns an file descriptor. The resulting file descriptor can be + * mmap'ed to process memory space with PROT_READ | PROT_WRITE | PROT_EXEC. Access to shared memory + * region can be restricted with {@link ASharedMemory_setProt}. + * + * Use close() to release the shared memory region. + * + * \param name an optional name. + * \param size size of the shared memory region + * \return file descriptor that denotes the shared memory; error code on failure. + */ +int ASharedMemory_create(const char *name, size_t size); + +/** + * Get the size of the shared memory region. + * + * \param fd file descriptor of the shared memory region + * \return size in bytes; 0 if fd is not a valid shared memory file descriptor. + */ +size_t ASharedMemory_getSize(int fd); + +/** + * Restrict access of shared memory region. + * + * This function restricts access of a shared memory region. Access can only be removed. The effect + * applies globally to all file descriptors in all processes across the system that refer to this + * shared memory region. Existing memory mapped regions are not affected. + * + * It is a common use case to create a shared memory region, map it read/write locally to intialize + * content, and then send the shared memory to another process with read only access. Code example + * as below (error handling ommited). + * + * \code{.c} + * int fd = ASharedMemory_create("memory", 128); + * + * // By default it has PROT_READ | PROT_WRITE | PROT_EXEC. + * char *buffer = (char *) mmap(NULL, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + * + * strcpy(buffer, "This is an example."); // trivially initialize content + * + * // limit access to read only + * ASharedMemory_setProt(fd, PROT_READ); + * + * // share fd with another process here and the other process can only map with PROT_READ. + * \endcode + * + * \param fd file descriptor of the shared memory region. + * \param prot any bitwise-or'ed combination of PROT_READ, PROT_WRITE, PROT_EXEC denoting + * updated access. Note access can only be removed, but not added back. + * \return 0 for success, error code on failure. + */ +int ASharedMemory_setProt(int fd, int prot); + +#endif + +#ifdef __cplusplus +}; +#endif + +#endif // ANDROID_SHARED_MEMORY_H + +/** @} */ diff --git a/include/gui/SurfaceComposerClient.h b/include/gui/SurfaceComposerClient.h index 520a7ab9b1..1e8cf76627 100644 --- a/include/gui/SurfaceComposerClient.h +++ b/include/gui/SurfaceComposerClient.h @@ -21,7 +21,6 @@ #include <sys/types.h> #include <binder/IBinder.h> -#include <binder/IMemory.h> #include <utils/RefBase.h> #include <utils/Singleton.h> @@ -148,7 +147,7 @@ public: status_t setTransparentRegionHint(const sp<IBinder>& id, const Region& transparent); status_t setLayer(const sp<IBinder>& id, int32_t layer); status_t setAlpha(const sp<IBinder>& id, float alpha=1.0f); - status_t setMatrix(const sp<IBinder>& id, float dsdx, float dtdx, float dsdy, float dtdy); + status_t setMatrix(const sp<IBinder>& id, float dsdx, float dtdx, float dtdy, float dsdy); status_t setPosition(const sp<IBinder>& id, float x, float y); status_t setSize(const sp<IBinder>& id, uint32_t w, uint32_t h); status_t setCrop(const sp<IBinder>& id, const Rect& crop); diff --git a/include/gui/SurfaceControl.h b/include/gui/SurfaceControl.h index 58ec6dce2a..8ee35bc495 100644 --- a/include/gui/SurfaceControl.h +++ b/include/gui/SurfaceControl.h @@ -69,7 +69,7 @@ public: status_t setFlags(uint32_t flags, uint32_t mask); status_t setTransparentRegionHint(const Region& transparent); status_t setAlpha(float alpha=1.0f); - status_t setMatrix(float dsdx, float dtdx, float dsdy, float dtdy); + status_t setMatrix(float dsdx, float dtdx, float dtdy, float dsdy); status_t setCrop(const Rect& crop); status_t setFinalCrop(const Rect& crop); diff --git a/include/private/binder/Static.h b/include/private/binder/Static.h index d104646804..3d10456a8d 100644 --- a/include/private/binder/Static.h +++ b/include/private/binder/Static.h @@ -20,7 +20,6 @@ #include <utils/threads.h> #include <binder/IBinder.h> -#include <binder/IMemory.h> #include <binder/ProcessState.h> #include <binder/IPermissionController.h> #include <binder/IServiceManager.h> diff --git a/include/private/gui/LayerState.h b/include/private/gui/LayerState.h index 6d2b0825aa..20f51a57ce 100644 --- a/include/private/gui/LayerState.h +++ b/include/private/gui/LayerState.h @@ -79,8 +79,8 @@ struct layer_state_t { struct matrix22_t { float dsdx{0}; float dtdx{0}; - float dsdy{0}; float dtdy{0}; + float dsdy{0}; }; sp<IBinder> surface; uint32_t what; diff --git a/libs/gui/ISurfaceComposer.cpp b/libs/gui/ISurfaceComposer.cpp index 06d1261feb..4d2692fe62 100644 --- a/libs/gui/ISurfaceComposer.cpp +++ b/libs/gui/ISurfaceComposer.cpp @@ -21,7 +21,6 @@ #include <sys/types.h> #include <binder/Parcel.h> -#include <binder/IMemory.h> #include <binder/IPCThreadState.h> #include <binder/IServiceManager.h> diff --git a/libs/gui/ISurfaceComposerClient.cpp b/libs/gui/ISurfaceComposerClient.cpp index 5a3fa04379..db8a517d4d 100644 --- a/libs/gui/ISurfaceComposerClient.cpp +++ b/libs/gui/ISurfaceComposerClient.cpp @@ -22,7 +22,6 @@ #include <sys/types.h> #include <binder/Parcel.h> -#include <binder/IMemory.h> #include <binder/IPCThreadState.h> #include <binder/IServiceManager.h> diff --git a/libs/gui/SurfaceComposerClient.cpp b/libs/gui/SurfaceComposerClient.cpp index 2632781982..088933afb6 100644 --- a/libs/gui/SurfaceComposerClient.cpp +++ b/libs/gui/SurfaceComposerClient.cpp @@ -26,7 +26,6 @@ #include <utils/String8.h> #include <utils/threads.h> -#include <binder/IMemory.h> #include <binder/IServiceManager.h> #include <system/graphics.h> @@ -158,7 +157,7 @@ public: status_t setAlpha(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, float alpha); status_t setMatrix(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, - float dsdx, float dtdx, float dsdy, float dtdy); + float dsdx, float dtdx, float dtdy, float dsdy); status_t setOrientation(int orientation); status_t setCrop(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, const Rect& crop); @@ -398,7 +397,7 @@ status_t Composer::setLayerStack(const sp<SurfaceComposerClient>& client, status_t Composer::setMatrix(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, float dsdx, float dtdx, - float dsdy, float dtdy) { + float dtdy, float dsdy) { Mutex::Autolock _l(mLock); layer_state_t* s = getLayerStateLocked(client, id); if (!s) @@ -800,8 +799,8 @@ status_t SurfaceComposerClient::setLayerStack(const sp<IBinder>& id, uint32_t la } status_t SurfaceComposerClient::setMatrix(const sp<IBinder>& id, float dsdx, float dtdx, - float dsdy, float dtdy) { - return getComposer().setMatrix(this, id, dsdx, dtdx, dsdy, dtdy); + float dtdy, float dsdy) { + return getComposer().setMatrix(this, id, dsdx, dtdx, dtdy, dsdy); } status_t SurfaceComposerClient::deferTransactionUntil(const sp<IBinder>& id, diff --git a/libs/gui/SurfaceControl.cpp b/libs/gui/SurfaceControl.cpp index 0080ff9812..1e693796eb 100644 --- a/libs/gui/SurfaceControl.cpp +++ b/libs/gui/SurfaceControl.cpp @@ -147,10 +147,10 @@ status_t SurfaceControl::setAlpha(float alpha) { if (err < 0) return err; return mClient->setAlpha(mHandle, alpha); } -status_t SurfaceControl::setMatrix(float dsdx, float dtdx, float dsdy, float dtdy) { +status_t SurfaceControl::setMatrix(float dsdx, float dtdx, float dtdy, float dsdy) { status_t err = validate(); if (err < 0) return err; - return mClient->setMatrix(mHandle, dsdx, dtdx, dsdy, dtdy); + return mClient->setMatrix(mHandle, dsdx, dtdx, dtdy, dsdy); } status_t SurfaceControl::setCrop(const Rect& crop) { status_t err = validate(); diff --git a/libs/gui/tests/Surface_test.cpp b/libs/gui/tests/Surface_test.cpp index ceeb90a4f6..012dbe7c95 100644 --- a/libs/gui/tests/Surface_test.cpp +++ b/libs/gui/tests/Surface_test.cpp @@ -18,7 +18,6 @@ #include <gtest/gtest.h> -#include <binder/IMemory.h> #include <binder/ProcessState.h> #include <gui/IDisplayEventConnection.h> #include <gui/ISurfaceComposer.h> diff --git a/libs/nativewindow/AHardwareBuffer.cpp b/libs/nativewindow/AHardwareBuffer.cpp index b4b5303032..3fbab175f1 100644 --- a/libs/nativewindow/AHardwareBuffer.cpp +++ b/libs/nativewindow/AHardwareBuffer.cpp @@ -57,7 +57,8 @@ int AHardwareBuffer_allocate(const AHardwareBuffer_Desc* desc, AHardwareBuffer** uint64_t producerUsage = 0; uint64_t consumerUsage = 0; - AHardwareBuffer_convertToGrallocUsageBits(desc->usage0, &producerUsage, &consumerUsage); + AHardwareBuffer_convertToGrallocUsageBits(&producerUsage, &consumerUsage, desc->usage0, + desc->usage1); sp<GraphicBuffer> gbuffer(new GraphicBuffer( desc->width, desc->height, format, desc->layers, producerUsage, consumerUsage, @@ -97,9 +98,8 @@ void AHardwareBuffer_describe(const AHardwareBuffer* buffer, outDesc->width = gbuffer->getWidth(); outDesc->height = gbuffer->getHeight(); outDesc->layers = gbuffer->getLayerCount(); - outDesc->usage0 = AHardwareBuffer_convertFromGrallocUsageBits( + AHardwareBuffer_convertFromGrallocUsageBits(&outDesc->usage0, &outDesc->usage1, gbuffer->getUsage(), gbuffer->getUsage()); - outDesc->usage1 = 0; outDesc->format = AHardwareBuffer_convertFromPixelFormat( static_cast<uint32_t>(gbuffer->getPixelFormat())); } @@ -117,7 +117,7 @@ int AHardwareBuffer_lock(AHardwareBuffer* buffer, uint64_t usage0, uint64_t producerUsage = 0; uint64_t consumerUsage = 0; - AHardwareBuffer_convertToGrallocUsageBits(usage0, &producerUsage, &consumerUsage); + AHardwareBuffer_convertToGrallocUsageBits(&producerUsage, &consumerUsage, usage0, 0); GraphicBuffer* gBuffer = AHardwareBuffer_to_GraphicBuffer(buffer); Rect bounds; if (!rect) { @@ -268,8 +268,76 @@ const struct native_handle* AHardwareBuffer_getNativeHandle( namespace android { +// A 1:1 mapping of AHardwaqreBuffer bitmasks to gralloc1 bitmasks. +struct UsageMaskMapping { + uint64_t hardwareBufferMask; + uint64_t grallocMask; +}; + +static constexpr UsageMaskMapping kUsage0ProducerMapping[] = { + { AHARDWAREBUFFER_USAGE0_CPU_WRITE, GRALLOC1_PRODUCER_USAGE_CPU_WRITE }, + { AHARDWAREBUFFER_USAGE0_CPU_WRITE_OFTEN, GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN }, + { AHARDWAREBUFFER_USAGE0_GPU_COLOR_OUTPUT, GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET }, + { AHARDWAREBUFFER_USAGE0_PROTECTED_CONTENT, GRALLOC1_PRODUCER_USAGE_PROTECTED }, + { AHARDWAREBUFFER_USAGE0_SENSOR_DIRECT_DATA, GRALLOC1_PRODUCER_USAGE_SENSOR_DIRECT_DATA }, +}; + +static constexpr UsageMaskMapping kUsage1ProducerMapping[] = { + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_0, GRALLOC1_PRODUCER_USAGE_PRIVATE_0 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_1, GRALLOC1_PRODUCER_USAGE_PRIVATE_1 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_2, GRALLOC1_PRODUCER_USAGE_PRIVATE_2 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_3, GRALLOC1_PRODUCER_USAGE_PRIVATE_3 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_4, GRALLOC1_PRODUCER_USAGE_PRIVATE_4 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_5, GRALLOC1_PRODUCER_USAGE_PRIVATE_5 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_6, GRALLOC1_PRODUCER_USAGE_PRIVATE_6 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_7, GRALLOC1_PRODUCER_USAGE_PRIVATE_7 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_8, GRALLOC1_PRODUCER_USAGE_PRIVATE_8 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_9, GRALLOC1_PRODUCER_USAGE_PRIVATE_9 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_10, GRALLOC1_PRODUCER_USAGE_PRIVATE_10 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_11, GRALLOC1_PRODUCER_USAGE_PRIVATE_11 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_12, GRALLOC1_PRODUCER_USAGE_PRIVATE_12 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_13, GRALLOC1_PRODUCER_USAGE_PRIVATE_13 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_14, GRALLOC1_PRODUCER_USAGE_PRIVATE_14 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_15, GRALLOC1_PRODUCER_USAGE_PRIVATE_15 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_16, GRALLOC1_PRODUCER_USAGE_PRIVATE_16 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_17, GRALLOC1_PRODUCER_USAGE_PRIVATE_17 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_18, GRALLOC1_PRODUCER_USAGE_PRIVATE_18 }, + { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_19, GRALLOC1_PRODUCER_USAGE_PRIVATE_19 }, +}; + +static constexpr UsageMaskMapping kUsage0ConsumerMapping[] = { + { AHARDWAREBUFFER_USAGE0_CPU_READ, GRALLOC1_CONSUMER_USAGE_CPU_READ }, + { AHARDWAREBUFFER_USAGE0_CPU_READ_OFTEN, GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN }, + { AHARDWAREBUFFER_USAGE0_GPU_SAMPLED_IMAGE, GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE }, + { AHARDWAREBUFFER_USAGE0_GPU_DATA_BUFFER, GRALLOC1_CONSUMER_USAGE_GPU_DATA_BUFFER }, + { AHARDWAREBUFFER_USAGE0_VIDEO_ENCODE, GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER }, +}; + +static constexpr UsageMaskMapping kUsage1ConsumerMapping[] = { + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_0, GRALLOC1_CONSUMER_USAGE_PRIVATE_0 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_1, GRALLOC1_CONSUMER_USAGE_PRIVATE_1 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_2, GRALLOC1_CONSUMER_USAGE_PRIVATE_2 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_3, GRALLOC1_CONSUMER_USAGE_PRIVATE_3 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_4, GRALLOC1_CONSUMER_USAGE_PRIVATE_4 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_5, GRALLOC1_CONSUMER_USAGE_PRIVATE_5 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_6, GRALLOC1_CONSUMER_USAGE_PRIVATE_6 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_7, GRALLOC1_CONSUMER_USAGE_PRIVATE_7 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_8, GRALLOC1_CONSUMER_USAGE_PRIVATE_8 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_9, GRALLOC1_CONSUMER_USAGE_PRIVATE_9 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_10, GRALLOC1_CONSUMER_USAGE_PRIVATE_10 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_11, GRALLOC1_CONSUMER_USAGE_PRIVATE_11 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_12, GRALLOC1_CONSUMER_USAGE_PRIVATE_12 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_13, GRALLOC1_CONSUMER_USAGE_PRIVATE_13 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_14, GRALLOC1_CONSUMER_USAGE_PRIVATE_14 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_15, GRALLOC1_CONSUMER_USAGE_PRIVATE_15 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_16, GRALLOC1_CONSUMER_USAGE_PRIVATE_16 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_17, GRALLOC1_CONSUMER_USAGE_PRIVATE_17 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_18, GRALLOC1_CONSUMER_USAGE_PRIVATE_18 }, + { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_19, GRALLOC1_CONSUMER_USAGE_PRIVATE_19 }, +}; + static inline bool containsBits(uint64_t mask, uint64_t bitsToCheck) { - return (mask & bitsToCheck) == bitsToCheck; + return (mask & bitsToCheck) == bitsToCheck && bitsToCheck; } uint32_t AHardwareBuffer_convertFromPixelFormat(uint32_t format) { @@ -300,58 +368,56 @@ uint32_t AHardwareBuffer_convertToPixelFormat(uint32_t format) { } } -void AHardwareBuffer_convertToGrallocUsageBits(uint64_t usage, uint64_t* outProducerUsage, - uint64_t* outConsumerUsage) { +void AHardwareBuffer_convertToGrallocUsageBits(uint64_t* outProducerUsage, + uint64_t* outConsumerUsage, uint64_t usage0, uint64_t usage1) { *outProducerUsage = 0; *outConsumerUsage = 0; - if (containsBits(usage, AHARDWAREBUFFER_USAGE0_CPU_READ)) - *outConsumerUsage |= GRALLOC1_CONSUMER_USAGE_CPU_READ; - if (containsBits(usage, AHARDWAREBUFFER_USAGE0_CPU_READ_OFTEN)) - *outConsumerUsage |= GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN; - if (containsBits(usage, AHARDWAREBUFFER_USAGE0_CPU_WRITE)) - *outProducerUsage |= GRALLOC1_PRODUCER_USAGE_CPU_WRITE; - if (containsBits(usage, AHARDWAREBUFFER_USAGE0_CPU_WRITE_OFTEN)) - *outProducerUsage |= GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN; - if (containsBits(usage, AHARDWAREBUFFER_USAGE0_GPU_SAMPLED_IMAGE)) - *outConsumerUsage |= GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE; - if (containsBits(usage, AHARDWAREBUFFER_USAGE0_GPU_COLOR_OUTPUT)) - *outProducerUsage |= GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET; - // Not sure what this should be. - //if (containsBits(usage0, AHARDWAREBUFFER_USAGE0_GPU_CUBEMAP)) bits |= 0; - if (containsBits(usage, AHARDWAREBUFFER_USAGE0_GPU_DATA_BUFFER)) - *outConsumerUsage |= GRALLOC1_CONSUMER_USAGE_GPU_DATA_BUFFER; - if (containsBits(usage, AHARDWAREBUFFER_USAGE0_VIDEO_ENCODE)) - *outConsumerUsage |= GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER; - if (containsBits(usage, AHARDWAREBUFFER_USAGE0_PROTECTED_CONTENT)) - *outProducerUsage |= GRALLOC1_PRODUCER_USAGE_PROTECTED; - if (containsBits(usage, AHARDWAREBUFFER_USAGE0_SENSOR_DIRECT_DATA)) - *outProducerUsage |= GRALLOC1_PRODUCER_USAGE_SENSOR_DIRECT_DATA; + for (const UsageMaskMapping& mapping : kUsage0ProducerMapping) { + if (containsBits(usage0, mapping.hardwareBufferMask)) { + *outProducerUsage |= mapping.grallocMask; + } + } + for (const UsageMaskMapping& mapping : kUsage1ProducerMapping) { + if (containsBits(usage1, mapping.hardwareBufferMask)) { + *outProducerUsage |= mapping.grallocMask; + } + } + for (const UsageMaskMapping& mapping : kUsage0ConsumerMapping) { + if (containsBits(usage0, mapping.hardwareBufferMask)) { + *outConsumerUsage |= mapping.grallocMask; + } + } + for (const UsageMaskMapping& mapping : kUsage1ConsumerMapping) { + if (containsBits(usage1, mapping.hardwareBufferMask)) { + *outConsumerUsage |= mapping.grallocMask; + } + } } -uint64_t AHardwareBuffer_convertFromGrallocUsageBits(uint64_t producerUsage, uint64_t consumerUsage) { - uint64_t bits = 0; - if (containsBits(consumerUsage, GRALLOC1_CONSUMER_USAGE_CPU_READ)) - bits |= AHARDWAREBUFFER_USAGE0_CPU_READ; - if (containsBits(consumerUsage, GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN)) - bits |= AHARDWAREBUFFER_USAGE0_CPU_READ_OFTEN; - if (containsBits(producerUsage, GRALLOC1_PRODUCER_USAGE_CPU_WRITE)) - bits |= AHARDWAREBUFFER_USAGE0_CPU_WRITE; - if (containsBits(producerUsage, GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN)) - bits |= AHARDWAREBUFFER_USAGE0_CPU_WRITE_OFTEN; - if (containsBits(consumerUsage, GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE)) - bits |= AHARDWAREBUFFER_USAGE0_GPU_SAMPLED_IMAGE; - if (containsBits(producerUsage, GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET)) - bits |= AHARDWAREBUFFER_USAGE0_GPU_COLOR_OUTPUT; - if (containsBits(consumerUsage, GRALLOC1_CONSUMER_USAGE_GPU_DATA_BUFFER)) - bits |= AHARDWAREBUFFER_USAGE0_GPU_DATA_BUFFER; - if (containsBits(consumerUsage, GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER)) - bits |= AHARDWAREBUFFER_USAGE0_VIDEO_ENCODE; - if (containsBits(producerUsage, GRALLOC1_PRODUCER_USAGE_PROTECTED)) - bits |= AHARDWAREBUFFER_USAGE0_PROTECTED_CONTENT; - if (containsBits(producerUsage, GRALLOC1_PRODUCER_USAGE_SENSOR_DIRECT_DATA)) - bits |= AHARDWAREBUFFER_USAGE0_SENSOR_DIRECT_DATA; - - return bits; +void AHardwareBuffer_convertFromGrallocUsageBits(uint64_t* outUsage0, uint64_t* outUsage1, + uint64_t producerUsage, uint64_t consumerUsage) { + *outUsage0 = 0; + *outUsage1 = 0; + for (const UsageMaskMapping& mapping : kUsage0ProducerMapping) { + if (containsBits(producerUsage, mapping.grallocMask)) { + *outUsage0 |= mapping.hardwareBufferMask; + } + } + for (const UsageMaskMapping& mapping : kUsage1ProducerMapping) { + if (containsBits(producerUsage, mapping.grallocMask)) { + *outUsage1 |= mapping.hardwareBufferMask; + } + } + for (const UsageMaskMapping& mapping : kUsage0ConsumerMapping) { + if (containsBits(consumerUsage, mapping.grallocMask)) { + *outUsage0 |= mapping.hardwareBufferMask; + } + } + for (const UsageMaskMapping& mapping : kUsage1ConsumerMapping) { + if (containsBits(consumerUsage, mapping.grallocMask)) { + *outUsage1 |= mapping.hardwareBufferMask; + } + } } const GraphicBuffer* AHardwareBuffer_to_GraphicBuffer(const AHardwareBuffer* buffer) { diff --git a/libs/nativewindow/Android.bp b/libs/nativewindow/Android.bp index 4d1d8ac3fb..d0e4161d04 100644 --- a/libs/nativewindow/Android.bp +++ b/libs/nativewindow/Android.bp @@ -13,7 +13,7 @@ // limitations under the License. ndk_headers { - name: "libnativewdinwow_headers", + name: "libnativewindow_headers", from: "include/android", to: "android", srcs: ["include/android/*.h"], @@ -48,3 +48,5 @@ cc_library { "libarect", ], } + +subdirs = ["tests"] diff --git a/libs/nativewindow/include/android/hardware_buffer.h b/libs/nativewindow/include/android/hardware_buffer.h index 9c08c7b0b0..ef49995b74 100644 --- a/libs/nativewindow/include/android/hardware_buffer.h +++ b/libs/nativewindow/include/android/hardware_buffer.h @@ -97,10 +97,6 @@ enum { AHARDWAREBUFFER_USAGE0_GPU_SAMPLED_IMAGE = 1ULL << 10, /* The buffer will be written to by the GPU */ AHARDWAREBUFFER_USAGE0_GPU_COLOR_OUTPUT = 1ULL << 11, - /* The buffer will be read from and written to by the GPU */ - AHARDWAREBUFFER_USAGE0_GPU_STORAGE_IMAGE = - AHARDWAREBUFFER_USAGE0_GPU_SAMPLED_IMAGE | - AHARDWAREBUFFER_USAGE0_GPU_COLOR_OUTPUT, /* The buffer will be used as a cubemap texture */ AHARDWAREBUFFER_USAGE0_GPU_CUBEMAP = 1ULL << 13, /* The buffer will be used as a shader storage or uniform buffer object*/ @@ -113,13 +109,57 @@ enum { AHARDWAREBUFFER_USAGE0_VIDEO_ENCODE = 1ULL << 21, }; +/* These flags are intended only for use by device-specific graphics drivers. */ +enum { + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_19 = 1ULL << 24, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_19 = 1ULL << 25, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_18 = 1ULL << 26, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_18 = 1ULL << 27, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_17 = 1ULL << 28, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_17 = 1ULL << 29, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_16 = 1ULL << 30, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_16 = 1ULL << 31, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_15 = 1ULL << 32, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_15 = 1ULL << 33, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_14 = 1ULL << 34, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_14 = 1ULL << 35, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_13 = 1ULL << 36, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_13 = 1ULL << 37, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_12 = 1ULL << 38, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_12 = 1ULL << 39, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_11 = 1ULL << 40, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_11 = 1ULL << 41, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_10 = 1ULL << 42, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_10 = 1ULL << 43, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_9 = 1ULL << 44, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_9 = 1ULL << 45, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_8 = 1ULL << 46, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_8 = 1ULL << 47, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_7 = 1ULL << 48, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_7 = 1ULL << 49, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_6 = 1ULL << 50, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_6 = 1ULL << 51, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_5 = 1ULL << 52, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_5 = 1ULL << 53, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_4 = 1ULL << 54, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_4 = 1ULL << 55, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_3 = 1ULL << 56, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_3 = 1ULL << 57, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_2 = 1ULL << 58, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_2 = 1ULL << 59, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_1 = 1ULL << 60, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_1 = 1ULL << 61, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_0 = 1ULL << 62, + AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_0 = 1ULL << 63, +}; + typedef struct AHardwareBuffer_Desc { uint32_t width; uint32_t height; uint32_t layers; + uint32_t format; // One of AHARDWAREBUFFER_FORMAT_* uint64_t usage0; // Combination of AHARDWAREBUFFER_USAGE0_* uint64_t usage1; // Initialize to zero, reserved for future use - uint32_t format; // One of AHARDWAREBUFFER_FORMAT_* } AHardwareBuffer_Desc; typedef struct AHardwareBuffer AHardwareBuffer; diff --git a/libs/nativewindow/include/private/android/AHardwareBufferHelpers.h b/libs/nativewindow/include/private/android/AHardwareBufferHelpers.h index f138fa7787..612ee80f73 100644 --- a/libs/nativewindow/include/private/android/AHardwareBufferHelpers.h +++ b/libs/nativewindow/include/private/android/AHardwareBufferHelpers.h @@ -18,11 +18,11 @@ #define ANDROID_PRIVATE_NATIVE_AHARDWARE_BUFFER_HELPERS_H /* - * This file contains utility functions related to AHardwareBuffer, mostly to convert - * to/from HAL formats. + * This file contains utility functions related to AHardwareBuffer, mostly to + * convert to/from HAL formats. * - * These are PRIVATE methods, so this file can NEVER appear in a public NDK header. - * They are used by higher level libraries such as core/jni. + * These are PRIVATE methods, so this file can NEVER appear in a public NDK + * header. They are used by higher level libraries such as core/jni. */ #include <stdint.h> @@ -35,12 +35,11 @@ uint32_t AHardwareBuffer_convertFromPixelFormat(uint32_t format); uint32_t AHardwareBuffer_convertToPixelFormat(uint32_t format); -void AHardwareBuffer_convertToGrallocUsageBits(uint64_t usage, - uint64_t* outProducerUsage, uint64_t* outConsumerUsage); - -uint64_t AHardwareBuffer_convertFromGrallocUsageBits( - uint64_t producerUsage, uint64_t consumerUsage); +void AHardwareBuffer_convertToGrallocUsageBits(uint64_t* outProducerUsage, + uint64_t* outConsumerUsage, uint64_t usage0, uint64_t usage1); +void AHardwareBuffer_convertFromGrallocUsageBits(uint64_t* outUsage0, uint64_t* outUsage1, + uint64_t producerUsage, uint64_t consumerUsage); class GraphicBuffer; const GraphicBuffer* AHardwareBuffer_to_GraphicBuffer(const AHardwareBuffer* buffer); diff --git a/libs/nativewindow/tests/AHardwareBufferTest.cpp b/libs/nativewindow/tests/AHardwareBufferTest.cpp new file mode 100644 index 0000000000..10990432c6 --- /dev/null +++ b/libs/nativewindow/tests/AHardwareBufferTest.cpp @@ -0,0 +1,186 @@ +/* + * 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. + */ + +#define LOG_TAG "AHardwareBuffer_test" +//#define LOG_NDEBUG 0 + +#include <android/hardware_buffer.h> +#include <private/android/AHardwareBufferHelpers.h> +#include <hardware/gralloc1.h> + +#include <gtest/gtest.h> + +using namespace android; + +static ::testing::AssertionResult BuildHexFailureMessage(uint64_t expected, + uint64_t actual, const char* type) { + std::ostringstream ss; + ss << type << " 0x" << std::hex << actual + << " does not match expected " << type << " 0x" << std::hex + << expected; + return ::testing::AssertionFailure() << ss.str(); +} + +static ::testing::AssertionResult TestUsageConversion( + uint64_t grallocProducerUsage, uint64_t grallocConsumerUsage, + uint64_t hardwareBufferUsage0, uint64_t hardwareBufferUsage1) { + uint64_t producerUsage = 0; + uint64_t consumerUsage = 0; + uint64_t usage0 = 0; + uint64_t usage1 = 0; + + AHardwareBuffer_convertToGrallocUsageBits( + &producerUsage, &consumerUsage, hardwareBufferUsage0, hardwareBufferUsage1); + if (producerUsage != grallocProducerUsage) + return BuildHexFailureMessage(grallocProducerUsage, producerUsage, + "producer"); + if (consumerUsage != grallocConsumerUsage) + return BuildHexFailureMessage(grallocConsumerUsage, consumerUsage, + "consumer"); + + AHardwareBuffer_convertFromGrallocUsageBits( + &usage0, &usage1, grallocProducerUsage, grallocConsumerUsage); + if (usage0 != hardwareBufferUsage0) + return BuildHexFailureMessage(hardwareBufferUsage0, usage0, "usage0"); + if (usage1 != hardwareBufferUsage1) + return BuildHexFailureMessage(hardwareBufferUsage1, usage1, "usage1"); + + return testing::AssertionSuccess(); +} + +// This is a unit test rather than going through AHardwareBuffer because not +// all flags may be supported by the host device. +TEST(AHardwareBufferTest, ConvertToAndFromGrallocBits) { + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_CPU_READ, + AHARDWAREBUFFER_USAGE0_CPU_READ, 0)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN, + AHARDWAREBUFFER_USAGE0_CPU_READ_OFTEN, 0)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_CPU_WRITE, 0, + AHARDWAREBUFFER_USAGE0_CPU_WRITE, 0)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN, 0, + AHARDWAREBUFFER_USAGE0_CPU_WRITE_OFTEN, 0)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE, + AHARDWAREBUFFER_USAGE0_GPU_SAMPLED_IMAGE, 0)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET, + 0, AHARDWAREBUFFER_USAGE0_GPU_COLOR_OUTPUT, 0)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_GPU_DATA_BUFFER, + AHARDWAREBUFFER_USAGE0_GPU_DATA_BUFFER, 0)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PROTECTED, 0, + AHARDWAREBUFFER_USAGE0_PROTECTED_CONTENT, 0)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_SENSOR_DIRECT_DATA, + 0, AHARDWAREBUFFER_USAGE0_SENSOR_DIRECT_DATA, 0)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER, + AHARDWAREBUFFER_USAGE0_VIDEO_ENCODE, 0)); + + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_0, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_0)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_1, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_1)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_2, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_2)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_3, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_3)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_4, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_4)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_5, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_5)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_6, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_6)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_7, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_7)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_8, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_8)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_9, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_9)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_10, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_10)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_11, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_11)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_12, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_12)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_13, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_13)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_14, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_14)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_15, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_15)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_16, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_16)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_17, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_17)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_18, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_18)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_PRIVATE_19, 0, + 0, AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_19)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_0, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_0)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_1, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_1)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_2, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_2)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_3, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_3)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_4, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_4)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_5, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_5)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_6, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_6)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_7, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_7)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_8, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_8)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_9, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_9)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_10, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_10)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_11, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_11)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_12, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_12)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_13, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_13)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_14, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_14)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_15, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_15)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_16, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_16)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_17, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_17)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_18, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_18)); + EXPECT_TRUE(TestUsageConversion(0, GRALLOC1_CONSUMER_USAGE_PRIVATE_19, + 0, AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_19)); + + // Test some more complex flag combinations. + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_CPU_WRITE, + GRALLOC1_CONSUMER_USAGE_CPU_READ, + AHARDWAREBUFFER_USAGE0_CPU_READ | AHARDWAREBUFFER_USAGE0_CPU_WRITE, + 0)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN, 0, + AHARDWAREBUFFER_USAGE0_CPU_WRITE_OFTEN, 0)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET, + GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE | + GRALLOC1_CONSUMER_USAGE_PRIVATE_17, + AHARDWAREBUFFER_USAGE0_GPU_COLOR_OUTPUT | + AHARDWAREBUFFER_USAGE0_GPU_SAMPLED_IMAGE, + AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_17)); + EXPECT_TRUE(TestUsageConversion(GRALLOC1_PRODUCER_USAGE_SENSOR_DIRECT_DATA, + GRALLOC1_CONSUMER_USAGE_GPU_DATA_BUFFER, + AHARDWAREBUFFER_USAGE0_GPU_DATA_BUFFER | + AHARDWAREBUFFER_USAGE0_SENSOR_DIRECT_DATA, 0)); +} diff --git a/libs/nativewindow/tests/Android.bp b/libs/nativewindow/tests/Android.bp new file mode 100644 index 0000000000..437ab7546c --- /dev/null +++ b/libs/nativewindow/tests/Android.bp @@ -0,0 +1,21 @@ +// +// 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. +// + +cc_test { + name: "AHardwareBufferTest", + shared_libs: ["libnativewindow"], + srcs: ["AHardwareBufferTest.cpp"], +} diff --git a/libs/ui/GraphicBuffer.cpp b/libs/ui/GraphicBuffer.cpp index 37ebfb3cd4..c4d8f76ec7 100644 --- a/libs/ui/GraphicBuffer.cpp +++ b/libs/ui/GraphicBuffer.cpp @@ -17,6 +17,9 @@ #define LOG_TAG "GraphicBuffer" #include <ui/GraphicBuffer.h> + +#include <cutils/atomic.h> + #include <ui/GrallocMapper.h> #include <ui/GraphicBufferAllocator.h> #include <ui/GraphicBufferMapper.h> diff --git a/libs/ui/tests/Android.bp b/libs/ui/tests/Android.bp index 6733505090..b55c2121d8 100644 --- a/libs/ui/tests/Android.bp +++ b/libs/ui/tests/Android.bp @@ -25,3 +25,9 @@ cc_test { shared_libs: ["libui"], srcs: ["colorspace_test.cpp"], } + +cc_test { + name: "Gralloc1Mapper_test", + shared_libs: ["libui", "libutils"], + srcs: ["Gralloc1Mapper_test.cpp"], +} diff --git a/libs/ui/tests/Gralloc1Mapper_test.cpp b/libs/ui/tests/Gralloc1Mapper_test.cpp new file mode 100644 index 0000000000..b7c9f0f91d --- /dev/null +++ b/libs/ui/tests/Gralloc1Mapper_test.cpp @@ -0,0 +1,105 @@ +/* + * 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. + */ + +#define LOG_TAG "Gralloc1Mapper_test" +//#define LOG_NDEBUG 0 + +#include <errno.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/un.h> + +#include <ui/GraphicBuffer.h> +#include <ui/GraphicBufferMapper.h> +#include <utils/Errors.h> + +#include <gtest/gtest.h> + +using namespace android; + +class Gralloc1MapperTest : public ::testing::Test +{ +public: + ~Gralloc1MapperTest() override = default; + +protected: + void SetUp() override { + buffer = new GraphicBuffer(4, 8, HAL_PIXEL_FORMAT_RGBA_8888, 1, + GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN, + GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN, "Gralloc1MapperTest"); + ASSERT_NE(nullptr, buffer.get()); + + handle = static_cast<buffer_handle_t>(buffer->handle); + + mapper = &GraphicBufferMapper::get(); + } + + sp<GraphicBuffer> buffer; + buffer_handle_t handle; + GraphicBufferMapper* mapper; +}; + +TEST_F(Gralloc1MapperTest, Gralloc1MapperTest_getDimensions) { + uint32_t width = 0; + uint32_t height = 0; + status_t err = mapper->getDimensions(handle, &width, &height); + ASSERT_EQ(GRALLOC1_ERROR_NONE, err); + EXPECT_EQ(4U, width); + EXPECT_EQ(8U, height); +} + +TEST_F(Gralloc1MapperTest, Gralloc1MapperTest_getFormat) { + int32_t value = 0; + status_t err = mapper->getFormat(handle, &value); + ASSERT_EQ(GRALLOC1_ERROR_NONE, err); + EXPECT_EQ(HAL_PIXEL_FORMAT_RGBA_8888, value); +} + +TEST_F(Gralloc1MapperTest, Gralloc1MapperTest_getLayerCount) { + uint32_t value = 0; + status_t err = mapper->getLayerCount(handle, &value); + if (err != GRALLOC1_ERROR_UNSUPPORTED) { + EXPECT_EQ(1U, value); + } +} + +TEST_F(Gralloc1MapperTest, Gralloc1MapperTest_getProducerUsage) { + uint64_t value = 0; + status_t err = mapper->getProducerUsage(handle, &value); + ASSERT_EQ(GRALLOC1_ERROR_NONE, err); + EXPECT_EQ(GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN, value); +} + +TEST_F(Gralloc1MapperTest, Gralloc1MapperTest_getConsumerUsage) { + uint64_t value = 0; + status_t err = mapper->getConsumerUsage(handle, &value); + ASSERT_EQ(GRALLOC1_ERROR_NONE, err); + EXPECT_EQ(GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN, value); +} + +TEST_F(Gralloc1MapperTest, Gralloc1MapperTest_getBackingStore) { + uint64_t value = 0; + status_t err = mapper->getBackingStore(handle, &value); + ASSERT_EQ(GRALLOC1_ERROR_NONE, err); +} + +TEST_F(Gralloc1MapperTest, Gralloc1MapperTest_getStride) { + uint32_t value = 0; + status_t err = mapper->getStride(handle, &value); + ASSERT_EQ(GRALLOC1_ERROR_NONE, err); + // The stride should be at least the width of the buffer. + EXPECT_LE(4U, value); +} diff --git a/libs/vr/libeds/Android.mk b/libs/vr/libeds/Android.mk index fd2c56e4ad..d2e65261b0 100644 --- a/libs/vr/libeds/Android.mk +++ b/libs/vr/libeds/Android.mk @@ -37,7 +37,6 @@ sharedLibraries := \ libGLESv1_CM \ libGLESv2 \ libvulkan \ - libandroid staticLibraries := \ libdisplay \ diff --git a/opengl/libs/EGL/Loader.cpp b/opengl/libs/EGL/Loader.cpp index b1ca13d148..9aedc61416 100644 --- a/opengl/libs/EGL/Loader.cpp +++ b/opengl/libs/EGL/Loader.cpp @@ -17,26 +17,21 @@ //#define LOG_NDEBUG 0 #define ATRACE_TAG ATRACE_TAG_GRAPHICS -#include <array> -#include <ctype.h> +#include "Loader.h" + #include <dirent.h> #include <dlfcn.h> -#include <errno.h> -#include <limits.h> -#include <stdio.h> -#include <stdlib.h> -#include <string.h> #include <android/dlext.h> #include <cutils/properties.h> #include <log/log.h> + +#include <utils/String8.h> #include <utils/Trace.h> -#include <ui/GraphicsEnv.h> -#include <EGL/egl.h> +#include <ui/GraphicsEnv.h> #include "egldefs.h" -#include "Loader.h" // ---------------------------------------------------------------------------- namespace android { @@ -437,10 +432,10 @@ static void* do_android_dlopen_ext(const char* path, int mode, const android_dle return android_dlopen_ext(path, mode, info); } -static const std::array<const char*, 2> HAL_SUBNAME_KEY_PROPERTIES = {{ +static const char* HAL_SUBNAME_KEY_PROPERTIES[2] = { "ro.hardware.egl", "ro.board.platform", -}}; +}; static void* load_updated_driver(const char* kind, android_namespace_t* ns) { ATRACE_CALL(); @@ -454,10 +449,10 @@ static void* load_updated_driver(const char* kind, android_namespace_t* ns) { if (property_get(key, prop, nullptr) > 0) { String8 name; name.appendFormat("lib%s_%s.so", kind, prop); - so = do_android_dlopen_ext(name.string(), RTLD_LOCAL | RTLD_NOW, - &dlextinfo); - if (so) + so = do_android_dlopen_ext(name.string(), RTLD_LOCAL | RTLD_NOW, &dlextinfo); + if (so) { return so; + } } } return nullptr; diff --git a/opengl/libs/EGL/Loader.h b/opengl/libs/EGL/Loader.h index b0743a57eb..2dd420677d 100644 --- a/opengl/libs/EGL/Loader.h +++ b/opengl/libs/EGL/Loader.h @@ -17,13 +17,10 @@ #ifndef ANDROID_EGL_LOADER_H #define ANDROID_EGL_LOADER_H -#include <ctype.h> -#include <string.h> -#include <errno.h> +#include <stdint.h> #include <utils/Errors.h> #include <utils/Singleton.h> -#include <utils/String8.h> #include <EGL/egl.h> @@ -33,12 +30,10 @@ namespace android { struct egl_connection_t; -class Loader : public Singleton<Loader> -{ +class Loader : public Singleton<Loader> { friend class Singleton<Loader>; - typedef __eglMustCastToProperFunctionPointerType (*getProcAddressType)( - const char*); + typedef __eglMustCastToProperFunctionPointerType (* getProcAddressType)(const char*); enum { EGL = 0x01, diff --git a/opengl/libs/EGL/egl.cpp b/opengl/libs/EGL/egl.cpp index ee83ada26d..34b0ba2516 100644 --- a/opengl/libs/EGL/egl.cpp +++ b/opengl/libs/EGL/egl.cpp @@ -14,30 +14,26 @@ ** limitations under the License. */ -#include <ctype.h> #include <stdlib.h> -#include <string.h> #include <hardware/gralloc.h> -#include <system/window.h> #include <EGL/egl.h> -#include <EGL/eglext.h> #include <cutils/atomic.h> #include <cutils/properties.h> + #include <log/log.h> + #include <utils/CallStack.h> -#include <utils/String8.h> #include "../egl_impl.h" -#include "egl_tls.h" #include "egldefs.h" -#include "Loader.h" - +#include "egl_tls.h" #include "egl_display.h" #include "egl_object.h" +#include "Loader.h" typedef __eglMustCastToProperFunctionPointerType EGLFuncPointer; diff --git a/opengl/libs/EGL/eglApi.cpp b/opengl/libs/EGL/eglApi.cpp index d0943a9062..3359c6408c 100644 --- a/opengl/libs/EGL/eglApi.cpp +++ b/opengl/libs/EGL/eglApi.cpp @@ -22,7 +22,6 @@ #include <string.h> #include <hardware/gralloc1.h> -#include <system/window.h> #include <EGL/egl.h> #include <EGL/eglext.h> @@ -30,9 +29,7 @@ #include <android/hardware_buffer.h> #include <private/android/AHardwareBufferHelpers.h> -#include <cutils/atomic.h> #include <cutils/compiler.h> -#include <cutils/memory.h> #include <cutils/properties.h> #include <log/log.h> @@ -42,21 +39,19 @@ #include <utils/KeyedVector.h> -#include <utils/SortedVector.h> #include <utils/String8.h> #include <utils/Trace.h> +#include <utils/Thread.h> #include "binder/Binder.h" #include "binder/Parcel.h" #include "binder/IServiceManager.h" #include "../egl_impl.h" -#include "../hooks.h" #include "egl_display.h" #include "egl_object.h" #include "egl_tls.h" -#include "egldefs.h" using namespace android; @@ -84,7 +79,11 @@ struct extention_map_t { * * NOTE: Both strings MUST have a single space as the last character. */ -extern char const * const gBuiltinExtensionString = + +extern char const * const gBuiltinExtensionString; +extern char const * const gExtensionString; + +char const * const gBuiltinExtensionString = "EGL_KHR_get_all_proc_addresses " "EGL_ANDROID_presentation_time " "EGL_KHR_swap_buffers_with_damage " @@ -93,7 +92,8 @@ extern char const * const gBuiltinExtensionString = "EGL_ANDROID_front_buffer_auto_refresh " "EGL_ANDROID_get_frame_timestamps " ; -extern char const * const gExtensionString = + +char const * const gExtensionString = "EGL_KHR_image " // mandatory "EGL_KHR_image_base " // mandatory "EGL_KHR_image_pixmap " @@ -304,7 +304,7 @@ EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor) clearError(); egl_display_ptr dp = get_display(dpy); - if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE); + if (!dp) return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); EGLBoolean res = dp->initialize(major, minor); @@ -320,7 +320,7 @@ EGLBoolean eglTerminate(EGLDisplay dpy) clearError(); egl_display_ptr dp = get_display(dpy); - if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE); + if (!dp) return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); EGLBoolean res = dp->terminate(); @@ -341,7 +341,7 @@ EGLBoolean eglGetConfigs( EGLDisplay dpy, if (!dp) return EGL_FALSE; if (num_config==0) { - return setError(EGL_BAD_PARAMETER, EGL_FALSE); + return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE); } EGLBoolean res = EGL_FALSE; @@ -366,7 +366,7 @@ EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list, if (!dp) return EGL_FALSE; if (num_config==0) { - return setError(EGL_BAD_PARAMETER, EGL_FALSE); + return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE); } EGLBoolean res = EGL_FALSE; @@ -398,6 +398,8 @@ EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list, case EGL_CONFIG_CAVEAT: attribCaveat = &attrib_list[attribCount]; break; + default: + break; } attribCount++; } @@ -493,14 +495,8 @@ EGLSurface eglCreateWindowSurface( EGLDisplay dpy, EGLConfig config, cnx->egl.eglGetConfigAttrib(iDpy, config, EGL_COLOR_COMPONENT_TYPE_EXT, &componentType); - // by default, just pick appropriate RGBA - EGLint format = HAL_PIXEL_FORMAT_RGBA_8888; - if (dp->haveExtension("EGL_EXT_pixel_format_float") && - (componentType == EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT)) { - format = HAL_PIXEL_FORMAT_RGBA_FP16; - } + EGLint format; android_dataspace dataSpace = HAL_DATASPACE_UNKNOWN; - EGLint a = 0; EGLint r, g, b; r = g = b = 0; @@ -633,7 +629,7 @@ EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface) SurfaceRef _s(dp.get(), surface); if (!_s.get()) - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); egl_surface_t * const s = get_surface(surface); EGLBoolean result = s->cnx->egl.eglDestroySurface(dp->disp.dpy, s->surface); @@ -653,7 +649,7 @@ EGLBoolean eglQuerySurface( EGLDisplay dpy, EGLSurface surface, SurfaceRef _s(dp.get(), surface); if (!_s.get()) - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); egl_surface_t const * const s = get_surface(surface); return s->cnx->egl.eglQuerySurface( @@ -672,7 +668,6 @@ void EGLAPI eglBeginFrame(EGLDisplay dpy, EGLSurface surface) { SurfaceRef _s(dp.get(), surface); if (!_s.get()) { setError(EGL_BAD_SURFACE, EGL_FALSE); - return; } } @@ -731,7 +726,7 @@ EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx) ContextRef _c(dp.get(), ctx); if (!_c.get()) - return setError(EGL_BAD_CONTEXT, EGL_FALSE); + return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); egl_context_t * const c = get_context(ctx); EGLBoolean result = c->cnx->egl.eglDestroyContext(dp->disp.dpy, c->context); @@ -747,14 +742,14 @@ EGLBoolean eglMakeCurrent( EGLDisplay dpy, EGLSurface draw, clearError(); egl_display_ptr dp = validate_display(dpy); - if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE); + if (!dp) return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); // If ctx is not EGL_NO_CONTEXT, read is not EGL_NO_SURFACE, or draw is not // EGL_NO_SURFACE, then an EGL_NOT_INITIALIZED error is generated if dpy is // a valid but uninitialized display. if ( (ctx != EGL_NO_CONTEXT) || (read != EGL_NO_SURFACE) || (draw != EGL_NO_SURFACE) ) { - if (!dp->isReady()) return setError(EGL_NOT_INITIALIZED, EGL_FALSE); + if (!dp->isReady()) return setError(EGL_NOT_INITIALIZED, (EGLBoolean)EGL_FALSE); } // get a reference to the object passed in @@ -765,7 +760,7 @@ EGLBoolean eglMakeCurrent( EGLDisplay dpy, EGLSurface draw, // validate the context (if not EGL_NO_CONTEXT) if ((ctx != EGL_NO_CONTEXT) && !_c.get()) { // EGL_NO_CONTEXT is valid - return setError(EGL_BAD_CONTEXT, EGL_FALSE); + return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); } // these are the underlying implementation's object @@ -788,7 +783,7 @@ EGLBoolean eglMakeCurrent( EGLDisplay dpy, EGLSurface draw, // no context given, use the implementation of the current context if (draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE) { // calling eglMakeCurrent( ..., !=0, !=0, EGL_NO_CONTEXT); - return setError(EGL_BAD_MATCH, EGL_FALSE); + return setError(EGL_BAD_MATCH, (EGLBoolean)EGL_FALSE); } if (cur_c == NULL) { // no current context @@ -799,14 +794,14 @@ EGLBoolean eglMakeCurrent( EGLDisplay dpy, EGLSurface draw, // retrieve the underlying implementation's draw EGLSurface if (draw != EGL_NO_SURFACE) { - if (!_d.get()) return setError(EGL_BAD_SURFACE, EGL_FALSE); + if (!_d.get()) return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); d = get_surface(draw); impl_draw = d->surface; } // retrieve the underlying implementation's read EGLSurface if (read != EGL_NO_SURFACE) { - if (!_r.get()) return setError(EGL_BAD_SURFACE, EGL_FALSE); + if (!_r.get()) return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); r = get_surface(read); impl_read = r->surface; } @@ -830,7 +825,7 @@ EGLBoolean eglMakeCurrent( EGLDisplay dpy, EGLSurface draw, } else { // this will ALOGE the error egl_connection_t* const cnx = &gEGLImpl; - result = setError(cnx->egl.eglGetError(), EGL_FALSE); + result = setError(cnx->egl.eglGetError(), (EGLBoolean)EGL_FALSE); } return result; } @@ -845,7 +840,7 @@ EGLBoolean eglQueryContext( EGLDisplay dpy, EGLContext ctx, if (!dp) return EGL_FALSE; ContextRef _c(dp.get(), ctx); - if (!_c.get()) return setError(EGL_BAD_CONTEXT, EGL_FALSE); + if (!_c.get()) return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); egl_context_t * const c = get_context(ctx); return c->cnx->egl.eglQueryContext( @@ -906,7 +901,7 @@ EGLBoolean eglWaitGL(void) egl_connection_t* const cnx = &gEGLImpl; if (!cnx->dso) - return setError(EGL_BAD_CONTEXT, EGL_FALSE); + return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); return cnx->egl.eglWaitGL(); } @@ -917,7 +912,7 @@ EGLBoolean eglWaitNative(EGLint engine) egl_connection_t* const cnx = &gEGLImpl; if (!cnx->dso) - return setError(EGL_BAD_CONTEXT, EGL_FALSE); + return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); return cnx->egl.eglWaitNative(engine); } @@ -1045,7 +1040,7 @@ public: thread->mQueue.push_back(sync); thread->mCondition.signal(); thread->mFramesQueued++; - ATRACE_INT("GPU Frames Outstanding", thread->mQueue.size()); + ATRACE_INT("GPU Frames Outstanding", int32_t(thread->mQueue.size())); } } @@ -1079,7 +1074,7 @@ private: Mutex::Autolock lock(mMutex); mQueue.removeAt(0); mFramesCompleted++; - ATRACE_INT("GPU Frames Outstanding", mQueue.size()); + ATRACE_INT("GPU Frames Outstanding", int32_t(mQueue.size())); } return true; } @@ -1102,7 +1097,7 @@ EGLBoolean eglSwapBuffersWithDamageKHR(EGLDisplay dpy, EGLSurface draw, SurfaceRef _s(dp.get(), draw); if (!_s.get()) - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); egl_surface_t const * const s = get_surface(draw); @@ -1167,7 +1162,7 @@ EGLBoolean eglCopyBuffers( EGLDisplay dpy, EGLSurface surface, SurfaceRef _s(dp.get(), surface); if (!_s.get()) - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); egl_surface_t const * const s = get_surface(surface); return s->cnx->egl.eglCopyBuffers(dp->disp.dpy, s->surface, target); @@ -1185,7 +1180,7 @@ const char* eglQueryString(EGLDisplay dpy, EGLint name) // If we want to support EGL_EXT_client_extensions later, we can return // the client extension string here instead. if (dpy == EGL_NO_DISPLAY && name == EGL_EXTENSIONS) - return setErrorQuiet(EGL_BAD_DISPLAY, nullptr); + return setErrorQuiet(EGL_BAD_DISPLAY, (const char*)0); const egl_display_ptr dp = validate_display(dpy); if (!dp) return (const char *) NULL; @@ -1199,6 +1194,8 @@ const char* eglQueryString(EGLDisplay dpy, EGLint name) return dp->getExtensionString(); case EGL_CLIENT_APIS: return dp->getClientApiString(); + default: + break; } return setError(EGL_BAD_PARAMETER, (const char *)0); } @@ -1219,6 +1216,8 @@ EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint na return dp->disp.queryString.extensions; case EGL_CLIENT_APIS: return dp->disp.queryString.clientApi; + default: + break; } return setError(EGL_BAD_PARAMETER, (const char *)0); } @@ -1237,7 +1236,7 @@ EGLBoolean eglSurfaceAttrib( SurfaceRef _s(dp.get(), surface); if (!_s.get()) - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); egl_surface_t * const s = get_surface(surface); @@ -1245,27 +1244,23 @@ EGLBoolean eglSurfaceAttrib( if (!s->win.get()) { setError(EGL_BAD_SURFACE, EGL_FALSE); } - int err = native_window_set_auto_refresh(s->win.get(), - value ? true : false); - return (err == NO_ERROR) ? EGL_TRUE : - setError(EGL_BAD_SURFACE, EGL_FALSE); + int err = native_window_set_auto_refresh(s->win.get(), value ? true : false); + return (err == NO_ERROR) ? EGL_TRUE : setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } if (attribute == EGL_TIMESTAMPS_ANDROID) { if (!s->win.get()) { - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } - int err = native_window_enable_frame_timestamps( - s->win.get(), value ? true : false); - return (err == NO_ERROR) ? EGL_TRUE : - setError(EGL_BAD_SURFACE, EGL_FALSE); + int err = native_window_enable_frame_timestamps(s->win.get(), value ? true : false); + return (err == NO_ERROR) ? EGL_TRUE : setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } if (s->cnx->egl.eglSurfaceAttrib) { return s->cnx->egl.eglSurfaceAttrib( dp->disp.dpy, s->surface, attribute, value); } - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } EGLBoolean eglBindTexImage( @@ -1278,14 +1273,14 @@ EGLBoolean eglBindTexImage( SurfaceRef _s(dp.get(), surface); if (!_s.get()) - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); egl_surface_t const * const s = get_surface(surface); if (s->cnx->egl.eglBindTexImage) { return s->cnx->egl.eglBindTexImage( dp->disp.dpy, s->surface, buffer); } - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } EGLBoolean eglReleaseTexImage( @@ -1298,14 +1293,14 @@ EGLBoolean eglReleaseTexImage( SurfaceRef _s(dp.get(), surface); if (!_s.get()) - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); egl_surface_t const * const s = get_surface(surface); if (s->cnx->egl.eglReleaseTexImage) { return s->cnx->egl.eglReleaseTexImage( dp->disp.dpy, s->surface, buffer); } - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval) @@ -1335,7 +1330,7 @@ EGLBoolean eglWaitClient(void) egl_connection_t* const cnx = &gEGLImpl; if (!cnx->dso) - return setError(EGL_BAD_CONTEXT, EGL_FALSE); + return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); EGLBoolean res; if (cnx->egl.eglWaitClient) { @@ -1351,7 +1346,7 @@ EGLBoolean eglBindAPI(EGLenum api) clearError(); if (egl_init_drivers() == EGL_FALSE) { - return setError(EGL_BAD_PARAMETER, EGL_FALSE); + return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE); } // bind this API on all EGLs @@ -1368,7 +1363,7 @@ EGLenum eglQueryAPI(void) clearError(); if (egl_init_drivers() == EGL_FALSE) { - return setError(EGL_BAD_PARAMETER, EGL_FALSE); + return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE); } egl_connection_t* const cnx = &gEGLImpl; @@ -1426,14 +1421,14 @@ EGLBoolean eglLockSurfaceKHR(EGLDisplay dpy, EGLSurface surface, SurfaceRef _s(dp.get(), surface); if (!_s.get()) - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); egl_surface_t const * const s = get_surface(surface); if (s->cnx->egl.eglLockSurfaceKHR) { return s->cnx->egl.eglLockSurfaceKHR( dp->disp.dpy, s->surface, attrib_list); } - return setError(EGL_BAD_DISPLAY, EGL_FALSE); + return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); } EGLBoolean eglUnlockSurfaceKHR(EGLDisplay dpy, EGLSurface surface) @@ -1445,13 +1440,13 @@ EGLBoolean eglUnlockSurfaceKHR(EGLDisplay dpy, EGLSurface surface) SurfaceRef _s(dp.get(), surface); if (!_s.get()) - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); egl_surface_t const * const s = get_surface(surface); if (s->cnx->egl.eglUnlockSurfaceKHR) { return s->cnx->egl.eglUnlockSurfaceKHR(dp->disp.dpy, s->surface); } - return setError(EGL_BAD_DISPLAY, EGL_FALSE); + return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); } EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, @@ -1549,7 +1544,7 @@ EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, const egl_display_ptr dp = validate_display(dpy); if (!dp) return EGL_FALSE; - EGLBoolean result = EGL_FALSE; + EGLint result = EGL_FALSE; egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso && cnx->egl.eglClientWaitSyncKHR) { result = cnx->egl.eglClientWaitSyncKHR( @@ -2006,7 +2001,7 @@ EGLuint64NV eglGetSystemTimeFrequencyNV() clearError(); if (egl_init_drivers() == EGL_FALSE) { - return setError(EGL_BAD_PARAMETER, EGL_FALSE); + return setError(EGL_BAD_PARAMETER, (EGLuint64NV)EGL_FALSE); } EGLuint64NV ret = 0; @@ -2016,7 +2011,7 @@ EGLuint64NV eglGetSystemTimeFrequencyNV() return cnx->egl.eglGetSystemTimeFrequencyNV(); } - return setErrorQuiet(EGL_BAD_DISPLAY, 0); + return setErrorQuiet(EGL_BAD_DISPLAY, (EGLuint64NV)0); } EGLuint64NV eglGetSystemTimeNV() @@ -2024,7 +2019,7 @@ EGLuint64NV eglGetSystemTimeNV() clearError(); if (egl_init_drivers() == EGL_FALSE) { - return setError(EGL_BAD_PARAMETER, EGL_FALSE); + return setError(EGL_BAD_PARAMETER, (EGLuint64NV)EGL_FALSE); } EGLuint64NV ret = 0; @@ -2034,7 +2029,7 @@ EGLuint64NV eglGetSystemTimeNV() return cnx->egl.eglGetSystemTimeNV(); } - return setErrorQuiet(EGL_BAD_DISPLAY, 0); + return setErrorQuiet(EGL_BAD_DISPLAY, (EGLuint64NV)0); } // ---------------------------------------------------------------------------- @@ -2072,18 +2067,18 @@ EGLBoolean eglGetNextFrameIdANDROID(EGLDisplay dpy, EGLSurface surface, const egl_display_ptr dp = validate_display(dpy); if (!dp) { - return setError(EGL_BAD_DISPLAY, EGL_FALSE); + return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); } SurfaceRef _s(dp.get(), surface); if (!_s.get()) { - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } egl_surface_t const * const s = get_surface(surface); if (!s->win.get()) { - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } uint64_t nextFrameId = 0; @@ -2093,7 +2088,7 @@ EGLBoolean eglGetNextFrameIdANDROID(EGLDisplay dpy, EGLSurface surface, // This should not happen. Return an error that is not in the spec // so it's obvious something is very wrong. ALOGE("eglGetNextFrameId: Unexpected error."); - return setError(EGL_NOT_INITIALIZED, EGL_FALSE); + return setError(EGL_NOT_INITIALIZED, (EGLBoolean)EGL_FALSE); } *frameId = nextFrameId; @@ -2107,18 +2102,18 @@ EGLBoolean eglGetCompositorTimingANDROID(EGLDisplay dpy, EGLSurface surface, const egl_display_ptr dp = validate_display(dpy); if (!dp) { - return setError(EGL_BAD_DISPLAY, EGL_FALSE); + return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); } SurfaceRef _s(dp.get(), surface); if (!_s.get()) { - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } egl_surface_t const * const s = get_surface(surface); if (!s->win.get()) { - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } nsecs_t* compositeDeadline = nullptr; @@ -2137,7 +2132,7 @@ EGLBoolean eglGetCompositorTimingANDROID(EGLDisplay dpy, EGLSurface surface, compositeToPresentLatency = &values[i]; break; default: - return setError(EGL_BAD_PARAMETER, EGL_FALSE); + return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE); } } @@ -2148,12 +2143,12 @@ EGLBoolean eglGetCompositorTimingANDROID(EGLDisplay dpy, EGLSurface surface, case NO_ERROR: return EGL_TRUE; case INVALID_OPERATION: - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); default: // This should not happen. Return an error that is not in the spec // so it's obvious something is very wrong. ALOGE("eglGetCompositorTiming: Unexpected error."); - return setError(EGL_NOT_INITIALIZED, EGL_FALSE); + return setError(EGL_NOT_INITIALIZED, (EGLBoolean)EGL_FALSE); } } @@ -2164,19 +2159,19 @@ EGLBoolean eglGetCompositorTimingSupportedANDROID( const egl_display_ptr dp = validate_display(dpy); if (!dp) { - return setError(EGL_BAD_DISPLAY, EGL_FALSE); + return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); } SurfaceRef _s(dp.get(), surface); if (!_s.get()) { - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } egl_surface_t const * const s = get_surface(surface); ANativeWindow* window = s->win.get(); if (!window) { - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } switch (name) { @@ -2197,18 +2192,18 @@ EGLBoolean eglGetFrameTimestampsANDROID(EGLDisplay dpy, EGLSurface surface, const egl_display_ptr dp = validate_display(dpy); if (!dp) { - return setError(EGL_BAD_DISPLAY, EGL_FALSE); + return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); } SurfaceRef _s(dp.get(), surface); if (!_s.get()) { - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } egl_surface_t const * const s = get_surface(surface); if (!s->win.get()) { - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } nsecs_t* requestedPresentTime = nullptr; @@ -2255,7 +2250,7 @@ EGLBoolean eglGetFrameTimestampsANDROID(EGLDisplay dpy, EGLSurface surface, releaseTime = &values[i]; break; default: - return setError(EGL_BAD_PARAMETER, EGL_FALSE); + return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE); } } @@ -2265,19 +2260,19 @@ EGLBoolean eglGetFrameTimestampsANDROID(EGLDisplay dpy, EGLSurface surface, displayRetireTime, dequeueReadyTime, releaseTime); switch (ret) { - case NO_ERROR: - return EGL_TRUE; - case NAME_NOT_FOUND: - return setError(EGL_BAD_ACCESS, EGL_FALSE); - case INVALID_OPERATION: - return setError(EGL_BAD_SURFACE, EGL_FALSE); - case BAD_VALUE: - return setError(EGL_BAD_PARAMETER, EGL_FALSE); - default: - // This should not happen. Return an error that is not in the spec - // so it's obvious something is very wrong. - ALOGE("eglGetFrameTimestamps: Unexpected error."); - return setError(EGL_NOT_INITIALIZED, EGL_FALSE); + case NO_ERROR: + return EGL_TRUE; + case NAME_NOT_FOUND: + return setError(EGL_BAD_ACCESS, (EGLBoolean)EGL_FALSE); + case INVALID_OPERATION: + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); + case BAD_VALUE: + return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE); + default: + // This should not happen. Return an error that is not in the spec + // so it's obvious something is very wrong. + ALOGE("eglGetFrameTimestamps: Unexpected error."); + return setError(EGL_NOT_INITIALIZED, (EGLBoolean)EGL_FALSE); } } @@ -2288,19 +2283,19 @@ EGLBoolean eglGetFrameTimestampSupportedANDROID( const egl_display_ptr dp = validate_display(dpy); if (!dp) { - return setError(EGL_BAD_DISPLAY, EGL_FALSE); + return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); } SurfaceRef _s(dp.get(), surface); if (!_s.get()) { - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } egl_surface_t const * const s = get_surface(surface); ANativeWindow* window = s->win.get(); if (!window) { - return setError(EGL_BAD_SURFACE, EGL_FALSE); + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } switch (timestamp) { @@ -2318,14 +2313,12 @@ EGLBoolean eglGetFrameTimestampSupportedANDROID( return EGL_TRUE; case EGL_DISPLAY_PRESENT_TIME_ANDROID: { int value = 0; - window->query(window, - NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &value); + window->query(window, NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &value); return value == 0 ? EGL_FALSE : EGL_TRUE; } case EGL_DISPLAY_RETIRE_TIME_ANDROID: { int value = 0; - window->query(window, - NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_RETIRE, &value); + window->query(window, NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_RETIRE, &value); return value == 0 ? EGL_FALSE : EGL_TRUE; } default: diff --git a/opengl/libs/EGL/egl_cache.cpp b/opengl/libs/EGL/egl_cache.cpp index 1fe322dc9f..e46716c9b7 100644 --- a/opengl/libs/EGL/egl_cache.cpp +++ b/opengl/libs/EGL/egl_cache.cpp @@ -14,18 +14,17 @@ ** limitations under the License. */ +#include "egl_cache.h" + #include "../egl_impl.h" -#include "egl_cache.h" #include "egl_display.h" -#include "egldefs.h" -#include <fcntl.h> #include <inttypes.h> #include <sys/mman.h> #include <sys/stat.h> -#include <sys/types.h> -#include <unistd.h> + +#include <utils/Thread.h> // Cache size limits. static const size_t maxKeySize = 12 * 1024; @@ -87,7 +86,7 @@ void egl_cache_t::initialize(egl_display_t *display) { bool atStart = !strncmp(BC_EXT_STR " ", exts, bcExtLen+1); bool atEnd = (bcExtLen+1) < extsLen && !strcmp(" " BC_EXT_STR, exts + extsLen - (bcExtLen+1)); - bool inMiddle = strstr(exts, " " BC_EXT_STR " "); + bool inMiddle = strstr(exts, " " BC_EXT_STR " ") != nullptr; if (equal || atStart || atEnd || inMiddle) { PFNEGLSETBLOBCACHEFUNCSANDROIDPROC eglSetBlobCacheFuncsANDROID; eglSetBlobCacheFuncsANDROID = diff --git a/opengl/libs/EGL/egl_cache.h b/opengl/libs/EGL/egl_cache.h index 876000951c..e7f17126f2 100644 --- a/opengl/libs/EGL/egl_cache.h +++ b/opengl/libs/EGL/egl_cache.h @@ -21,6 +21,7 @@ #include <EGL/eglext.h> #include <utils/BlobCache.h> +#include <utils/Mutex.h> #include <utils/String8.h> #include <utils/StrongPointer.h> diff --git a/opengl/libs/EGL/egl_display.cpp b/opengl/libs/EGL/egl_display.cpp index d7df40c086..c804fa7519 100644 --- a/opengl/libs/EGL/egl_display.cpp +++ b/opengl/libs/EGL/egl_display.cpp @@ -17,16 +17,16 @@ #define __STDC_LIMIT_MACROS 1 #define ATRACE_TAG ATRACE_TAG_GRAPHICS -#include <string.h> +#include "egl_display.h" #include "../egl_impl.h" #include "egl_cache.h" -#include "egl_display.h" #include "egl_object.h" #include "egl_tls.h" #include "Loader.h" #include <cutils/properties.h> + #include <utils/Trace.h> // ---------------------------------------------------------------------------- diff --git a/opengl/libs/EGL/egl_display.h b/opengl/libs/EGL/egl_display.h index e17558cbd0..f5e729494c 100644 --- a/opengl/libs/EGL/egl_display.h +++ b/opengl/libs/EGL/egl_display.h @@ -18,16 +18,16 @@ #define ANDROID_EGL_DISPLAY_H -#include <ctype.h> #include <stdint.h> -#include <stdlib.h> +#include <stddef.h> #include <EGL/egl.h> #include <EGL/eglext.h> #include <cutils/compiler.h> #include <utils/SortedVector.h> -#include <utils/threads.h> +#include <utils/Condition.h> +#include <utils/Mutex.h> #include <utils/String8.h> #include "egldefs.h" diff --git a/opengl/libs/EGL/egl_object.cpp b/opengl/libs/EGL/egl_object.cpp index 7fc56094bf..b553d71edf 100644 --- a/opengl/libs/EGL/egl_object.cpp +++ b/opengl/libs/EGL/egl_object.cpp @@ -14,19 +14,10 @@ ** limitations under the License. */ -#include <string> -#include <sstream> - -#include <ctype.h> -#include <stdint.h> -#include <stdlib.h> - -#include <EGL/egl.h> -#include <EGL/eglext.h> +#include "egl_object.h" -#include <utils/threads.h> +#include <sstream> -#include "egl_object.h" // ---------------------------------------------------------------------------- namespace android { diff --git a/opengl/libs/EGL/egl_object.h b/opengl/libs/EGL/egl_object.h index 8ceba1d892..f4012abb39 100644 --- a/opengl/libs/EGL/egl_object.h +++ b/opengl/libs/EGL/egl_object.h @@ -17,15 +17,13 @@ #ifndef ANDROID_EGL_OBJECT_H #define ANDROID_EGL_OBJECT_H -#include <atomic> -#include <ctype.h> #include <stdint.h> -#include <stdlib.h> +#include <stddef.h> #include <EGL/egl.h> #include <EGL/eglext.h> -#include <utils/threads.h> +#include <utils/StrongPointer.h> #include <utils/String8.h> #include <utils/Vector.h> @@ -62,8 +60,8 @@ public: template <typename N, typename T> class LocalRef { egl_object_t* ref; - LocalRef(); - explicit LocalRef(const LocalRef* rhs); + LocalRef() = delete; + LocalRef(const LocalRef* rhs) = delete; public: ~LocalRef(); explicit LocalRef(egl_object_t* rhs); diff --git a/opengl/libs/EGL/egl_tls.cpp b/opengl/libs/EGL/egl_tls.cpp index 6de5f27f4f..ca8684e3dd 100644 --- a/opengl/libs/EGL/egl_tls.cpp +++ b/opengl/libs/EGL/egl_tls.cpp @@ -14,16 +14,14 @@ ** limitations under the License. */ -#include <pthread.h> +#include "egl_tls.h" + #include <stdlib.h> #include <cutils/properties.h> #include <log/log.h> #include <utils/CallStack.h> -#include <EGL/egl.h> - -#include "egl_tls.h" namespace android { @@ -31,7 +29,7 @@ pthread_key_t egl_tls_t::sKey = TLS_KEY_NOT_INITIALIZED; pthread_once_t egl_tls_t::sOnceKey = PTHREAD_ONCE_INIT; egl_tls_t::egl_tls_t() - : error(EGL_SUCCESS), ctx(0), logCallWithNoContext(EGL_TRUE) { + : error(EGL_SUCCESS), ctx(0), logCallWithNoContext(true) { } const char *egl_tls_t::egl_strerror(EGLint err) { @@ -85,11 +83,12 @@ void egl_tls_t::setErrorEtcImpl( bool egl_tls_t::logNoContextCall() { egl_tls_t* tls = getTLS(); - if (tls->logCallWithNoContext == true) { + if (tls->logCallWithNoContext) { tls->logCallWithNoContext = false; return true; } return false; + } egl_tls_t* egl_tls_t::getTLS() { diff --git a/opengl/libs/EGL/egl_tls.h b/opengl/libs/EGL/egl_tls.h index 00eae0bdc6..9feae681bd 100644 --- a/opengl/libs/EGL/egl_tls.h +++ b/opengl/libs/EGL/egl_tls.h @@ -17,11 +17,9 @@ #ifndef ANDROID_EGL_TLS_H #define ANDROID_EGL_TLS_H -#include <pthread.h> - #include <EGL/egl.h> -#include "egldefs.h" +#include <pthread.h> // ---------------------------------------------------------------------------- namespace android { @@ -36,7 +34,7 @@ class egl_tls_t { EGLint error; EGLContext ctx; - EGLBoolean logCallWithNoContext; + bool logCallWithNoContext; egl_tls_t(); static void validateTLSKey(); diff --git a/opengl/libs/egl_impl.h b/opengl/libs/egl_impl.h index c0990ece39..a8855efa57 100644 --- a/opengl/libs/egl_impl.h +++ b/opengl/libs/egl_impl.h @@ -17,8 +17,6 @@ #ifndef ANDROID_EGL_IMPL_H #define ANDROID_EGL_IMPL_H -#include <ctype.h> - #include <EGL/egl.h> #include <EGL/eglext.h> #include <EGL/eglplatform.h> @@ -30,8 +28,7 @@ namespace android { // ---------------------------------------------------------------------------- EGLAPI const GLubyte * egl_get_string_for_current_context(GLenum name); -EGLAPI const GLubyte * egl_get_string_for_current_context(GLenum name, - GLuint index); +EGLAPI const GLubyte * egl_get_string_for_current_context(GLenum name, GLuint index); EGLAPI GLint egl_get_num_extensions_for_current_context(); // ---------------------------------------------------------------------------- diff --git a/services/surfaceflinger/Android.mk b/services/surfaceflinger/Android.mk index 24c68ece6b..afaccd2b5c 100644 --- a/services/surfaceflinger/Android.mk +++ b/services/surfaceflinger/Android.mk @@ -131,9 +131,11 @@ endif LOCAL_CFLAGS += -fvisibility=hidden -Werror=format +LOCAL_HEADER_LIBRARIES := \ + android.hardware.configstore-utils + LOCAL_STATIC_LIBRARIES := \ libhwcomposer-command-buffer \ - android.hardware.configstore-utils \ libtrace_proto \ libvkjson \ libvr_manager \ diff --git a/services/surfaceflinger/DisplayHardware/HWC2On1Adapter.cpp b/services/surfaceflinger/DisplayHardware/HWC2On1Adapter.cpp index d72139e12d..418789004a 100644 --- a/services/surfaceflinger/DisplayHardware/HWC2On1Adapter.cpp +++ b/services/surfaceflinger/DisplayHardware/HWC2On1Adapter.cpp @@ -961,8 +961,6 @@ Error HWC2On1Adapter::Display::validate(uint32_t* outNumTypes, uint32_t* outNumRequests) { std::unique_lock<std::recursive_mutex> lock(mStateMutex); - ALOGV("[%" PRIu64 "] Entering validate", mId); - if (!mChanges) { if (!mDevice.prepareAllDisplays()) { return Error::BadDisplay; @@ -1189,8 +1187,6 @@ bool HWC2On1Adapter::Display::prepare() { return false; } - ALOGV("[%" PRIu64 "] Entering prepare", mId); - allocateRequestedContents(); assignHwc1LayerIds(); @@ -2207,7 +2203,6 @@ void HWC2On1Adapter::Layer::applyCompositionType(hwc_layer_1_t& hwc1Layer) { // Adapter helpers void HWC2On1Adapter::populateCapabilities() { - ALOGV("populateCapabilities"); if (mHwc1MinorVersion >= 3U) { int supportedTypes = 0; auto result = mHwc1Device->query(mHwc1Device, @@ -2265,8 +2260,6 @@ std::tuple<HWC2On1Adapter::Layer*, Error> HWC2On1Adapter::getLayer( } void HWC2On1Adapter::populatePrimary() { - ALOGV("populatePrimary"); - std::unique_lock<std::recursive_timed_mutex> lock(mStateMutex); auto display = std::make_shared<Display>(*this, HWC2::DisplayType::Physical); @@ -2367,6 +2360,83 @@ bool HWC2On1Adapter::prepareAllDisplays() { return true; } +void dumpHWC1Message(hwc_composer_device_1* device, size_t numDisplays, + hwc_display_contents_1_t** displays) { + ALOGV("*****************************"); + size_t displayId = 0; + while (displayId < numDisplays) { + hwc_display_contents_1_t* display = displays[displayId]; + + ALOGV("hwc_display_contents_1_t[%zu] @0x%p", displayId, display); + if (display == nullptr) { + displayId++; + continue; + } + ALOGV(" retirefd:0x%08x", display->retireFenceFd); + ALOGV(" outbuf :0x%p", display->outbuf); + ALOGV(" outbuffd:0x%08x", display->outbufAcquireFenceFd); + ALOGV(" flags :0x%08x", display->flags); + for(size_t layerId=0 ; layerId < display->numHwLayers ; layerId++) { + hwc_layer_1_t& layer = display->hwLayers[layerId]; + ALOGV(" Layer[%zu]:", layerId); + ALOGV(" composition : 0x%08x", layer.compositionType); + ALOGV(" hints : 0x%08x", layer.hints); + ALOGV(" flags : 0x%08x", layer.flags); + ALOGV(" handle : 0x%p", layer.handle); + ALOGV(" transform : 0x%08x", layer.transform); + ALOGV(" blending : 0x%08x", layer.blending); + ALOGV(" sourceCropf : %f, %f, %f, %f", + layer.sourceCropf.left, + layer.sourceCropf.top, + layer.sourceCropf.right, + layer.sourceCropf.bottom); + ALOGV(" displayFrame : %d, %d, %d, %d", + layer.displayFrame.left, + layer.displayFrame.left, + layer.displayFrame.left, + layer.displayFrame.left); + hwc_region_t& visReg = layer.visibleRegionScreen; + ALOGV(" visibleRegionScreen: #0x%08zx[@0x%p]", + visReg.numRects, + visReg.rects); + for (size_t visRegId=0; visRegId < visReg.numRects ; visRegId++) { + if (layer.visibleRegionScreen.rects == nullptr) { + ALOGV(" null"); + } else { + ALOGV(" visibleRegionScreen[%zu] %d, %d, %d, %d", + visRegId, + visReg.rects[visRegId].left, + visReg.rects[visRegId].top, + visReg.rects[visRegId].right, + visReg.rects[visRegId].bottom); + } + } + ALOGV(" acquireFenceFd : 0x%08x", layer.acquireFenceFd); + ALOGV(" releaseFenceFd : 0x%08x", layer.releaseFenceFd); + ALOGV(" planeAlpha : 0x%08x", layer.planeAlpha); + if (getMinorVersion(device) < 5) + continue; + ALOGV(" surfaceDamage : #0x%08zx[@0x%p]", + layer.surfaceDamage.numRects, + layer.surfaceDamage.rects); + for (size_t sdId=0; sdId < layer.surfaceDamage.numRects ; sdId++) { + if (layer.surfaceDamage.rects == nullptr) { + ALOGV(" null"); + } else { + ALOGV(" surfaceDamage[%zu] %d, %d, %d, %d", + sdId, + layer.surfaceDamage.rects[sdId].left, + layer.surfaceDamage.rects[sdId].top, + layer.surfaceDamage.rects[sdId].right, + layer.surfaceDamage.rects[sdId].bottom); + } + } + } + displayId++; + } + ALOGV("-----------------------------"); +} + Error HWC2On1Adapter::setAllDisplays() { ATRACE_CALL(); @@ -2391,6 +2461,7 @@ Error HWC2On1Adapter::setAllDisplays() { ALOGV("Calling HWC1 set"); { ATRACE_NAME("HWC1 set"); + //dumpHWC1Message(mHwc1Device, mHwc1Contents.size(), mHwc1Contents.data()); mHwc1Device->set(mHwc1Device, mHwc1Contents.size(), mHwc1Contents.data()); } diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp index 9b02d3e616..24ebac7bca 100644 --- a/services/surfaceflinger/Layer.cpp +++ b/services/surfaceflinger/Layer.cpp @@ -1727,7 +1727,7 @@ bool Layer::setAlpha(uint8_t alpha) { bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix) { mCurrentState.sequence++; mCurrentState.requested.transform.set( - matrix.dsdx, matrix.dsdy, matrix.dtdx, matrix.dtdy); + matrix.dsdx, matrix.dtdy, matrix.dtdx, matrix.dsdy); mCurrentState.modified = true; setTransactionFlags(eTransactionNeeded); return true; diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp index 62c9f25da3..4acdb826e0 100644 --- a/services/surfaceflinger/SurfaceFlinger.cpp +++ b/services/surfaceflinger/SurfaceFlinger.cpp @@ -33,7 +33,6 @@ #include <binder/IPCThreadState.h> #include <binder/IServiceManager.h> -#include <binder/MemoryHeapBase.h> #include <binder/PermissionCache.h> #include <dvr/vr_flinger.h> @@ -1272,6 +1271,7 @@ void SurfaceFlinger::onMessageReceived(int32_t what) { Fence::SIGNAL_TIME_PENDING); ATRACE_INT("FrameMissed", static_cast<int>(frameMissed)); if (mPropagateBackpressure && frameMissed) { + ALOGD("Backpressure trigger, skipping transaction & refresh!"); signalLayerUpdate(); break; } diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h index 5bdedf3af3..0b3deef0e1 100644 --- a/services/surfaceflinger/SurfaceFlinger.h +++ b/services/surfaceflinger/SurfaceFlinger.h @@ -36,8 +36,6 @@ #include <utils/SortedVector.h> #include <utils/threads.h> -#include <binder/IMemory.h> - #include <ui/FenceTime.h> #include <ui/PixelFormat.h> #include <math/mat4.h> diff --git a/services/surfaceflinger/SurfaceFlingerConsumer.cpp b/services/surfaceflinger/SurfaceFlingerConsumer.cpp index 04f4f7e339..2fcbdba224 100644 --- a/services/surfaceflinger/SurfaceFlingerConsumer.cpp +++ b/services/surfaceflinger/SurfaceFlingerConsumer.cpp @@ -223,7 +223,7 @@ bool SurfaceFlingerConsumer::releasePendingBuffer() status_t result = releaseBufferLocked(mPendingRelease.currentTexture, mPendingRelease.graphicBuffer, mPendingRelease.display, mPendingRelease.fence); - ALOGE_IF(result != NO_ERROR, "releasePendingBuffer failed: %s (%d)", + ALOGE_IF(result < NO_ERROR, "releasePendingBuffer failed: %s (%d)", strerror(-result), result); mPendingRelease = PendingRelease(); return true; diff --git a/services/surfaceflinger/SurfaceFlinger_hwc1.cpp b/services/surfaceflinger/SurfaceFlinger_hwc1.cpp index 9aa2fabf8c..fe8dd0ced5 100644 --- a/services/surfaceflinger/SurfaceFlinger_hwc1.cpp +++ b/services/surfaceflinger/SurfaceFlinger_hwc1.cpp @@ -33,7 +33,6 @@ #include <binder/IPCThreadState.h> #include <binder/IServiceManager.h> -#include <binder/MemoryHeapBase.h> #include <binder/PermissionCache.h> #include <ui/DisplayInfo.h> diff --git a/services/surfaceflinger/tests/Transaction_test.cpp b/services/surfaceflinger/tests/Transaction_test.cpp index 5b61ae0e9b..aeb557aad3 100644 --- a/services/surfaceflinger/tests/Transaction_test.cpp +++ b/services/surfaceflinger/tests/Transaction_test.cpp @@ -18,8 +18,6 @@ #include <android/native_window.h> -#include <binder/IMemory.h> - #include <gui/ISurfaceComposer.h> #include <gui/Surface.h> #include <gui/SurfaceComposerClient.h> @@ -199,9 +197,9 @@ TEST_F(LayerUpdateTest, LayerMoveWorks) { { SCOPED_TRACE("before move"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 0, 12, 63, 63, 195); - sc->checkPixel( 75, 75, 195, 63, 63); - sc->checkPixel(145, 145, 63, 63, 195); + sc->expectBGColor(0, 12); + sc->expectFGColor(75, 75); + sc->expectBGColor(145, 145); } SurfaceComposerClient::openGlobalTransaction(); @@ -211,9 +209,9 @@ TEST_F(LayerUpdateTest, LayerMoveWorks) { // This should reflect the new position, but not the new color. SCOPED_TRACE("after move, before redraw"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 75, 75, 63, 63, 195); - sc->checkPixel(145, 145, 195, 63, 63); + sc->expectBGColor(24, 24); + sc->expectBGColor(75, 75); + sc->expectFGColor(145, 145); } fillSurfaceRGBA8(mFGSurfaceControl, 63, 195, 63); @@ -222,9 +220,9 @@ TEST_F(LayerUpdateTest, LayerMoveWorks) { // This should reflect the new position and the new color. SCOPED_TRACE("after redraw"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 75, 75, 63, 63, 195); - sc->checkPixel(145, 145, 63, 195, 63); + sc->expectBGColor(24, 24); + sc->expectBGColor(75, 75); + sc->checkPixel(145, 145, 63, 195, 63); } } @@ -233,9 +231,9 @@ TEST_F(LayerUpdateTest, LayerResizeWorks) { { SCOPED_TRACE("before resize"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 0, 12, 63, 63, 195); - sc->checkPixel( 75, 75, 195, 63, 63); - sc->checkPixel(145, 145, 63, 63, 195); + sc->expectBGColor(0, 12); + sc->expectFGColor(75, 75); + sc->expectBGColor(145, 145); } ALOGD("resizing"); @@ -248,9 +246,9 @@ TEST_F(LayerUpdateTest, LayerResizeWorks) { // has not yet received a buffer of the correct size. SCOPED_TRACE("after resize, before redraw"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 0, 12, 63, 63, 195); - sc->checkPixel( 75, 75, 195, 63, 63); - sc->checkPixel(145, 145, 63, 63, 195); + sc->expectBGColor(0, 12); + sc->expectFGColor(75, 75); + sc->expectBGColor(145, 145); } ALOGD("drawing"); @@ -261,9 +259,9 @@ TEST_F(LayerUpdateTest, LayerResizeWorks) { // This should reflect the new size and the new color. SCOPED_TRACE("after redraw"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 75, 75, 63, 195, 63); - sc->checkPixel(145, 145, 63, 195, 63); + sc->expectBGColor(24, 24); + sc->checkPixel(75, 75, 63, 195, 63); + sc->checkPixel(145, 145, 63, 195, 63); } } @@ -272,9 +270,9 @@ TEST_F(LayerUpdateTest, LayerCropWorks) { { SCOPED_TRACE("before crop"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 75, 75, 195, 63, 63); - sc->checkPixel(145, 145, 63, 63, 195); + sc->expectBGColor(24, 24); + sc->expectFGColor(75, 75); + sc->expectBGColor(145, 145); } SurfaceComposerClient::openGlobalTransaction(); @@ -285,11 +283,11 @@ TEST_F(LayerUpdateTest, LayerCropWorks) { // This should crop the foreground surface. SCOPED_TRACE("after crop"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 75, 75, 63, 63, 195); - sc->checkPixel( 95, 80, 195, 63, 63); - sc->checkPixel( 80, 95, 195, 63, 63); - sc->checkPixel( 96, 96, 63, 63, 195); + sc->expectBGColor(24, 24); + sc->expectBGColor(75, 75); + sc->expectFGColor(95, 80); + sc->expectFGColor(80, 95); + sc->expectBGColor(96, 96); } } @@ -298,9 +296,9 @@ TEST_F(LayerUpdateTest, LayerFinalCropWorks) { { SCOPED_TRACE("before crop"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 75, 75, 195, 63, 63); - sc->checkPixel(145, 145, 63, 63, 195); + sc->expectBGColor(24, 24); + sc->expectFGColor(75, 75); + sc->expectBGColor(145, 145); } SurfaceComposerClient::openGlobalTransaction(); Rect cropRect(16, 16, 32, 32); @@ -310,11 +308,11 @@ TEST_F(LayerUpdateTest, LayerFinalCropWorks) { // This should crop the foreground surface. SCOPED_TRACE("after crop"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 75, 75, 63, 63, 195); - sc->checkPixel( 95, 80, 63, 63, 195); - sc->checkPixel( 80, 95, 63, 63, 195); - sc->checkPixel( 96, 96, 63, 63, 195); + sc->expectBGColor(24, 24); + sc->expectBGColor(75, 75); + sc->expectBGColor(95, 80); + sc->expectBGColor(80, 95); + sc->expectBGColor(96, 96); } } @@ -323,9 +321,9 @@ TEST_F(LayerUpdateTest, LayerSetLayerWorks) { { SCOPED_TRACE("before setLayer"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 75, 75, 195, 63, 63); - sc->checkPixel(145, 145, 63, 63, 195); + sc->expectBGColor(24, 24); + sc->expectFGColor(75, 75); + sc->expectBGColor(145, 145); } SurfaceComposerClient::openGlobalTransaction(); @@ -335,9 +333,9 @@ TEST_F(LayerUpdateTest, LayerSetLayerWorks) { // This should hide the foreground surface beneath the background. SCOPED_TRACE("after setLayer"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 75, 75, 63, 63, 195); - sc->checkPixel(145, 145, 63, 63, 195); + sc->expectBGColor(24, 24); + sc->expectBGColor(75, 75); + sc->expectBGColor(145, 145); } } @@ -346,9 +344,9 @@ TEST_F(LayerUpdateTest, LayerShowHideWorks) { { SCOPED_TRACE("before hide"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 75, 75, 195, 63, 63); - sc->checkPixel(145, 145, 63, 63, 195); + sc->expectBGColor(24, 24); + sc->expectFGColor(75, 75); + sc->expectBGColor(145, 145); } SurfaceComposerClient::openGlobalTransaction(); @@ -358,9 +356,9 @@ TEST_F(LayerUpdateTest, LayerShowHideWorks) { // This should hide the foreground surface. SCOPED_TRACE("after hide, before show"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 75, 75, 63, 63, 195); - sc->checkPixel(145, 145, 63, 63, 195); + sc->expectBGColor(24, 24); + sc->expectBGColor(75, 75); + sc->expectBGColor(145, 145); } SurfaceComposerClient::openGlobalTransaction(); @@ -370,9 +368,9 @@ TEST_F(LayerUpdateTest, LayerShowHideWorks) { // This should show the foreground surface. SCOPED_TRACE("after show"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 75, 75, 195, 63, 63); - sc->checkPixel(145, 145, 63, 63, 195); + sc->expectBGColor(24, 24); + sc->expectFGColor(75, 75); + sc->expectBGColor(145, 145); } } @@ -381,9 +379,9 @@ TEST_F(LayerUpdateTest, LayerSetAlphaWorks) { { SCOPED_TRACE("before setAlpha"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 75, 75, 195, 63, 63); - sc->checkPixel(145, 145, 63, 63, 195); + sc->expectBGColor(24, 24); + sc->expectFGColor(75, 75); + sc->expectBGColor(145, 145); } SurfaceComposerClient::openGlobalTransaction(); @@ -393,9 +391,9 @@ TEST_F(LayerUpdateTest, LayerSetAlphaWorks) { // This should set foreground to be 75% opaque. SCOPED_TRACE("after setAlpha"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 75, 75, 162, 63, 96); - sc->checkPixel(145, 145, 63, 63, 195); + sc->expectBGColor(24, 24); + sc->checkPixel(75, 75, 162, 63, 96); + sc->expectBGColor(145, 145); } } @@ -404,9 +402,9 @@ TEST_F(LayerUpdateTest, LayerSetLayerStackWorks) { { SCOPED_TRACE("before setLayerStack"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 75, 75, 195, 63, 63); - sc->checkPixel(145, 145, 63, 63, 195); + sc->expectBGColor(24, 24); + sc->expectFGColor(75, 75); + sc->expectBGColor(145, 145); } SurfaceComposerClient::openGlobalTransaction(); @@ -417,9 +415,9 @@ TEST_F(LayerUpdateTest, LayerSetLayerStackWorks) { // layer stack. SCOPED_TRACE("after setLayerStack"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 75, 75, 63, 63, 195); - sc->checkPixel(145, 145, 63, 63, 195); + sc->expectBGColor(24, 24); + sc->expectBGColor(75, 75); + sc->expectBGColor(145, 145); } } @@ -428,9 +426,9 @@ TEST_F(LayerUpdateTest, LayerSetFlagsWorks) { { SCOPED_TRACE("before setFlags"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 75, 75, 195, 63, 63); - sc->checkPixel(145, 145, 63, 63, 195); + sc->expectBGColor(24, 24); + sc->expectFGColor(75, 75); + sc->expectBGColor(145, 145); } SurfaceComposerClient::openGlobalTransaction(); @@ -441,9 +439,9 @@ TEST_F(LayerUpdateTest, LayerSetFlagsWorks) { // This should hide the foreground surface SCOPED_TRACE("after setFlags"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 75, 75, 63, 63, 195); - sc->checkPixel(145, 145, 63, 63, 195); + sc->expectBGColor(24, 24); + sc->expectBGColor(75, 75); + sc->expectBGColor(145, 145); } } @@ -452,10 +450,10 @@ TEST_F(LayerUpdateTest, LayerSetMatrixWorks) { { SCOPED_TRACE("before setMatrix"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 91, 96, 195, 63, 63); - sc->checkPixel( 96, 101, 195, 63, 63); - sc->checkPixel(145, 145, 63, 63, 195); + sc->expectBGColor(24, 24); + sc->expectFGColor(91, 96); + sc->expectFGColor(96, 101); + sc->expectBGColor(145, 145); } SurfaceComposerClient::openGlobalTransaction(); @@ -465,10 +463,10 @@ TEST_F(LayerUpdateTest, LayerSetMatrixWorks) { { SCOPED_TRACE("after setMatrix"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 24, 24, 63, 63, 195); - sc->checkPixel( 91, 96, 195, 63, 63); - sc->checkPixel( 96, 91, 63, 63, 195); - sc->checkPixel(145, 145, 63, 63, 195); + sc->expectBGColor(24, 24); + sc->expectFGColor(91, 96); + sc->expectBGColor(96, 91); + sc->expectBGColor(145, 145); } } @@ -477,9 +475,9 @@ TEST_F(LayerUpdateTest, DeferredTransactionTest) { { SCOPED_TRACE("before anything"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 32, 32, 63, 63, 195); - sc->checkPixel( 96, 96, 195, 63, 63); - sc->checkPixel(160, 160, 63, 63, 195); + sc->expectBGColor(32, 32); + sc->expectFGColor(96, 96); + sc->expectBGColor(160, 160); } // set up two deferred transactions on different frames @@ -498,9 +496,9 @@ TEST_F(LayerUpdateTest, DeferredTransactionTest) { { SCOPED_TRACE("before any trigger"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 32, 32, 63, 63, 195); - sc->checkPixel( 96, 96, 195, 63, 63); - sc->checkPixel(160, 160, 63, 63, 195); + sc->expectBGColor(32, 32); + sc->expectFGColor(96, 96); + sc->expectBGColor(160, 160); } // should trigger the first deferred transaction, but not the second one @@ -508,9 +506,9 @@ TEST_F(LayerUpdateTest, DeferredTransactionTest) { { SCOPED_TRACE("after first trigger"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 32, 32, 63, 63, 195); - sc->checkPixel( 96, 96, 162, 63, 96); - sc->checkPixel(160, 160, 63, 63, 195); + sc->expectBGColor(32, 32); + sc->checkPixel(96, 96, 162, 63, 96); + sc->expectBGColor(160, 160); } // should show up immediately since it's not deferred @@ -523,9 +521,9 @@ TEST_F(LayerUpdateTest, DeferredTransactionTest) { { SCOPED_TRACE("after second trigger"); ScreenCapture::captureScreen(&sc); - sc->checkPixel( 32, 32, 63, 63, 195); - sc->checkPixel( 96, 96, 63, 63, 195); - sc->checkPixel(160, 160, 195, 63, 63); + sc->expectBGColor(32, 32); + sc->expectBGColor(96, 96); + sc->expectFGColor(160, 160); } } diff --git a/services/vr/sensord/pose_service.cpp b/services/vr/sensord/pose_service.cpp index 40eb21db77..32a2160869 100644 --- a/services/vr/sensord/pose_service.cpp +++ b/services/vr/sensord/pose_service.cpp @@ -25,8 +25,6 @@ #include <private/dvr/sensor_constants.h> #include <utils/Trace.h> -#define arraysize(x) (static_cast<ssize_t>(std::extent<decltype(x)>::value)) - using android::pdx::LocalChannelHandle; using android::pdx::default_transport::Endpoint; using android::pdx::Status; @@ -35,11 +33,8 @@ namespace android { namespace dvr { using Vector3d = vec3d; -using Vector3f = vec3f; using Rotationd = quatd; -using Rotationf = quatf; using AngleAxisd = Eigen::AngleAxis<double>; -using AngleAxisf = Eigen::AngleAxis<float>; namespace { // Wait a few seconds before checking if we need to disable sensors. @@ -69,7 +64,6 @@ static constexpr char kPoseRingBufferName[] = "PoseService:RingBuffer"; static constexpr int kDatasetIdLength = 36; static constexpr char kDatasetIdChars[] = "0123456789abcdef-"; -static constexpr char kDatasetLocation[] = "/data/sdcard/datasets/"; // These are the flags used by BufferProducer::CreatePersistentUncachedBlob, // plus PRIVATE_ADSP_HEAP to allow access from the DSP. @@ -77,14 +71,6 @@ static constexpr int kPoseRingBufferFlags = GRALLOC_USAGE_SW_READ_RARELY | GRALLOC_USAGE_SW_WRITE_RARELY | GRALLOC_USAGE_PRIVATE_UNCACHED | GRALLOC_USAGE_PRIVATE_ADSP_HEAP; -// Extract yaw angle from a given quaternion rotation. -// Y-axis is considered to be vertical. Result is in rad. -template <typename T> -T ExtractYaw(Eigen::Quaternion<T> rotation) { - const Eigen::Vector3<T> yaw_axis = rotation * vec3::UnitZ(); - return std::atan2(yaw_axis.z(), yaw_axis.x()); -} - std::string GetPoseModeString(DvrPoseMode mode) { switch (mode) { case DVR_POSE_MODE_6DOF: @@ -110,19 +96,6 @@ std::string GetPoseModeString(DvrPoseMode mode) { } } -inline std::string GetVector3dString(const Vector3d& vector) { - std::ostringstream stream; - stream << "[" << vector[0] << "," << vector[1] << "," << vector[2] << "]"; - return stream.str(); -} - -inline std::string GetRotationdString(const Rotationd& rotation) { - std::ostringstream stream; - stream << "[" << rotation.w() << ", " << GetVector3dString(rotation.vec()) - << "]"; - return stream.str(); -} - } // namespace PoseService::PoseService(SensorThread* sensor_thread) diff --git a/vulkan/api/platform.api b/vulkan/api/platform.api index fb8e3cea5c..b82cbb4b6c 100644 --- a/vulkan/api/platform.api +++ b/vulkan/api/platform.api @@ -49,4 +49,5 @@ type u64 size_t @internal type void* HINSTANCE @internal type void* HWND @internal type void* HANDLE +@internal type u32 DWORD @internal class SECURITY_ATTRIBUTES {} diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api index eed44ad670..cfeeeefd7f 100644 --- a/vulkan/api/vulkan.api +++ b/vulkan/api/vulkan.api @@ -45,117 +45,153 @@ define VK_FALSE 0 // API keyword, but needs special handling by some templates define NULL_HANDLE 0 +// 1 @extension("VK_KHR_surface") define VK_KHR_SURFACE_SPEC_VERSION 25 @extension("VK_KHR_surface") define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" +// 2 @extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_SPEC_VERSION 68 @extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" +// 3 @extension("VK_KHR_display") define VK_KHR_DISPLAY_SPEC_VERSION 21 @extension("VK_KHR_display") define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" +// 4 @extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9 @extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" +// 5 @extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6 @extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_NAME "VK_KHR_xlib_surface" +// 6 @extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_SPEC_VERSION 6 @extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_NAME "VK_KHR_xcb_surface" +// 7 @extension("VK_KHR_wayland_surface") define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 5 @extension("VK_KHR_wayland_surface") define VK_KHR_WAYLAND_SURFACE_NAME "VK_KHR_wayland_surface" +// 8 @extension("VK_KHR_mir_surface") define VK_KHR_MIR_SURFACE_SPEC_VERSION 4 @extension("VK_KHR_mir_surface") define VK_KHR_MIR_SURFACE_NAME "VK_KHR_mir_surface" +// 9 @extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6 @extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_NAME "VK_KHR_android_surface" +// 10 @extension("VK_KHR_win32_surface") define VK_KHR_WIN32_SURFACE_SPEC_VERSION 5 @extension("VK_KHR_win32_surface") define VK_KHR_WIN32_SURFACE_NAME "VK_KHR_win32_surface" -@extension("VK_KHR_incremental_present") define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1 -@extension("VK_KHR_incremental_present") define VK_KHR_INCREMENTAL_PRESENT_NAME "VK_KHR_incremental_present" - -@extension("VK_ANDROID_native_buffer") define VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION 6 +// 11 +@extension("VK_ANDROID_native_buffer") define VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION 7 @extension("VK_ANDROID_native_buffer") define VK_ANDROID_NATIVE_BUFFER_NAME "VK_ANDROID_native_buffer" -@extension("VK_GOOGLE_display_timing") define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1 -@extension("VK_GOOGLE_display_timing") define VK_GOOGLE_DISPLAY_TIMING_NAME "VK_GOOGLE_display_timing" - +// 12 @extension("VK_EXT_debug_report") define VK_EXT_DEBUG_REPORT_SPEC_VERSION 4 @extension("VK_EXT_debug_report") define VK_EXT_DEBUG_REPORT_NAME "VK_EXT_debug_report" +// 13 @extension("VK_NV_glsl_shader") define VK_NV_GLSL_SHADER_SPEC_VERSION 1 @extension("VK_NV_glsl_shader") define VK_NV_GLSL_SHADER_NAME "VK_NV_glsl_shader" +// 15 @extension("VK_KHR_sampler_mirror_clamp_to_edge") define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1 @extension("VK_KHR_sampler_mirror_clamp_to_edge") define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_NAME "VK_KHR_sampler_mirror_clamp_to_edge" +// 16 @extension("VK_IMG_filter_cubic") define VK_IMG_FILTER_CUBIC_SPEC_VERSION 1 @extension("VK_IMG_filter_cubic") define VK_IMG_FILTER_CUBIC_NAME "VK_IMG_filter_cubic" +// 19 @extension("VK_AMD_rasterization_order") define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1 @extension("VK_AMD_rasterization_order") define VK_AMD_RASTERIZATION_ORDER_NAME "VK_AMD_rasterization_order" +// 21 @extension("VK_AMD_shader_trinary_minmax") define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1 @extension("VK_AMD_shader_trinary_minmax") define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax" +// 22 @extension("VK_AMD_shader_explicit_vertex_parameter") define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1 @extension("VK_AMD_shader_explicit_vertex_parameter") define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter" +// 23 @extension("VK_EXT_debug_marker") define VK_EXT_DEBUG_MARKER_SPEC_VERSION 3 @extension("VK_EXT_debug_marker") define VK_EXT_DEBUG_MARKER_NAME "VK_EXT_debug_marker" +// 26 @extension("VK_AMD_gcn_shader") define VK_AMD_GCN_SHADER_SPEC_VERSION 1 @extension("VK_AMD_gcn_shader") define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader" +// 27 @extension("VK_NV_dedicated_allocation") define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1 @extension("VK_NV_dedicated_allocation") define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation" -@extension("VK_KHR_get_physical_device_properties2") define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1 -@extension("VK_KHR_get_physical_device_properties2") define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2" +// 28 +@extension("VK_IMG_format_pvrtc") define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1 +@extension("VK_IMG_format_pvrtc") define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc" +// 34 @extension("VK_AMD_draw_indirect_count") define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 @extension("VK_AMD_draw_indirect_count") define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count" +// 36 @extension("VK_AMD_negative_viewport_height") define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1 @extension("VK_AMD_negative_viewport_height") define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height" +// 37 @extension("VK_AMD_gpu_shader_half_float") define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 1 @extension("VK_AMD_gpu_shader_half_float") define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float" +// 38 @extension("VK_AMD_shader_ballot") define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1 @extension("VK_AMD_shader_ballot") define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot" -@extension("VK_IMG_format_pvrtc") define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1 -@extension("VK_IMG_format_pvrtc") define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc" - +// 56 @extension("VK_NV_external_memory_capabilities") define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 @extension("VK_NV_external_memory_capabilities") define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities" +// 57 @extension("VK_NV_external_memory") define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1 @extension("VK_NV_external_memory") define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory" +// 58 @extension("VK_NV_external_memory_win32") define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 @extension("VK_NV_external_memory_win32") define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32" +// 59 @extension("VK_NV_win32_keyed_mutex") define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1 @extension("VK_NV_win32_keyed_mutex") define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex" +// 60 +@extension("VK_KHR_get_physical_device_properties2") define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1 +@extension("VK_KHR_get_physical_device_properties2") define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2" + +// 62 @extension("VK_EXT_validation_flags") define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1 @extension("VK_EXT_validation_flags") define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags" +// 85 +@extension("VK_KHR_incremental_present") define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1 +@extension("VK_KHR_incremental_present") define VK_KHR_INCREMENTAL_PRESENT_NAME "VK_KHR_incremental_present" + +// 87 @extension("VK_NVX_device_generated_commands") define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 1 @extension("VK_NVX_device_generated_commands") define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands" -@extension("VK_KHR_shared_presentable_image") define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1 -@extension("VK_KHR_shared_presentable_image") define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image" +// 93 +@extension("VK_GOOGLE_display_timing") define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1 +@extension("VK_GOOGLE_display_timing") define VK_GOOGLE_DISPLAY_TIMING_NAME "VK_GOOGLE_display_timing" -@extension("VK_EXT_HDR_METADATA_SPEC_VERSION") define VK_EXT_HDR_METADATA_SPEC_VERSION 1 -@extension("VK_EXT_HDR_METADATA_EXTENSION_NAME") define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" +// 106 +@extension("VK_EXT_hdr_metadata") define VK_EXT_HDR_METADATA_SPEC_VERSION 1 +@extension("VK_EXT_hdr_metadata") define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" +// 112 +@extension("VK_KHR_shared_presentable_image") define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1 +@extension("VK_KHR_shared_presentable_image") define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image" ///////////// // Types // @@ -652,28 +688,14 @@ enum VkFormat { VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, //@extension("VK_IMG_format_pvrtc") - VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, - - //@extension("VK_IMG_format_pvrtc") - VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, - - //@extension("VK_IMG_format_pvrtc") - VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, - - //@extension("VK_IMG_format_pvrtc") - VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, - - //@extension("VK_IMG_format_pvrtc") - VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, - - //@extension("VK_IMG_format_pvrtc") - VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, - - //@extension("VK_IMG_format_pvrtc") - VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, - - //@extension("VK_IMG_format_pvrtc") - VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, + VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, + VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, + VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, + VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, + VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, + VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, + VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, + VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, } /// Structure type enumerant @@ -763,6 +785,7 @@ enum VkStructureType { //@extension("VK_ANDROID_native_buffer") VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID = 1000010000, VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID = 1000010001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID = 1000010002, //@extension("VK_GOOGLE_display_timing") VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000, @@ -775,87 +798,49 @@ enum VkStructureType { //@extension("VK_EXT_debug_marker") VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, - - //@extension("VK_EXT_debug_marker") VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, - - //@extension("VK_EXT_debug_marker") VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, //@extension("VK_NV_dedicated_allocation") VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, - - //@extension("VK_NV_dedicated_allocation") VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, - - //@extension("VK_NV_dedicated_allocation") VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, //@extension("VK_NV_external_memory") - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, - - //@extension("VK_NV_external_memory") - VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, - - //@extension("VK_NV_external_memory_win32") - VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, //@extension("VK_NV_external_memory_win32") - VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, //@extension("VK_NV_win32_keyed_mutex") VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, //@extension("VK_KHR_get_physical_device_properties2") - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = 1000059000, - - //@extension("VK_KHR_get_physical_device_properties2") - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = 1000059001, - - //@extension("VK_KHR_get_physical_device_properties2") - VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = 1000059002, - - //@extension("VK_KHR_get_physical_device_properties2") - VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059003, - - //@extension("VK_KHR_get_physical_device_properties2") - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = 1000059004, - - //@extension("VK_KHR_get_physical_device_properties2") - VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000059005, - - //@extension("VK_KHR_get_physical_device_properties2") - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = 1000059006, - - //@extension("VK_KHR_get_physical_device_properties2") - VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007, - - //@extension("VK_KHR_get_physical_device_properties2") + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = 1000059000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = 1000059001, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = 1000059002, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = 1000059004, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000059005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = 1000059006, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008, //@extension("VK_EXT_validation_flags") - VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, + VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, //@extension("VK_KHR_incremental_present") - VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, - - //@extension("VK_NVX_device_generated_commands") - VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000, - - //@extension("VK_NVX_device_generated_commands") - VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001, - - //@extension("VK_NVX_device_generated_commands") - VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002, - - //@extension("VK_NVX_device_generated_commands") - VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003, - - //@extension("VK_NVX_device_generated_commands") - VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004, + VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, //@extension("VK_NVX_device_generated_commands") - VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005, + VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001, + VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002, + VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003, + VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004, + VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005, } enum VkSubpassContents { @@ -941,7 +926,7 @@ enum VkPresentModeKHR { @extension("VK_KHR_surface") enum VkColorSpaceKHR { VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0x00000000, - VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104001, + VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104001, VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104002, VK_COLOR_SPACE_SCRGB_LINEAR_EXT = 1000104003, VK_COLOR_SPACE_SCRGB_NONLINEAR_EXT = 1000104004, @@ -1011,23 +996,23 @@ enum VkValidationCheckEXT { @extension("VK_NVX_device_generated_commands") enum VkIndirectCommandsTokenTypeNVX { - VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX = 0, - VK_INDIRECT_COMMANDS_TOKEN_DESCRIPTOR_SET_NVX = 1, - VK_INDIRECT_COMMANDS_TOKEN_INDEX_BUFFER_NVX = 2, - VK_INDIRECT_COMMANDS_TOKEN_VERTEX_BUFFER_NVX = 3, - VK_INDIRECT_COMMANDS_TOKEN_PUSH_CONSTANT_NVX = 4, - VK_INDIRECT_COMMANDS_TOKEN_DRAW_INDEXED_NVX = 5, - VK_INDIRECT_COMMANDS_TOKEN_DRAW_NVX = 6, - VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX = 7, + VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX = 0, + VK_INDIRECT_COMMANDS_TOKEN_DESCRIPTOR_SET_NVX = 1, + VK_INDIRECT_COMMANDS_TOKEN_INDEX_BUFFER_NVX = 2, + VK_INDIRECT_COMMANDS_TOKEN_VERTEX_BUFFER_NVX = 3, + VK_INDIRECT_COMMANDS_TOKEN_PUSH_CONSTANT_NVX = 4, + VK_INDIRECT_COMMANDS_TOKEN_DRAW_INDEXED_NVX = 5, + VK_INDIRECT_COMMANDS_TOKEN_DRAW_NVX = 6, + VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX = 7, } @extension("VK_NVX_device_generated_commands") enum VkObjectEntryTypeNVX { - VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX = 0, - VK_OBJECT_ENTRY_PIPELINE_NVX = 1, - VK_OBJECT_ENTRY_INDEX_BUFFER_NVX = 2, - VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX = 3, - VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX = 4, + VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX = 0, + VK_OBJECT_ENTRY_PIPELINE_NVX = 1, + VK_OBJECT_ENTRY_INDEX_BUFFER_NVX = 2, + VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX = 3, + VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX = 4, } ///////////////// @@ -1082,8 +1067,6 @@ bitfield VkAccessFlagBits { //@extension("VK_NVX_device_generated_commands") VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000, - - //@extension("VK_NVX_device_generated_commands") VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000, } @@ -1570,6 +1553,13 @@ type VkFlags VkWin32SurfaceCreateFlagsKHR //bitfield VkWin32SurfaceCreateFlagBitsKHR { //} +@extension("VK_ANDROID_native_buffer") +type VkFlags VkSwapchainImageUsageFlagsANDROID +@extension("VK_ANDROID_native_buffer") +bitfield VkSwapchainImageUsageFlagBitsANDROID { + VK_SWAPCHAIN_IMAGE_USAGE_FLAGS_SHARED_BIT_ANDROID = 0x00000001, +} + @extension("VK_EXT_debug_report") type VkFlags VkDebugReportFlagsEXT @extension("VK_EXT_debug_report") @@ -1581,51 +1571,43 @@ bitfield VkDebugReportFlagBitsEXT { VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, } -@extension("VK_ANDROID_native_buffer") -type VkFlags VkSwapchainImageUsageFlagsANDROID -@extension("VK_ANDROID_native_buffer") -bitfield VkSwapchainImageUsageFlagBitsANDROID { - VK_SWAPCHAIN_IMAGE_USAGE_FLAGS_SHARED_BIT_ANDROID = 0x00000001, -} - @extension("VK_NV_external_memory_capabilities") type VkFlags VkExternalMemoryHandleTypeFlagsNV @extension("VK_NV_external_memory_capabilities") bitfield VkExternalMemoryHandleTypeFlagBitsNV { - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008, } @extension("VK_NV_external_memory_capabilities") type VkFlags VkExternalMemoryFeatureFlagsNV @extension("VK_NV_external_memory_capabilities") bitfield VkExternalMemoryFeatureFlagBitsNV { - VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001, - VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002, - VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004, + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004, } @extension("VK_NVX_device_generated_commands") type VkFlags VkIndirectCommandsLayoutUsageFlagsNVX @extension("VK_NVX_device_generated_commands") bitfield VkIndirectCommandsLayoutUsageFlagBitsNVX { - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008, } @extension("VK_NVX_device_generated_commands") type VkFlags VkObjectEntryUsageFlagsNVX @extension("VK_NVX_device_generated_commands") bitfield VkObjectEntryUsageFlagBitsNVX { - VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001, - VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002, + VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001, + VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002, } - ////////////////// // Structures // ////////////////// @@ -2933,6 +2915,13 @@ class VkSwapchainImageCreateInfoANDROID { VkSwapchainImageUsageFlagsANDROID flags } +@extension("VK_ANDROID_native_buffer") +class VkPhysicalDevicePresentationPropertiesANDROID { + VkStructureType sType + void* pNext + VkBool32 sharedImage +} + @extension("VK_GOOGLE_display_timing") class VkRefreshCycleDurationGOOGLE { u64 minRefreshDuration @@ -3028,6 +3017,57 @@ class VkDedicatedAllocationMemoryAllocateInfoNV { VkBuffer buffer } +@extension("VK_NV_external_memory_capabilities") +class VkExternalImageFormatPropertiesNV { + VkImageFormatProperties imageFormatProperties + VkExternalMemoryFeatureFlagsNV externalMemoryFeatures + VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes + VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes +} + +@extension("VK_NV_external_memory") +class VkExternalMemoryImageCreateInfoNV { + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagsNV handleTypes +} + +@extension("VK_NV_external_memory") +class VkExportMemoryAllocateInfoNV { + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagsNV handleTypes +} + +@extension("VK_NV_external_memory_win32") +class VkImportMemoryWin32HandleInfoNV { + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagsNV handleType + platform.HANDLE handle +} + +@extension("VK_NV_external_memory_win32") +class VkExportMemoryWin32HandleInfoNV { + VkStructureType sType + const void* pNext + const platform.SECURITY_ATTRIBUTES* pAttributes + platform.DWORD dwAccess +} + +@extension("VK_NV_win32_keyed_mutex") +class VkWin32KeyedMutexAcquireReleaseInfoNV { + VkStructureType sType + const void* pNext + u32 acquireCount + const VkDeviceMemory* pAcquireSyncs + const u64* pAcquireKeys + const u32* pAcquireTimeoutMilliseconds + u32 releaseCount + const VkDeviceMemory* pReleaseSyncs + const u64* pReleaseKeys +} + @extension("VK_KHR_get_physical_device_properties2") class VkPhysicalDeviceFeatures2KHR { VkStructureType sType @@ -3099,78 +3139,6 @@ class VkPhysicalDeviceSparseImageFormatInfo2KHR { VkImageTiling tiling } -@extension("VK_KHR_incremental_present") -class VkRectLayerKHR { - VkOffset2D offset - VkExtent2D extent - u32 layer -} - -@extension("VK_KHR_incremental_present") -class VkPresentRegionKHR { - u32 rectangleCount - const VkRectLayerKHR* pRectangles -} - -@extension("VK_KHR_incremental_present") -class VkPresentRegionsKHR { - VkStructureType sType - const void* pNext - u32 swapchainCount - const VkPresentRegionKHR* pRegions -} - -@extension("VK_NV_external_memory_capabilities") -class VkExternalImageFormatPropertiesNV { - VkImageFormatProperties imageFormatProperties - VkExternalMemoryFeatureFlagsNV externalMemoryFeatures - VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes - VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes -} - -@extension("VK_NV_external_memory") -class VkExternalMemoryImageCreateInfoNV { - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagsNV handleTypes -} - -@extension("VK_NV_external_memory") -class VkExportMemoryAllocateInfoNV { - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagsNV handleTypes -} - -@extension("VK_NV_external_memory_win32") -class VkImportMemoryWin32HandleInfoNV { - VkStructureType sType - const void* pNext - VkExternalMemoryHandleTypeFlagsNV handleType - platform.HANDLE handle -} - -@extension("VK_NV_external_memory_win32") -class VkExportMemoryWin32HandleInfoNV { - VkStructureType sType - const void* pNext - const platform.SECURITY_ATTRIBUTES* pAttributes - u32 dwAccess -} - -@extension("VK_NV_win32_keyed_mutex") -class VkWin32KeyedMutexAcquireReleaseInfoNV { - VkStructureType sType - const void* pNext - u32 acquireCount - const VkDeviceMemory* pAcquireSyncs - const u64* pAcquireKeys - const u32* pAcquireTimeoutMilliseconds - u32 releaseCount - const VkDeviceMemory* pReleaseSyncs - const u64* pReleaseKeys -} - @extension("VK_EXT_validation_flags") class VkValidationFlagsEXT { VkStructureType sType @@ -3305,6 +3273,27 @@ class VkObjectTablePushConstantEntryNVX { VkShaderStageFlags stageFlags } +@extension("VK_KHR_incremental_present") +class VkRectLayerKHR { + VkOffset2D offset + VkExtent2D extent + u32 layer +} + +@extension("VK_KHR_incremental_present") +class VkPresentRegionKHR { + u32 rectangleCount + const VkRectLayerKHR* pRectangles +} + +@extension("VK_KHR_incremental_present") +class VkPresentRegionsKHR { + VkStructureType sType + const void* pNext + u32 swapchainCount + const VkPresentRegionKHR* pRegions +} + @extension("VK_EXT_hdr_metadata") class VkXYColorEXT { f32 x @@ -3323,8 +3312,6 @@ class VkHdrMetadataEXT { f32 maxFrameAverageLightLevel } - - //////////////// // Commands // //////////////// @@ -5997,6 +5984,50 @@ cmd void vkCmdDebugMarkerInsertEXT( VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { } +@extension("VK_AMD_draw_indirect_count") +cmd void vkCmdDrawIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + u32 maxDrawCount, + u32 stride) { +} + +@extension("VK_AMD_draw_indirect_count") +cmd void vkCmdDrawIndexedIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + u32 maxDrawCount, + u32 stride) { +} + +@extension("VK_NV_external_memory_capabilities") +cmd VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkExternalMemoryHandleTypeFlagsNV externalHandleType, + VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) { + return ? +} + +@extension("VK_NV_external_memory_win32") +cmd VkResult vkGetMemoryWin32HandleNV( + VkDevice device, + VkDeviceMemory memory, + VkExternalMemoryHandleTypeFlagsNV handleType, + platform.HANDLE* pHandle) { + return ? +} + @extension("VK_KHR_get_physical_device_properties2") cmd void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, @@ -6045,64 +6076,20 @@ cmd void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkSparseImageFormatProperties2KHR* pProperties) { } -@extension("VK_AMD_draw_indirect_count") -cmd void vkCmdDrawIndirectCountAMD( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - u32 maxDrawCount, - u32 stride) { -} - -@extension("VK_AMD_draw_indirect_count") -cmd void vkCmdDrawIndexedIndirectCountAMD( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - u32 maxDrawCount, - u32 stride) { -} - -@extension("VK_NV_external_memory_capabilities") -cmd VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageCreateFlags flags, - VkExternalMemoryHandleTypeFlagsNV externalHandleType, - VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) { - return ? -} - -@extension("VK_NV_external_memory_win32") -cmd VkResult vkGetMemoryWin32HandleNV( - VkDevice device, - VkDeviceMemory memory, - VkExternalMemoryHandleTypeFlagsNV handleType, - platform.HANDLE* pHandle) { - return ? -} - -@extension("VK_NV_external_memory_win32") -cmd void vkCmdProcessCommandsNVX( +@extension("VK_NVX_device_generated_commands") +cmd void vkCmdProcessCommandsNVX( VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) { } -@extension("VK_NV_external_memory_win32") -cmd void vkCmdReserveSpaceForCommandsNVX( +@extension("VK_NVX_device_generated_commands") +cmd void vkCmdReserveSpaceForCommandsNVX( VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) { } -@extension("VK_NV_external_memory_win32") -cmd VkResult vkCreateIndirectCommandsLayoutNVX( +@extension("VK_NVX_device_generated_commands") +cmd VkResult vkCreateIndirectCommandsLayoutNVX( VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, @@ -6110,15 +6097,15 @@ cmd VkResult vkCreateIndirectCommandsLayoutNVX( return ? } -@extension("VK_NV_external_memory_win32") -cmd void vkDestroyIndirectCommandsLayoutNVX( +@extension("VK_NVX_device_generated_commands") +cmd void vkDestroyIndirectCommandsLayoutNVX( VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) { } -@extension("VK_NV_external_memory_win32") -cmd VkResult vkCreateObjectTableNVX( +@extension("VK_NVX_device_generated_commands") +cmd VkResult vkCreateObjectTableNVX( VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, @@ -6126,15 +6113,15 @@ cmd VkResult vkCreateObjectTableNVX( return ? } -@extension("VK_NV_external_memory_win32") -cmd void vkDestroyObjectTableNVX( +@extension("VK_NVX_device_generated_commands") +cmd void vkDestroyObjectTableNVX( VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator) { } -@extension("VK_NV_external_memory_win32") -cmd VkResult vkRegisterObjectsNVX( +@extension("VK_NVX_device_generated_commands") +cmd VkResult vkRegisterObjectsNVX( VkDevice device, VkObjectTableNVX objectTable, u32 objectCount, @@ -6143,8 +6130,8 @@ cmd VkResult vkRegisterObjectsNVX( return ? } -@extension("VK_NV_external_memory_win32") -cmd VkResult vkUnregisterObjectsNVX( +@extension("VK_NVX_device_generated_commands") +cmd VkResult vkUnregisterObjectsNVX( VkDevice device, VkObjectTableNVX objectTable, u32 objectCount, @@ -6153,28 +6140,27 @@ cmd VkResult vkUnregisterObjectsNVX( return ? } -@extension("VK_NV_external_memory_win32") -cmd void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( +@extension("VK_NVX_device_generated_commands") +cmd void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits) { } -@extension("VK_KHR_shared_presentable_image") -cmd VkResult vkGetSwapchainStatusKHR( - VkDevice device, - VkSwapchainKHR swapchain) { - return ? -} - @extension("VK_EXT_hdr_metadata") -cmd void vkSetHdrMetadataEXT( +cmd void vkSetHdrMetadataEXT( VkDevice device, u32 swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) { } +@extension("VK_KHR_shared_presentable_image") +cmd VkResult vkGetSwapchainStatusKHR( + VkDevice device, + VkSwapchainKHR swapchain) { + return ? +} //////////////// // Validation // diff --git a/vulkan/include/vulkan/vk_android_native_buffer.h b/vulkan/include/vulkan/vk_android_native_buffer.h index d7c5a079e0..43a9a9c20d 100644 --- a/vulkan/include/vulkan/vk_android_native_buffer.h +++ b/vulkan/include/vulkan/vk_android_native_buffer.h @@ -37,12 +37,13 @@ extern "C" { * backwards-compatibility support is temporary, and will likely be removed in * (along with all gralloc0 support) in a future release. */ -#define VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION 6 +#define VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION 7 #define VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME "VK_ANDROID_native_buffer" #define VK_ANDROID_NATIVE_BUFFER_ENUM(type,id) ((type)(1000000000 + (1000 * (VK_ANDROID_NATIVE_BUFFER_EXTENSION_NUMBER - 1)) + (id))) #define VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 0) #define VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 1) +#define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 2) typedef enum VkSwapchainImageUsageFlagBitsANDROID { VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID = 0x00000001, @@ -75,6 +76,13 @@ typedef struct { VkSwapchainImageUsageFlagsANDROID usage; } VkSwapchainImageCreateInfoANDROID; +typedef struct { + VkStructureType sType; // must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID + const void* pNext; + + VkBool32 sharedImage; +} VkPhysicalDevicePresentationPropertiesANDROID; + // -- DEPRECATED in SPEC_VERSION 6 -- typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainGrallocUsageANDROID)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage); // -- ADDED in SPEC_VERSION 6 -- diff --git a/vulkan/include/vulkan/vk_platform.h b/vulkan/include/vulkan/vk_platform.h index 644be3611e..2054447cb1 100644 --- a/vulkan/include/vulkan/vk_platform.h +++ b/vulkan/include/vulkan/vk_platform.h @@ -53,7 +53,7 @@ extern "C" #define VKAPI_PTR VKAPI_CALL #elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7 #error "Vulkan isn't supported for the 'armeabi' NDK ABI" -#elif defined(__ANDROID__) && __ARM_ARCH >= 7 && __ARM_32BIT_STATE +#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE) // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat" // calling convention, i.e. float parameters are passed in registers. This // is true even if the rest of the application passes floats on the stack, diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h index 0980f24bcf..43dba6ed09 100644 --- a/vulkan/include/vulkan/vulkan.h +++ b/vulkan/include/vulkan/vulkan.h @@ -220,7 +220,6 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, - VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, @@ -236,6 +235,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008, VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, + VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000, VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001, VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002, @@ -3702,7 +3702,6 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR( #ifdef VK_USE_PLATFORM_ANDROID_KHR #define VK_KHR_android_surface 1 -struct ANativeWindow; #define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6 #define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface" @@ -4154,52 +4153,6 @@ typedef struct VkDedicatedAllocationMemoryAllocateInfoNV { } VkDedicatedAllocationMemoryAllocateInfoNV; -#define VK_GOOGLE_display_timing 1 -#define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1 -#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing" - -typedef struct VkRefreshCycleDurationGOOGLE { - uint64_t refreshDuration; -} VkRefreshCycleDurationGOOGLE; - -typedef struct VkPastPresentationTimingGOOGLE { - uint32_t presentID; - uint64_t desiredPresentTime; - uint64_t actualPresentTime; - uint64_t earliestPresentTime; - uint64_t presentMargin; -} VkPastPresentationTimingGOOGLE; - -typedef struct VkPresentTimeGOOGLE { - uint32_t presentID; - uint64_t desiredPresentTime; -} VkPresentTimeGOOGLE; - -typedef struct VkPresentTimesInfoGOOGLE { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const VkPresentTimeGOOGLE* pTimes; -} VkPresentTimesInfoGOOGLE; - - -typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE( - VkDevice device, - VkSwapchainKHR swapchain, - VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE( - VkDevice device, - VkSwapchainKHR swapchain, - uint32_t* pPresentationTimingCount, - VkPastPresentationTimingGOOGLE* pPresentationTimings); -#endif - - #define VK_AMD_draw_indirect_count 1 #define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 #define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count" @@ -4608,6 +4561,51 @@ VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( VkDeviceGeneratedCommandsLimitsNVX* pLimits); #endif +#define VK_GOOGLE_display_timing 1 +#define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1 +#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing" + +typedef struct VkRefreshCycleDurationGOOGLE { + uint64_t refreshDuration; +} VkRefreshCycleDurationGOOGLE; + +typedef struct VkPastPresentationTimingGOOGLE { + uint32_t presentID; + uint64_t desiredPresentTime; + uint64_t actualPresentTime; + uint64_t earliestPresentTime; + uint64_t presentMargin; +} VkPastPresentationTimingGOOGLE; + +typedef struct VkPresentTimeGOOGLE { + uint32_t presentID; + uint64_t desiredPresentTime; +} VkPresentTimeGOOGLE; + +typedef struct VkPresentTimesInfoGOOGLE { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentTimeGOOGLE* pTimes; +} VkPresentTimesInfoGOOGLE; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pPresentationTimingCount, + VkPastPresentationTimingGOOGLE* pPresentationTimings); +#endif + #define VK_EXT_hdr_metadata 1 #define VK_EXT_HDR_METADATA_SPEC_VERSION 0 #define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" diff --git a/vulkan/libvulkan/code-generator.tmpl b/vulkan/libvulkan/code-generator.tmpl index caf38bcb69..4835a56701 100644 --- a/vulkan/libvulkan/code-generator.tmpl +++ b/vulkan/libvulkan/code-generator.tmpl @@ -319,7 +319,7 @@ const ProcHook* GetProcHook(const char* name) { } ΒΆ ProcHook::Extension GetProcHookExtension(const char* name) { - {{$exts := Strings (Macro "driver.InterceptedExtensions") | SplitOn "\n"}} + {{$exts := Strings (Macro "driver.KnownExtensions") | SplitOn "\n"}} // clang-format off {{range $e := $exts}} if (strcmp(name, "{{$e}}") == 0) return ProcHook::{{TrimPrefix "VK_" $e}}; @@ -694,6 +694,17 @@ VK_KHR_shared_presentable_image {{/* ------------------------------------------------------------------------------ + Emits a list of extensions known to vulkan::driver. +------------------------------------------------------------------------------ +*/}} +{{define "driver.KnownExtensions"}} +{{Macro "driver.InterceptedExtensions"}} +VK_KHR_get_physical_device_properties2 +{{end}} + + +{{/* +------------------------------------------------------------------------------ Emits true if an extension is intercepted by vulkan::driver. ------------------------------------------------------------------------------ */}} @@ -776,7 +787,7 @@ VK_KHR_shared_presentable_image }; enum Extension { - {{$exts := Strings (Macro "driver.InterceptedExtensions") | SplitOn "\n"}} + {{$exts := Strings (Macro "driver.KnownExtensions") | SplitOn "\n"}} {{range $e := $exts}} {{TrimPrefix "VK_" $e}}, {{end}} @@ -965,7 +976,7 @@ VK_KHR_shared_presentable_image {{else if eq $.Name "vkDestroyImage"}}true {{else if eq $.Name "vkGetPhysicalDeviceProperties"}}true - + {{else if eq $.Name "vkGetPhysicalDeviceProperties2KHR"}}true {{end}} {{$ext := GetAnnotation $ "extension"}} @@ -1122,6 +1133,8 @@ VK_KHR_shared_presentable_image {{else if eq $ext "VK_KHR_wayland_surface"}}true {{else if eq $ext "VK_KHR_mir_surface"}}true {{else if eq $ext "VK_KHR_win32_surface"}}true + {{else if eq $ext "VK_NV_external_memory_win32"}}true + {{else if eq $ext "VK_NV_win32_keyed_mutex"}}true {{end}} {{end}} diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 71bfecfd56..76aa176fb7 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -29,6 +29,7 @@ #include <android/dlext.h> #include <cutils/properties.h> #include <ui/GraphicsEnv.h> +#include <utils/Vector.h> #include "driver.h" #include "stubhal.h" @@ -454,6 +455,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { hook_extensions_.set(ext_bit); break; case ProcHook::EXTENSION_UNKNOWN: + case ProcHook::KHR_get_physical_device_properties2: // HAL's extensions break; default: @@ -469,6 +471,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { break; case ProcHook::KHR_incremental_present: case ProcHook::GOOGLE_display_timing: + case ProcHook::KHR_shared_presentable_image: hook_extensions_.set(ext_bit); // return now as these extensions do not require HAL support return; @@ -478,9 +481,6 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::EXTENSION_UNKNOWN: // HAL's extensions break; - case ProcHook::KHR_shared_presentable_image: - // Exposed by HAL, but API surface is all in the loader - break; default: ALOGW("Ignored invalid device extension %s", name); return; @@ -498,10 +498,6 @@ void CreateInfoWrapper::FilterExtension(const char* name) { if (ext_bit == ProcHook::ANDROID_native_buffer) hook_extensions_.set(ProcHook::KHR_swapchain); - // Exposed by HAL, but API surface is all in the loader - if (ext_bit == ProcHook::KHR_shared_presentable_image) - hook_extensions_.set(ext_bit); - hal_extensions_.set(ext_bit); } @@ -734,21 +730,63 @@ VkResult EnumerateInstanceExtensionProperties( return result; } +bool QueryPresentationProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDevicePresentationPropertiesANDROID *presentation_properties) +{ + const InstanceData& data = GetData(physicalDevice); + + // GPDP2 must be present and enabled on the instance. + if (!data.driver.GetPhysicalDeviceProperties2KHR) + return false; + + // Request the android-specific presentation properties via GPDP2 + VkPhysicalDeviceProperties2KHR properties = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, + presentation_properties, + {} + }; + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wold-style-cast" + presentation_properties->sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID; +#pragma clang diagnostic pop + presentation_properties->pNext = nullptr; + presentation_properties->sharedImage = VK_FALSE; + + data.driver.GetPhysicalDeviceProperties2KHR(physicalDevice, + &properties); + + return true; +} + VkResult EnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) { const InstanceData& data = GetData(physicalDevice); - static const std::array<VkExtensionProperties, 3> loader_extensions = {{ - // WSI extensions - {VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, - VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION}, - {VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, - VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION}, - {VK_EXT_HDR_METADATA_EXTENSION_NAME, - VK_EXT_HDR_METADATA_SPEC_VERSION}, - }}; + // extensions that are unconditionally exposed by the loader + android::Vector<VkExtensionProperties> loader_extensions; + loader_extensions.push_back({ + VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, + VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION}); + loader_extensions.push_back({ + VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, + VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION}); + loader_extensions.push_back({ + VK_EXT_HDR_METADATA_EXTENSION_NAME, + VK_EXT_HDR_METADATA_SPEC_VERSION}); + + // conditionally add shared_presentable_image if supportable + VkPhysicalDevicePresentationPropertiesANDROID presentation_properties; + if (QueryPresentationProperties(physicalDevice, &presentation_properties) && + presentation_properties.sharedImage) { + loader_extensions.push_back({ + VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME, + VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION}); + } // enumerate our extensions first if (!pLayerName && pProperties) { diff --git a/vulkan/libvulkan/driver.h b/vulkan/libvulkan/driver.h index 5383f59b58..7f8ae98b02 100644 --- a/vulkan/libvulkan/driver.h +++ b/vulkan/libvulkan/driver.h @@ -109,6 +109,10 @@ bool Debuggable(); bool OpenHAL(); const VkAllocationCallbacks& GetDefaultAllocator(); +bool QueryPresentationProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDevicePresentationPropertiesANDROID *presentation_properties); + // clang-format off VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName); VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName); diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index 59964fb2c9..c4cb5440a9 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -93,6 +93,14 @@ VKAPI_ATTR VkResult checkedGetPastPresentationTimingGOOGLE(VkDevice device, VkSw } } +VKAPI_ATTR void checkedSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) { + if (GetData(device).hook_extensions[ProcHook::EXT_hdr_metadata]) { + SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); + } else { + Logger(device).Err(device, "VK_EXT_hdr_metadata not enabled. vkSetHdrMetadataEXT not executed."); + } +} + VKAPI_ATTR VkResult checkedGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) { if (GetData(device).hook_extensions[ProcHook::KHR_shared_presentable_image]) { return GetSwapchainStatusKHR(device, swapchain); @@ -102,14 +110,6 @@ VKAPI_ATTR VkResult checkedGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR } } -VKAPI_ATTR void checkedSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) { - if (GetData(device).hook_extensions[ProcHook::EXT_hdr_metadata]) { - SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); - } else { - Logger(device).Err(device, "VK_EXT_hdr_metadata not enabled. vkSetHdrMetadataEXT not executed."); - } -} - // clang-format on const ProcHook g_proc_hooks[] = { @@ -371,6 +371,7 @@ ProcHook::Extension GetProcHookExtension(const char* name) { if (strcmp(name, "VK_KHR_surface") == 0) return ProcHook::KHR_surface; if (strcmp(name, "VK_KHR_swapchain") == 0) return ProcHook::KHR_swapchain; if (strcmp(name, "VK_KHR_shared_presentable_image") == 0) return ProcHook::KHR_shared_presentable_image; + if (strcmp(name, "VK_KHR_get_physical_device_properties2") == 0) return ProcHook::KHR_get_physical_device_properties2; // clang-format on return ProcHook::EXTENSION_UNKNOWN; } @@ -409,6 +410,7 @@ bool InitDriverTable(VkInstance instance, INIT_PROC_EXT(EXT_debug_report, true, instance, CreateDebugReportCallbackEXT); INIT_PROC_EXT(EXT_debug_report, true, instance, DestroyDebugReportCallbackEXT); INIT_PROC_EXT(EXT_debug_report, true, instance, DebugReportMessageEXT); + INIT_PROC_EXT(KHR_get_physical_device_properties2, true, instance, GetPhysicalDeviceProperties2KHR); // clang-format on return success; diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index 273e796d84..c9dba788ea 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -42,6 +42,7 @@ struct ProcHook { KHR_surface, KHR_swapchain, KHR_shared_presentable_image, + KHR_get_physical_device_properties2, EXTENSION_CORE, // valid bit EXTENSION_COUNT, @@ -67,6 +68,7 @@ struct InstanceDriverTable { PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT; PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallbackEXT; PFN_vkDebugReportMessageEXT DebugReportMessageEXT; + PFN_vkGetPhysicalDeviceProperties2KHR GetPhysicalDeviceProperties2KHR; // clang-format on }; diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index b1e3d61cf1..e105922be2 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -542,26 +542,32 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice /*pdev*/, } VKAPI_ATTR -VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice /*pdev*/, +VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev, VkSurfaceKHR /*surface*/, uint32_t* count, VkPresentModeKHR* modes) { - const VkPresentModeKHR kModes[] = { - VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR, - // TODO(chrisforbes): should only expose this if the driver can. - // VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR, - // VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR, - }; - const uint32_t kNumModes = sizeof(kModes) / sizeof(kModes[0]); + android::Vector<VkPresentModeKHR> present_modes; + present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); + present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); + + VkPhysicalDevicePresentationPropertiesANDROID present_properties; + if (QueryPresentationProperties(pdev, &present_properties)) { + if (present_properties.sharedImage) { + present_modes.push_back(VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR); + present_modes.push_back(VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR); + } + } + + uint32_t num_modes = uint32_t(present_modes.size()); VkResult result = VK_SUCCESS; if (modes) { - if (*count < kNumModes) + if (*count < num_modes) result = VK_INCOMPLETE; - *count = std::min(*count, kNumModes); - std::copy(kModes, kModes + *count, modes); + *count = std::min(*count, num_modes); + std::copy(present_modes.begin(), present_modes.begin() + int(*count), modes); } else { - *count = kNumModes; + *count = num_modes; } return result; } @@ -798,7 +804,8 @@ VkResult CreateSwapchainKHR(VkDevice device, int gralloc_usage = 0; if (dispatch.GetSwapchainGrallocUsage2ANDROID) { uint64_t consumer_usage, producer_usage; - if (GetData(device).driver_version == 256587285) { + uint32_t driver_version = GetData(device).driver_version; + if (driver_version == 256587285 || driver_version == 96011958) { // HACK workaround for loader/driver mismatch during transition to // vkGetSwapchainGrallocUsage2ANDROID. typedef VkResult(VKAPI_PTR * |