Merge "Expose extension for obtaining an EGLClientBuffer from an AHardwareBuffer"
diff --git a/cmds/dumpstate/dumpstate.cpp b/cmds/dumpstate/dumpstate.cpp
index b323624..e33f099 100644
--- a/cmds/dumpstate/dumpstate.cpp
+++ b/cmds/dumpstate/dumpstate.cpp
@@ -1344,7 +1344,8 @@
// TODO: explicity setting Shell's component to allow broadcast to launch it.
// That might break other components that are listening to the bugreport notifications
- // (android.intent.action.BUGREPORT_STARTED and android.intent.action.BUGREPORT_STOPED), but
+ // (com.android.internal.intent.action.BUGREPORT_STARTED and
+ // com.android.internal.intent.action.BUGREPORT_STOPED), but
// those should be just handled by Shell anyways.
// A more generic alternative would be passing the -f 0x01000000 flag (or whatever
// value is defined by FLAG_RECEIVER_INCLUDE_BACKGROUND), but that would reset the
@@ -1600,7 +1601,7 @@
"--ei", "android.intent.extra.MAX", std::to_string(ds.progress_->GetMax()),
};
// clang-format on
- SendShellBroadcast("android.intent.action.BUGREPORT_STARTED", am_args);
+ SendShellBroadcast("com.android.internal.intent.action.BUGREPORT_STARTED", am_args);
}
if (use_control_socket) {
dprintf(ds.control_socket_fd_, "BEGIN:%s\n", ds.path_.c_str());
@@ -1825,9 +1826,10 @@
am_args.push_back("--es");
am_args.push_back("android.intent.extra.REMOTE_BUGREPORT_HASH");
am_args.push_back(SHA256_file_hash(ds.path_));
- SendShellBroadcast("android.intent.action.REMOTE_BUGREPORT_FINISHED", am_args);
+ SendShellBroadcast("com.android.internal.intent.action.REMOTE_BUGREPORT_FINISHED",
+ am_args);
} else {
- SendShellBroadcast("android.intent.action.BUGREPORT_FINISHED", am_args);
+ SendShellBroadcast("com.android.internal.intent.action.BUGREPORT_FINISHED", am_args);
}
} else {
MYLOGE("Skipping finished broadcast because bugreport could not be generated\n");
diff --git a/cmds/installd/dexopt.cpp b/cmds/installd/dexopt.cpp
index aa32d6b..0fb207b 100644
--- a/cmds/installd/dexopt.cpp
+++ b/cmds/installd/dexopt.cpp
@@ -854,13 +854,16 @@
return open(file_name, flags, permissions);
}
-static bool set_permissions_and_ownership(int fd, bool is_public, int uid, const char* path) {
+static bool set_permissions_and_ownership(
+ int fd, bool is_public, int uid, const char* path, bool is_secondary_dex) {
+ // Primary apks are owned by the system. Secondary dex files are owned by the app.
+ int owning_uid = is_secondary_dex ? uid : AID_SYSTEM;
if (fchmod(fd,
S_IRUSR|S_IWUSR|S_IRGRP |
(is_public ? S_IROTH : 0)) < 0) {
ALOGE("installd cannot chmod '%s' during dexopt\n", path);
return false;
- } else if (fchown(fd, AID_SYSTEM, uid) < 0) {
+ } else if (fchown(fd, owning_uid, uid) < 0) {
ALOGE("installd cannot chown '%s' during dexopt\n", path);
return false;
}
@@ -1009,10 +1012,11 @@
// (re)Creates the app image if needed.
Dex2oatFileWrapper maybe_open_app_image(const char* out_oat_path, bool profile_guided,
- bool is_public, int uid) {
+ bool is_public, int uid, bool is_secondary_dex) {
// Use app images only if it is enabled (by a set image format) and we are compiling
// profile-guided (so the app image doesn't conservatively contain all classes).
- if (!profile_guided) {
+ // Note that we don't create an image for secondary dex files.
+ if (is_secondary_dex || !profile_guided) {
return Dex2oatFileWrapper();
}
@@ -1043,7 +1047,7 @@
}
}
} else if (!set_permissions_and_ownership(
- wrapper_fd.get(), is_public, uid, image_path.c_str())) {
+ wrapper_fd.get(), is_public, uid, image_path.c_str(), is_secondary_dex)) {
ALOGE("installd cannot set owner '%s' for image during dexopt\n", image_path.c_str());
wrapper_fd.reset(-1);
}
@@ -1101,7 +1105,7 @@
// Opens the vdex files and assigns the input fd to in_vdex_wrapper_fd and the output fd to
// out_vdex_wrapper_fd. Returns true for success or false in case of errors.
bool open_vdex_files(const char* apk_path, const char* out_oat_path, int dexopt_needed,
- const char* instruction_set, bool is_public, int uid,
+ const char* instruction_set, bool is_public, int uid, bool is_secondary_dex,
Dex2oatFileWrapper* in_vdex_wrapper_fd,
Dex2oatFileWrapper* out_vdex_wrapper_fd) {
CHECK(in_vdex_wrapper_fd != nullptr);
@@ -1164,7 +1168,7 @@
}
}
if (!set_permissions_and_ownership(out_vdex_wrapper_fd->get(), is_public, uid,
- out_vdex_path_str.c_str())) {
+ out_vdex_path_str.c_str(), is_secondary_dex)) {
ALOGE("installd cannot set owner '%s' for vdex during dexopt\n", out_vdex_path_str.c_str());
return false;
}
@@ -1187,7 +1191,8 @@
[out_oat_path_str]() { unlink(out_oat_path_str.c_str()); });
if (wrapper_fd.get() < 0) {
PLOG(ERROR) << "installd cannot open output during dexopt" << out_oat_path;
- } else if (!set_permissions_and_ownership(wrapper_fd.get(), is_public, uid, out_oat_path)) {
+ } else if (!set_permissions_and_ownership(
+ wrapper_fd.get(), is_public, uid, out_oat_path, is_secondary_dex)) {
ALOGE("installd cannot set owner '%s' for output during dexopt\n", out_oat_path);
wrapper_fd.reset(-1);
}
@@ -1445,7 +1450,7 @@
Dex2oatFileWrapper in_vdex_fd;
Dex2oatFileWrapper out_vdex_fd;
if (!open_vdex_files(dex_path, out_oat_path, dexopt_needed, instruction_set, is_public, uid,
- &in_vdex_fd, &out_vdex_fd)) {
+ is_secondary_dex, &in_vdex_fd, &out_vdex_fd)) {
return -1;
}
@@ -1454,7 +1459,7 @@
// Create the app image file if needed.
Dex2oatFileWrapper image_fd =
- maybe_open_app_image(out_oat_path, profile_guided, is_public, uid);
+ maybe_open_app_image(out_oat_path, profile_guided, is_public, uid, is_secondary_dex);
// Open the reference profile if needed.
Dex2oatFileWrapper reference_profile_fd =
diff --git a/cmds/lshal/Android.bp b/cmds/lshal/Android.bp
index c380598..5aab35a 100644
--- a/cmds/lshal/Android.bp
+++ b/cmds/lshal/Android.bp
@@ -22,6 +22,6 @@
"libhidltransport",
],
srcs: [
- "lshal.cpp"
+ "Lshal.cpp"
],
}
diff --git a/cmds/lshal/Lshal.cpp b/cmds/lshal/Lshal.cpp
new file mode 100644
index 0000000..ce058c8
--- /dev/null
+++ b/cmds/lshal/Lshal.cpp
@@ -0,0 +1,477 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Lshal.h"
+
+#include <getopt.h>
+
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <map>
+#include <sstream>
+#include <regex>
+
+#include <android-base/parseint.h>
+#include <android/hidl/manager/1.0/IServiceManager.h>
+#include <hidl/ServiceManagement.h>
+
+#include "Timeout.h"
+
+using ::android::hardware::hidl_string;
+using ::android::hidl::manager::V1_0::IServiceManager;
+
+namespace android {
+namespace lshal {
+
+template <typename A>
+std::string join(const A &components, const std::string &separator) {
+ std::stringstream out;
+ bool first = true;
+ for (const auto &component : components) {
+ if (!first) {
+ out << separator;
+ }
+ out << component;
+
+ first = false;
+ }
+ return out.str();
+}
+
+static std::string toHexString(uint64_t t) {
+ std::ostringstream os;
+ os << std::hex << std::setfill('0') << std::setw(16) << t;
+ return os.str();
+}
+
+static std::pair<hidl_string, hidl_string> split(const hidl_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)};
+}
+
+static std::vector<std::string> split(const std::string &s, char c) {
+ std::vector<std::string> components{};
+ size_t startPos = 0;
+ size_t matchPos;
+ while ((matchPos = s.find(c, startPos)) != std::string::npos) {
+ components.push_back(s.substr(startPos, matchPos - startPos));
+ startPos = matchPos + 1;
+ }
+
+ if (startPos <= s.length()) {
+ components.push_back(s.substr(startPos));
+ }
+ return components;
+}
+
+std::string getCmdline(pid_t pid) {
+ std::ifstream ifs("/proc/" + std::to_string(pid) + "/cmdline");
+ std::string cmdline;
+ if (!ifs.is_open()) {
+ return "";
+ }
+ ifs >> cmdline;
+ return cmdline;
+}
+
+const std::string &Lshal::getCmdline(pid_t pid) {
+ auto pair = mCmdlines.find(pid);
+ if (pair != mCmdlines.end()) {
+ return pair->second;
+ }
+ mCmdlines[pid] = ::android::lshal::getCmdline(pid);
+ return mCmdlines[pid];
+}
+
+void Lshal::removeDeadProcesses(Pids *pids) {
+ static const pid_t myPid = getpid();
+ std::remove_if(pids->begin(), pids->end(), [this](auto pid) {
+ return pid == myPid || this->getCmdline(pid).empty();
+ });
+}
+
+bool Lshal::getReferencedPids(
+ pid_t serverPid, std::map<uint64_t, Pids> *objects) const {
+
+ std::ifstream ifs("/d/binder/proc/" + std::to_string(serverPid));
+ if (!ifs.is_open()) {
+ return false;
+ }
+
+ static const std::regex prefix("^\\s*node \\d+:\\s+u([0-9a-f]+)\\s+c([0-9a-f]+)\\s+");
+
+ std::string line;
+ std::smatch match;
+ while(getline(ifs, line)) {
+ if (!std::regex_search(line, match, prefix)) {
+ // the line doesn't start with the correct prefix
+ continue;
+ }
+ std::string ptrString = "0x" + match.str(2); // use number after c
+ uint64_t ptr;
+ if (!::android::base::ParseUint(ptrString.c_str(), &ptr)) {
+ // Should not reach here, but just be tolerant.
+ mErr << "Could not parse number " << ptrString << std::endl;
+ continue;
+ }
+ const std::string proc = " proc ";
+ auto pos = line.rfind(proc);
+ if (pos != std::string::npos) {
+ for (const std::string &pidStr : split(line.substr(pos + proc.size()), ' ')) {
+ int32_t pid;
+ if (!::android::base::ParseInt(pidStr, &pid)) {
+ mErr << "Could not parse number " << pidStr << std::endl;
+ continue;
+ }
+ (*objects)[ptr].push_back(pid);
+ }
+ }
+ }
+ return true;
+}
+
+void Lshal::postprocess() {
+ if (mSortColumn) {
+ std::sort(mTable.begin(), mTable.end(), mSortColumn);
+ }
+ for (TableEntry &entry : mTable) {
+ entry.serverCmdline = getCmdline(entry.serverPid);
+ removeDeadProcesses(&entry.clientPids);
+ for (auto pid : entry.clientPids) {
+ entry.clientCmdlines.push_back(this->getCmdline(pid));
+ }
+ }
+}
+
+void Lshal::printLine(
+ const std::string &interfaceName,
+ const std::string &transport, const std::string &server,
+ const std::string &serverCmdline,
+ const std::string &address, const std::string &clients,
+ const std::string &clientCmdlines) const {
+ if (mSelectedColumns & ENABLE_INTERFACE_NAME)
+ mOut << std::setw(80) << interfaceName << "\t";
+ if (mSelectedColumns & ENABLE_TRANSPORT)
+ mOut << std::setw(10) << transport << "\t";
+ if (mSelectedColumns & ENABLE_SERVER_PID) {
+ if (mEnableCmdlines) {
+ mOut << std::setw(15) << serverCmdline << "\t";
+ } else {
+ mOut << std::setw(5) << server << "\t";
+ }
+ }
+ if (mSelectedColumns & ENABLE_SERVER_ADDR)
+ mOut << std::setw(16) << address << "\t";
+ if (mSelectedColumns & ENABLE_CLIENT_PIDS) {
+ if (mEnableCmdlines) {
+ mOut << std::setw(0) << clientCmdlines;
+ } else {
+ mOut << std::setw(0) << clients;
+ }
+ }
+ mOut << std::endl;
+}
+
+void Lshal::dump() const {
+ mOut << "All services:" << std::endl;
+ mOut << std::left;
+ printLine("Interface", "Transport", "Server", "Server CMD", "PTR", "Clients", "Clients CMD");
+ for (const auto &entry : mTable) {
+ printLine(entry.interfaceName,
+ entry.transport,
+ entry.serverPid == NO_PID ? "N/A" : std::to_string(entry.serverPid),
+ entry.serverCmdline,
+ entry.serverObjectAddress == NO_PTR ? "N/A" : toHexString(entry.serverObjectAddress),
+ join(entry.clientPids, " "),
+ join(entry.clientCmdlines, ";"));
+ }
+}
+
+void Lshal::putEntry(TableEntry &&entry) {
+ mTable.push_back(std::forward<TableEntry>(entry));
+}
+
+Status Lshal::fetchAllLibraries(const sp<IServiceManager> &manager) {
+ using namespace ::android::hardware;
+ using namespace ::android::hidl::manager::V1_0;
+ using namespace ::android::hidl::base::V1_0;
+ auto ret = timeoutIPC(manager, &IServiceManager::list, [&] (const auto &fqInstanceNames) {
+ for (const auto &fqInstanceName : fqInstanceNames) {
+ putEntry({
+ .interfaceName = fqInstanceName,
+ .transport = "passthrough",
+ .serverPid = NO_PID,
+ .serverObjectAddress = NO_PTR,
+ .clientPids = {}
+ });
+ }
+ });
+ if (!ret.isOk()) {
+ mErr << "Error: Failed to call list on getPassthroughServiceManager(): "
+ << ret.description() << std::endl;
+ return DUMP_ALL_LIBS_ERROR;
+ }
+ return OK;
+}
+
+Status Lshal::fetchPassthrough(const sp<IServiceManager> &manager) {
+ using namespace ::android::hardware;
+ using namespace ::android::hidl::manager::V1_0;
+ using namespace ::android::hidl::base::V1_0;
+ auto ret = timeoutIPC(manager, &IServiceManager::debugDump, [&] (const auto &infos) {
+ for (const auto &info : infos) {
+ putEntry({
+ .interfaceName =
+ std::string{info.interfaceName.c_str()} + "/" +
+ std::string{info.instanceName.c_str()},
+ .transport = "passthrough",
+ .serverPid = info.clientPids.size() == 1 ? info.clientPids[0] : NO_PID,
+ .serverObjectAddress = NO_PTR,
+ .clientPids = info.clientPids
+ });
+ }
+ });
+ if (!ret.isOk()) {
+ mErr << "Error: Failed to call debugDump on defaultServiceManager(): "
+ << ret.description() << std::endl;
+ return DUMP_PASSTHROUGH_ERROR;
+ }
+ return OK;
+}
+
+Status Lshal::fetchBinderized(const sp<IServiceManager> &manager) {
+ using namespace ::std;
+ using namespace ::android::hardware;
+ using namespace ::android::hidl::manager::V1_0;
+ using namespace ::android::hidl::base::V1_0;
+ const std::string mode = "hwbinder";
+ 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;
+ }
+ }
+ 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 = NO_PID,
+ .serverObjectAddress = NO_PTR,
+ .clientPids = {}
+ });
+ continue;
+ }
+ 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]
+ });
+ }
+
+ });
+ if (!listRet.isOk()) {
+ mErr << "Error: Failed to list services for " << mode << ": "
+ << listRet.description() << std::endl;
+ status |= DUMP_BINDERIZED_ERROR;
+ }
+ return status;
+}
+
+Status Lshal::fetch() {
+ Status status = OK;
+ auto bManager = ::android::hardware::defaultServiceManager();
+ if (bManager == nullptr) {
+ mErr << "Failed to get defaultServiceManager()!" << std::endl;
+ status |= NO_BINDERIZED_MANAGER;
+ } else {
+ status |= fetchBinderized(bManager);
+ // Passthrough PIDs are registered to the binderized manager as well.
+ status |= fetchPassthrough(bManager);
+ }
+
+ auto pManager = ::android::hardware::getPassthroughServiceManager();
+ if (pManager == nullptr) {
+ mErr << "Failed to get getPassthroughServiceManager()!" << std::endl;
+ status |= NO_PASSTHROUGH_MANAGER;
+ } else {
+ status |= fetchAllLibraries(pManager);
+ }
+ return status;
+}
+
+void Lshal::usage() const {
+ mErr
+ << "usage: lshal" << std::endl
+ << " 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
+ << " -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
+ << " -p, --pid: print the server PID, or server cmdline if -m is set" << std::endl
+ << " -a, --address: print the server object address column" << std::endl
+ << " -c, --clients: print the client PIDs, or client cmdlines if -m is set"
+ << std::endl
+ << " -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
+ << " lshal [-h|--help]" << std::endl
+ << " -h, --help: show this help information." << std::endl;
+}
+
+Status Lshal::parseArgs(int argc, char **argv) {
+ static struct option longOptions[] = {
+ // long options with short alternatives
+ {"help", no_argument, 0, 'h' },
+ {"interface", no_argument, 0, 'i' },
+ {"transport", no_argument, 0, 't' },
+ {"pid", no_argument, 0, 'p' },
+ {"address", no_argument, 0, 'a' },
+ {"clients", no_argument, 0, 'c' },
+ {"cmdline", no_argument, 0, 'm' },
+
+ // long options without short alternatives
+ {"sort", required_argument, 0, 's' },
+ { 0, 0, 0, 0 }
+ };
+
+ int optionIndex;
+ int c;
+ optind = 1;
+ for (;;) {
+ // using getopt_long in case we want to add other options in the future
+ c = getopt_long(argc, argv, "hitpacm", longOptions, &optionIndex);
+ if (c == -1) {
+ break;
+ }
+ switch (c) {
+ case 's': {
+ if (strcmp(optarg, "interface") == 0 || strcmp(optarg, "i") == 0) {
+ mSortColumn = TableEntry::sortByInterfaceName;
+ } else if (strcmp(optarg, "pid") == 0 || strcmp(optarg, "p") == 0) {
+ mSortColumn = TableEntry::sortByServerPid;
+ } else {
+ mErr << "Unrecognized sorting column: " << optarg << std::endl;
+ usage();
+ return USAGE;
+ }
+ break;
+ }
+ case 'i': {
+ mSelectedColumns |= ENABLE_INTERFACE_NAME;
+ break;
+ }
+ case 't': {
+ mSelectedColumns |= ENABLE_TRANSPORT;
+ break;
+ }
+ case 'p': {
+ mSelectedColumns |= ENABLE_SERVER_PID;
+ break;
+ }
+ case 'a': {
+ mSelectedColumns |= ENABLE_SERVER_ADDR;
+ break;
+ }
+ case 'c': {
+ mSelectedColumns |= ENABLE_CLIENT_PIDS;
+ break;
+ }
+ case 'm': {
+ mEnableCmdlines = true;
+ break;
+ }
+ case 'h': // falls through
+ default: // see unrecognized options
+ usage();
+ return USAGE;
+ }
+ }
+
+ if (mSelectedColumns == 0) {
+ mSelectedColumns = ENABLE_INTERFACE_NAME
+ | ENABLE_TRANSPORT | ENABLE_SERVER_PID | ENABLE_CLIENT_PIDS;
+ }
+ return OK;
+}
+
+int Lshal::main(int argc, char **argv) {
+ Status status = parseArgs(argc, argv);
+ if (status != OK) {
+ return status;
+ }
+ status = fetch();
+ postprocess();
+ dump();
+ return status;
+}
+
+} // namespace lshal
+} // namespace android
+
+int main(int argc, char **argv) {
+ return ::android::lshal::Lshal{}.main(argc, argv);
+}
diff --git a/cmds/lshal/Lshal.h b/cmds/lshal/Lshal.h
new file mode 100644
index 0000000..ead99dc
--- /dev/null
+++ b/cmds/lshal/Lshal.h
@@ -0,0 +1,89 @@
+/*
+ * 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_LSHAL_H_
+#define FRAMEWORK_NATIVE_CMDS_LSHAL_LSHAL_H_
+
+#include <stdint.h>
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include <android/hidl/manager/1.0/IServiceManager.h>
+
+#include "TableEntry.h"
+
+namespace android {
+namespace lshal {
+
+enum : unsigned int {
+ OK = 0,
+ USAGE = 1 << 0,
+ NO_BINDERIZED_MANAGER = 1 << 1,
+ NO_PASSTHROUGH_MANAGER = 1 << 2,
+ DUMP_BINDERIZED_ERROR = 1 << 3,
+ DUMP_PASSTHROUGH_ERROR = 1 << 4,
+ DUMP_ALL_LIBS_ERROR = 1 << 5,
+};
+using Status = unsigned int;
+
+class Lshal {
+public:
+ int main(int argc, char **argv);
+
+private:
+ Status parseArgs(int argc, char **argv);
+ Status fetch();
+ void postprocess();
+ void dump() const;
+ void usage() const;
+ void putEntry(TableEntry &&entry);
+ Status fetchPassthrough(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager);
+ Status fetchBinderized(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager);
+ Status fetchAllLibraries(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager);
+ bool getReferencedPids(
+ pid_t serverPid, std::map<uint64_t, Pids> *objects) const;
+ void printLine(
+ const std::string &interfaceName,
+ const std::string &transport, const std::string &server,
+ const std::string &serverCmdline,
+ const std::string &address, const std::string &clients,
+ const std::string &clientCmdlines) const ;
+ // Return /proc/{pid}/cmdline if it exists, else empty string.
+ const std::string &getCmdline(pid_t pid);
+ // Call getCmdline on all pid in pids. If it returns empty string, the process might
+ // have died, and the pid is removed from pids.
+ void removeDeadProcesses(Pids *pids);
+
+ Table mTable{};
+ std::ostream &mErr = std::cerr;
+ std::ostream &mOut = std::cout;
+ TableEntryCompare mSortColumn = nullptr;
+ TableEntrySelect mSelectedColumns = 0;
+ // If true, cmdlines will be printed instead of pid.
+ bool mEnableCmdlines;
+ // 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.
+ std::map<pid_t, std::string> mCmdlines;
+};
+
+
+} // namespace lshal
+} // namespace android
+
+#endif // FRAMEWORK_NATIVE_CMDS_LSHAL_LSHAL_H_
diff --git a/cmds/lshal/TableEntry.h b/cmds/lshal/TableEntry.h
new file mode 100644
index 0000000..4ec3a0c
--- /dev/null
+++ b/cmds/lshal/TableEntry.h
@@ -0,0 +1,69 @@
+/*
+ * 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_TABLE_ENTRY_H_
+#define FRAMEWORK_NATIVE_CMDS_LSHAL_TABLE_ENTRY_H_
+
+#include <stdint.h>
+
+#include <string>
+#include <vector>
+#include <iostream>
+
+namespace android {
+namespace lshal {
+
+using Pids = std::vector<int32_t>;
+
+struct TableEntry {
+ std::string interfaceName;
+ std::string transport;
+ int32_t serverPid;
+ std::string serverCmdline;
+ uint64_t serverObjectAddress;
+ Pids clientPids;
+ std::vector<std::string> clientCmdlines;
+
+ static bool sortByInterfaceName(const TableEntry &a, const TableEntry &b) {
+ return a.interfaceName < b.interfaceName;
+ };
+ static bool sortByServerPid(const TableEntry &a, const TableEntry &b) {
+ return a.serverPid < b.serverPid;
+ };
+};
+
+using Table = std::vector<TableEntry>;
+using TableEntryCompare = std::function<bool(const TableEntry &, const TableEntry &)>;
+
+enum : unsigned int {
+ ENABLE_INTERFACE_NAME = 1 << 0,
+ ENABLE_TRANSPORT = 1 << 1,
+ ENABLE_SERVER_PID = 1 << 2,
+ ENABLE_SERVER_ADDR = 1 << 3,
+ ENABLE_CLIENT_PIDS = 1 << 4
+};
+
+using TableEntrySelect = unsigned int;
+
+enum {
+ NO_PID = -1,
+ NO_PTR = 0
+};
+
+} // namespace lshal
+} // namespace android
+
+#endif // FRAMEWORK_NATIVE_CMDS_LSHAL_TABLE_ENTRY_H_
diff --git a/cmds/lshal/Timeout.h b/cmds/lshal/Timeout.h
new file mode 100644
index 0000000..bf883c0
--- /dev/null
+++ b/cmds/lshal/Timeout.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <condition_variable>
+#include <chrono>
+#include <functional>
+#include <mutex>
+#include <thread>
+
+#include <hidl/Status.h>
+
+namespace android {
+namespace lshal {
+
+static constexpr std::chrono::milliseconds IPC_CALL_WAIT{500};
+
+class BackgroundTaskState {
+public:
+ BackgroundTaskState(){}
+ void notify() {
+ std::unique_lock<std::mutex> lock(mMutex);
+ mFinished = true;
+ lock.unlock();
+ mCondVar.notify_all();
+ }
+ template<class C, class D>
+ bool wait(std::chrono::time_point<C, D> end) {
+ std::unique_lock<std::mutex> lock(mMutex);
+ mCondVar.wait_until(lock, end, [this](){ return this->mFinished; });
+ return mFinished;
+ }
+private:
+ std::mutex mMutex;
+ std::condition_variable mCondVar;
+ bool mFinished = false;
+};
+
+template<class R, class P>
+bool timeout(std::chrono::duration<R, P> delay, const std::function<void(void)> &func) {
+ auto now = std::chrono::system_clock::now();
+ BackgroundTaskState state{};
+ std::thread t([&state, &func] {
+ func();
+ state.notify();
+ });
+ t.detach();
+ bool success = state.wait(now + delay);
+ return success;
+}
+
+template<class Function, class I, class... Args>
+typename std::result_of<Function(I *, Args...)>::type
+timeoutIPC(const sp<I> &interfaceObject, Function &&func, Args &&... args) {
+ using ::android::hardware::Status;
+ typename std::result_of<Function(I *, Args...)>::type ret{Status::ok()};
+ auto boundFunc = std::bind(std::forward<Function>(func),
+ interfaceObject.get(), std::forward<Args>(args)...);
+ bool success = timeout(IPC_CALL_WAIT, [&ret, &boundFunc] {
+ ret = boundFunc();
+ });
+ if (!success) {
+ return Status::fromStatusT(TIMED_OUT);
+ }
+ return ret;
+}
+
+} // namespace lshal
+} // namespace android
diff --git a/cmds/lshal/lshal.cpp b/cmds/lshal/lshal.cpp
deleted file mode 100644
index 9998a46..0000000
--- a/cmds/lshal/lshal.cpp
+++ /dev/null
@@ -1,306 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-#include <getopt.h>
-
-#include <map>
-#include <fstream>
-#include <iomanip>
-#include <iostream>
-#include <sstream>
-#include <regex>
-
-#include <android-base/parseint.h>
-#include <android/hidl/manager/1.0/IServiceManager.h>
-#include <hidl/ServiceManagement.h>
-
-using ::android::sp;
-using ::android::hardware::hidl_string;
-using ::android::hidl::manager::V1_0::IServiceManager;
-
-template <typename A, typename B, typename C, typename D, typename E, typename F>
-void printColumn(std::stringstream &stream,
- const A &a, const B &b, const C &c, const D &d, const E &, const F &f) {
- using namespace ::std;
- stream << left
- << setw(70) << a << "\t"
- << setw(20) << b << "\t"
- << setw(10) << c << "\t"
- << setw(5) << d << "\t"
- // TODO(b/34984175): enable selecting columns
- // << setw(16) << e << "\t"
- << setw(0) << f
- << endl;
-}
-
-template <typename A>
-std::string join(const A &components, const std::string &separator) {
- std::stringstream out;
- bool first = true;
- for (const auto &component : components) {
- if (!first) {
- out << separator;
- }
- out << component;
-
- first = false;
- }
- return out.str();
-}
-
-std::string toHexString(uint64_t t) {
- std::ostringstream os;
- os << std::hex << std::setfill('0') << std::setw(16) << t;
- return os.str();
-}
-
-std::pair<hidl_string, hidl_string> split(const hidl_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)};
-}
-
-bool getReferencedPids(
- pid_t serverPid, std::map<uint64_t, std::string> *objects) {
-
- std::ifstream ifs("/d/binder/proc/" + std::to_string(serverPid));
- if (!ifs.is_open()) {
- return false;
- }
-
- static const std::regex prefix("^\\s*node \\d+:\\s+u([0-9a-f]+)\\s+c([0-9a-f]+)\\s+");
-
- std::string line;
- std::smatch match;
- while(getline(ifs, line)) {
- if (!std::regex_search(line, match, prefix)) {
- // the line doesn't start with the correct prefix
- continue;
- }
- std::string ptrString = "0x" + match.str(2); // use number after c
- uint64_t ptr;
- if (!::android::base::ParseUint(ptrString.c_str(), &ptr)) {
- // Should not reach here, but just be tolerant.
- std::cerr << "Could not parse number " << ptrString << std::endl;
- continue;
- }
- const std::string proc = " proc ";
- auto pos = line.rfind(proc);
- if (pos != std::string::npos) {
- (*objects)[ptr] += line.substr(pos + proc.size());
- }
- }
- return true;
-}
-
-void dumpAllLibraries(std::stringstream &stream, const std::string &mode,
- const sp<IServiceManager> &manager) {
- using namespace ::std;
- using namespace ::android::hardware;
- using namespace ::android::hidl::manager::V1_0;
- using namespace ::android::hidl::base::V1_0;
- auto ret = manager->list([&] (const auto &fqInstanceNames) {
- for (const auto &fqInstanceName : fqInstanceNames) {
- const auto pair = split(fqInstanceName, '/');
- const auto &serviceName = pair.first;
- const auto &instanceName = pair.second;
- printColumn(stream,
- serviceName,
- instanceName,
- mode,
- "N/A",
- "N/A",
- "N/A");
- }
- });
- if (!ret.isOk()) {
- cerr << "Error: Failed to call debugDump on defaultServiceManager(): "
- << ret.description() << endl;
- }
-}
-
-void dumpPassthrough(std::stringstream &stream, const std::string &mode,
- const sp<IServiceManager> &manager) {
- using namespace ::std;
- using namespace ::android::hardware;
- using namespace ::android::hidl::manager::V1_0;
- using namespace ::android::hidl::base::V1_0;
- auto ret = manager->debugDump([&] (const auto &infos) {
- for (const auto &info : infos) {
-
- printColumn(stream,
- info.interfaceName,
- info.instanceName,
- mode,
- info.clientPids.size() == 1 ? std::to_string(info.clientPids[0]) : "N/A",
- "N/A",
- join(info.clientPids, " "));
- }
- });
- if (!ret.isOk()) {
- cerr << "Error: Failed to call debugDump on defaultServiceManager(): "
- << ret.description() << endl;
- }
-}
-
-void dumpBinderized(std::stringstream &stream, const std::string &mode,
- const sp<IServiceManager> &manager) {
- using namespace ::std;
- using namespace ::android::hardware;
- using namespace ::android::hidl::manager::V1_0;
- using namespace ::android::hidl::base::V1_0;
- auto listRet = manager->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, std::string>> allPids;
- for (const auto &fqInstanceName : fqInstanceNames) {
- const auto pair = split(fqInstanceName, '/');
- const auto &serviceName = pair.first;
- const auto &instanceName = pair.second;
- auto getRet = manager->get(serviceName, instanceName);
- if (!getRet.isOk()) {
- cerr << "Warning: Skipping \"" << fqInstanceName << "\": "
- << "cannot be fetched from service manager:"
- << getRet.description() << endl;
- continue;
- }
- sp<IBase> service = getRet;
- if (service == nullptr) {
- cerr << "Warning: Skipping \"" << fqInstanceName << "\": "
- << "cannot be fetched from service manager (null)";
- continue;
- }
- auto debugRet = service->getDebugInfo([&] (const auto &debugInfo) {
- allDebugInfos[fqInstanceName] = debugInfo;
- if (debugInfo.pid >= 0) {
- allPids[static_cast<pid_t>(debugInfo.pid)].clear();
- }
- });
- if (!debugRet.isOk()) {
- cerr << "Warning: Skipping \"" << fqInstanceName << "\": "
- << "debugging information cannot be retrieved:"
- << debugRet.description() << endl;
- }
- }
- for (auto &pair : allPids) {
- pid_t serverPid = pair.first;
- if (!getReferencedPids(serverPid, &allPids[serverPid])) {
- std::cerr << "Warning: no information for PID " << serverPid
- << ", are you root?" << std::endl;
- }
- }
- for (const auto &fqInstanceName : fqInstanceNames) {
- const auto pair = split(fqInstanceName, '/');
- const auto &serviceName = pair.first;
- const auto &instanceName = pair.second;
- auto it = allDebugInfos.find(fqInstanceName);
- if (it == allDebugInfos.end()) {
- printColumn(stream,
- serviceName,
- instanceName,
- mode,
- "N/A",
- "N/A",
- ""
- );
- continue;
- }
- const DebugInfo &info = it->second;
- printColumn(stream,
- serviceName,
- instanceName,
- mode,
- info.pid < 0 ? "N/A" : std::to_string(info.pid),
- info.ptr == 0 ? "N/A" : toHexString(info.ptr),
- info.pid < 0 || info.ptr == 0 ? "" : allPids[info.pid][info.ptr]
- );
- }
-
- });
- if (!listRet.isOk()) {
- cerr << "Error: Failed to list services for " << mode << ": "
- << listRet.description() << endl;
- }
-}
-
-int dump() {
- using namespace ::std;
- using namespace ::android::hardware;
-
- std::stringstream stream;
-
- stream << "All services:" << endl;
- stream << left;
- printColumn(stream, "Interface", "Instance", "Transport", "Server", "PTR", "Clients");
-
- auto bManager = defaultServiceManager();
- if (bManager == nullptr) {
- cerr << "Failed to get defaultServiceManager()!" << endl;
- } else {
- dumpBinderized(stream, "hwbinder", bManager);
- // Passthrough PIDs are registered to the binderized manager as well.
- dumpPassthrough(stream, "passthrough", bManager);
- }
-
- auto pManager = getPassthroughServiceManager();
- if (pManager == nullptr) {
- cerr << "Failed to get getPassthroughServiceManager()!" << endl;
- } else {
- dumpAllLibraries(stream, "passthrough", pManager);
- }
-
- cout << stream.rdbuf();
- return 0;
-}
-
-int usage() {
- using namespace ::std;
- cerr
- << "usage: lshal" << endl
- << " To dump all hals." << endl
- << "or:" << endl
- << " lshal [-h|--help]" << endl
- << " -h, --help: show this help information." << endl;
- return -1;
-}
-
-int main(int argc, char **argv) {
- static struct option longOptions[] = {
- {"help", no_argument, 0, 'h' },
- { 0, 0, 0, 0 }
- };
-
- int optionIndex;
- int c;
- optind = 1;
- for (;;) {
- // using getopt_long in case we want to add other options in the future
- c = getopt_long(argc, argv, "h", longOptions, &optionIndex);
- if (c == -1) {
- break;
- }
- switch (c) {
- case 'h': // falls through
- default: // see unrecognized options
- return usage();
- }
- }
- return dump();
-
-}
diff --git a/include/audiomanager/IPlayer.h b/include/audiomanager/IPlayer.h
index 94afae5..de5c1c7 100644
--- a/include/audiomanager/IPlayer.h
+++ b/include/audiomanager/IPlayer.h
@@ -20,6 +20,7 @@
#include <stdint.h>
#include <sys/types.h>
+#include <media/VolumeShaper.h>
#include <utils/RefBase.h>
#include <utils/Errors.h>
#include <binder/IInterface.h>
@@ -45,6 +46,9 @@
virtual void setStartDelayMs(int delayMs) = 0;
+ virtual void applyVolumeShaper(
+ const sp<VolumeShaper::Configuration>& configuration,
+ const sp<VolumeShaper::Operation>& operation) = 0;
};
// ----------------------------------------------------------------------------
diff --git a/include/gui/FrameTimestamps.h b/include/gui/FrameTimestamps.h
index 46ca2c2..9e1ae94 100644
--- a/include/gui/FrameTimestamps.h
+++ b/include/gui/FrameTimestamps.h
@@ -95,6 +95,11 @@
std::shared_ptr<FenceTime> releaseFence{FenceTime::NO_FENCE};
};
+struct CompositorTiming {
+ nsecs_t deadline{0};
+ nsecs_t interval{16666667};
+ nsecs_t presentLatency{0};
+};
// A short history of frames that are synchronized between the consumer and
// producer via deltas.
@@ -111,6 +116,8 @@
protected:
std::array<FrameEvents, MAX_FRAME_HISTORY> mFrames;
+
+ CompositorTiming mCompositorTiming;
};
@@ -119,6 +126,16 @@
public:
~ProducerFrameEventHistory() override;
+ // Public for testing.
+ static nsecs_t snapToNextTick(
+ nsecs_t timestamp, nsecs_t tickPhase, nsecs_t tickInterval);
+
+ nsecs_t getNextCompositeDeadline(const nsecs_t now) const;
+ nsecs_t getCompositeInterval() const { return mCompositorTiming.interval; }
+ nsecs_t getCompositeToPresentLatency() const {
+ return mCompositorTiming.presentLatency;
+ }
+
// virtual for testing.
virtual void updateAcquireFence(
uint64_t frameNumber, std::shared_ptr<FenceTime>&& acquire);
@@ -189,12 +206,15 @@
public:
~ConsumerFrameEventHistory() override;
+ void initializeCompositorTiming(const CompositorTiming& compositorTiming);
+
void addQueue(const NewFrameEventsEntry& newEntry);
void addLatch(uint64_t frameNumber, nsecs_t latchTime);
void addPreComposition(uint64_t frameNumber, nsecs_t refreshStartTime);
void addPostComposition(uint64_t frameNumber,
const std::shared_ptr<FenceTime>& gpuCompositionDone,
- const std::shared_ptr<FenceTime>& displayPresent);
+ const std::shared_ptr<FenceTime>& displayPresent,
+ const CompositorTiming& compositorTiming);
void addRetire(uint64_t frameNumber,
const std::shared_ptr<FenceTime>& displayRetire);
void addRelease(uint64_t frameNumber, nsecs_t dequeueReadyTime,
@@ -244,7 +264,7 @@
size_t& count);
private:
- static size_t minFlattenedSize();
+ static constexpr size_t minFlattenedSize();
size_t mIndex{0};
uint64_t mFrameNumber{0};
@@ -306,9 +326,10 @@
size_t& count);
private:
- static size_t minFlattenedSize();
+ static constexpr size_t minFlattenedSize();
std::vector<FrameEventsDelta> mDeltas;
+ CompositorTiming mCompositorTiming;
};
diff --git a/include/gui/Surface.h b/include/gui/Surface.h
index 966e70d..a3c2bfa 100644
--- a/include/gui/Surface.h
+++ b/include/gui/Surface.h
@@ -135,12 +135,18 @@
status_t getLastQueuedBuffer(sp<GraphicBuffer>* outBuffer,
sp<Fence>* outFence, float outTransformMatrix[16]);
+ status_t getDisplayRefreshCycleDuration(nsecs_t* outRefreshDuration);
+
/* Enables or disables frame timestamp tracking. It is disabled by default
* to avoid overhead during queue and dequeue for applications that don't
* need the feature. If disabled, calls to getFrameTimestamps will fail.
*/
void enableFrameTimestamps(bool enable);
+ status_t getCompositorTiming(
+ nsecs_t* compositeDeadline, nsecs_t* compositeInterval,
+ nsecs_t* compositeToPresentLatency);
+
// See IGraphicBufferProducer::getFrameTimestamps
status_t getFrameTimestamps(uint64_t frameNumber,
nsecs_t* outRequestedPresentTime, nsecs_t* outAcquireTime,
@@ -148,7 +154,6 @@
nsecs_t* outLastRefreshStartTime, nsecs_t* outGlCompositionDoneTime,
nsecs_t* outDisplayPresentTime, nsecs_t* outDisplayRetireTime,
nsecs_t* outDequeueReadyTime, nsecs_t* outReleaseTime);
- status_t getDisplayRefreshCycleDuration(nsecs_t* outRefreshDuration);
status_t getUniqueId(uint64_t* outId) const;
@@ -157,6 +162,7 @@
// Virtual for testing.
virtual sp<ISurfaceComposer> composerService() const;
+ virtual nsecs_t now() const;
private:
// can't be copied
@@ -204,10 +210,11 @@
int dispatchSetSurfaceDamage(va_list args);
int dispatchSetSharedBufferMode(va_list args);
int dispatchSetAutoRefresh(va_list args);
+ int dispatchGetDisplayRefreshCycleDuration(va_list args);
int dispatchGetNextFrameId(va_list args);
int dispatchEnableFrameTimestamps(va_list args);
+ int dispatchGetCompositorTiming(va_list args);
int dispatchGetFrameTimestamps(va_list args);
- int dispatchGetDisplayRefreshCycleDuration(va_list args);
protected:
virtual int dequeueBuffer(ANativeWindowBuffer** buffer, int* fenceFd);
diff --git a/libs/gui/FrameTimestamps.cpp b/libs/gui/FrameTimestamps.cpp
index 73537bf..a6fa38a 100644
--- a/libs/gui/FrameTimestamps.cpp
+++ b/libs/gui/FrameTimestamps.cpp
@@ -235,6 +235,23 @@
ProducerFrameEventHistory::~ProducerFrameEventHistory() = default;
+nsecs_t ProducerFrameEventHistory::snapToNextTick(
+ nsecs_t timestamp, nsecs_t tickPhase, nsecs_t tickInterval) {
+ nsecs_t tickOffset = (tickPhase - timestamp) % tickInterval;
+ // Integer modulo rounds towards 0 and not -inf before taking the remainder,
+ // so adjust the offset if it is negative.
+ if (tickOffset < 0) {
+ tickOffset += tickInterval;
+ }
+ return timestamp + tickOffset;
+}
+
+nsecs_t ProducerFrameEventHistory::getNextCompositeDeadline(
+ const nsecs_t now) const{
+ return snapToNextTick(
+ now, mCompositorTiming.deadline, mCompositorTiming.interval);
+}
+
void ProducerFrameEventHistory::updateAcquireFence(
uint64_t frameNumber, std::shared_ptr<FenceTime>&& acquire) {
FrameEvents* frame = getFrame(frameNumber, &mAcquireOffset);
@@ -256,6 +273,8 @@
void ProducerFrameEventHistory::applyDelta(
const FrameEventHistoryDelta& delta) {
+ mCompositorTiming = delta.mCompositorTiming;
+
for (auto& d : delta.mDeltas) {
// Avoid out-of-bounds access.
if (d.mIndex >= mFrames.size()) {
@@ -346,6 +365,11 @@
ConsumerFrameEventHistory::~ConsumerFrameEventHistory() = default;
+void ConsumerFrameEventHistory::initializeCompositorTiming(
+ const CompositorTiming& compositorTiming) {
+ mCompositorTiming = compositorTiming;
+}
+
void ConsumerFrameEventHistory::addQueue(const NewFrameEventsEntry& newEntry) {
// Overwrite all fields of the frame with default values unless set here.
FrameEvents newTimestamps;
@@ -393,7 +417,10 @@
void ConsumerFrameEventHistory::addPostComposition(uint64_t frameNumber,
const std::shared_ptr<FenceTime>& gpuCompositionDone,
- const std::shared_ptr<FenceTime>& displayPresent) {
+ const std::shared_ptr<FenceTime>& displayPresent,
+ const CompositorTiming& compositorTiming) {
+ mCompositorTiming = compositorTiming;
+
FrameEvents* frame = getFrame(frameNumber, &mCompositionOffset);
if (frame == nullptr) {
ALOGE_IF(mProducerWantsEvents,
@@ -450,6 +477,8 @@
void ConsumerFrameEventHistory::getAndResetDelta(
FrameEventHistoryDelta* delta) {
+ delta->mCompositorTiming = mCompositorTiming;
+
// Write these in order of frame number so that it is easy to
// add them to a FenceTimeline in the proper order producer side.
delta->mDeltas.reserve(mFramesDirty.size());
@@ -499,9 +528,8 @@
}
}
-size_t FrameEventsDelta::minFlattenedSize() {
- constexpr size_t min =
- sizeof(FrameEventsDelta::mFrameNumber) +
+constexpr size_t FrameEventsDelta::minFlattenedSize() {
+ return sizeof(FrameEventsDelta::mFrameNumber) +
sizeof(uint8_t) + // mIndex
sizeof(uint8_t) + // mAddPostCompositeCalled
sizeof(uint8_t) + // mAddRetireCalled
@@ -512,7 +540,6 @@
sizeof(FrameEventsDelta::mFirstRefreshStartTime) +
sizeof(FrameEventsDelta::mLastRefreshStartTime) +
sizeof(FrameEventsDelta::mDequeueReadyTime);
- return min;
}
// Flattenable implementation
@@ -618,6 +645,8 @@
FrameEventHistoryDelta& FrameEventHistoryDelta::operator=(
FrameEventHistoryDelta&& src) {
+ mCompositorTiming = src.mCompositorTiming;
+
if (CC_UNLIKELY(!mDeltas.empty())) {
ALOGE("FrameEventHistoryDelta: Clobbering history.");
}
@@ -626,8 +655,9 @@
return *this;
}
-size_t FrameEventHistoryDelta::minFlattenedSize() {
- return sizeof(uint32_t);
+constexpr size_t FrameEventHistoryDelta::minFlattenedSize() {
+ return sizeof(uint32_t) + // mDeltas.size()
+ sizeof(mCompositorTiming);
}
size_t FrameEventHistoryDelta::getFlattenedSize() const {
@@ -654,6 +684,8 @@
return NO_MEMORY;
}
+ FlattenableUtils::write(buffer, size, mCompositorTiming);
+
FlattenableUtils::write(
buffer, size, static_cast<uint32_t>(mDeltas.size()));
for (auto& d : mDeltas) {
@@ -671,6 +703,8 @@
return NO_MEMORY;
}
+ FlattenableUtils::read(buffer, size, mCompositorTiming);
+
uint32_t deltaCount = 0;
FlattenableUtils::read(buffer, size, deltaCount);
if (deltaCount > FrameEventHistory::MAX_FRAME_HISTORY) {
diff --git a/libs/gui/Surface.cpp b/libs/gui/Surface.cpp
index d1f9f6a..d285ef0 100644
--- a/libs/gui/Surface.cpp
+++ b/libs/gui/Surface.cpp
@@ -100,6 +100,10 @@
return ComposerService::getComposerService();
}
+nsecs_t Surface::now() const {
+ return systemTime();
+}
+
sp<IGraphicBufferProducer> Surface::getIGraphicBufferProducer() const {
return mGraphicBufferProducer;
}
@@ -142,11 +146,51 @@
outTransformMatrix);
}
+status_t Surface::getDisplayRefreshCycleDuration(nsecs_t* outRefreshDuration) {
+ ATRACE_CALL();
+
+ DisplayStatInfo stats;
+ status_t err = composerService()->getDisplayStats(NULL, &stats);
+
+ *outRefreshDuration = stats.vsyncPeriod;
+
+ return NO_ERROR;
+}
+
void Surface::enableFrameTimestamps(bool enable) {
Mutex::Autolock lock(mMutex);
+ // If going from disabled to enabled, get the initial values for
+ // compositor and display timing.
+ if (!mEnableFrameTimestamps && enable) {
+ FrameEventHistoryDelta delta;
+ mGraphicBufferProducer->getFrameTimestamps(&delta);
+ mFrameEventHistory->applyDelta(delta);
+ }
mEnableFrameTimestamps = enable;
}
+status_t Surface::getCompositorTiming(
+ nsecs_t* compositeDeadline, nsecs_t* compositeInterval,
+ nsecs_t* compositeToPresentLatency) {
+ Mutex::Autolock lock(mMutex);
+ if (!mEnableFrameTimestamps) {
+ return INVALID_OPERATION;
+ }
+
+ if (compositeDeadline != nullptr) {
+ *compositeDeadline =
+ mFrameEventHistory->getNextCompositeDeadline(now());
+ }
+ if (compositeInterval != nullptr) {
+ *compositeInterval = mFrameEventHistory->getCompositeInterval();
+ }
+ if (compositeToPresentLatency != nullptr) {
+ *compositeToPresentLatency =
+ mFrameEventHistory->getCompositeToPresentLatency();
+ }
+ return NO_ERROR;
+}
+
static bool checkConsumerForUpdates(
const FrameEvents* e, const uint64_t lastFrameNumber,
const nsecs_t* outLatchTime,
@@ -260,16 +304,6 @@
return NO_ERROR;
}
-status_t Surface::getDisplayRefreshCycleDuration(nsecs_t* outRefreshDuration) {
- ATRACE_CALL();
-
- DisplayStatInfo stats;
- status_t err = composerService()->getDisplayStats(NULL, &stats);
-
- *outRefreshDuration = stats.vsyncPeriod;
-
- return NO_ERROR;
-}
int Surface::hook_setSwapInterval(ANativeWindow* window, int interval) {
Surface* c = getSelf(window);
@@ -831,18 +865,21 @@
case NATIVE_WINDOW_SET_AUTO_REFRESH:
res = dispatchSetAutoRefresh(args);
break;
+ case NATIVE_WINDOW_GET_REFRESH_CYCLE_DURATION:
+ res = dispatchGetDisplayRefreshCycleDuration(args);
+ break;
case NATIVE_WINDOW_GET_NEXT_FRAME_ID:
res = dispatchGetNextFrameId(args);
break;
case NATIVE_WINDOW_ENABLE_FRAME_TIMESTAMPS:
res = dispatchEnableFrameTimestamps(args);
break;
+ case NATIVE_WINDOW_GET_COMPOSITOR_TIMING:
+ res = dispatchGetCompositorTiming(args);
+ break;
case NATIVE_WINDOW_GET_FRAME_TIMESTAMPS:
res = dispatchGetFrameTimestamps(args);
break;
- case NATIVE_WINDOW_GET_REFRESH_CYCLE_DURATION:
- res = dispatchGetDisplayRefreshCycleDuration(args);
- break;
default:
res = NAME_NOT_FOUND;
break;
@@ -963,6 +1000,11 @@
return setAutoRefresh(autoRefresh);
}
+int Surface::dispatchGetDisplayRefreshCycleDuration(va_list args) {
+ nsecs_t* outRefreshDuration = va_arg(args, int64_t*);
+ return getDisplayRefreshCycleDuration(outRefreshDuration);
+}
+
int Surface::dispatchGetNextFrameId(va_list args) {
uint64_t* nextFrameId = va_arg(args, uint64_t*);
*nextFrameId = getNextFrameNumber();
@@ -975,6 +1017,14 @@
return NO_ERROR;
}
+int Surface::dispatchGetCompositorTiming(va_list args) {
+ nsecs_t* compositeDeadline = va_arg(args, int64_t*);
+ nsecs_t* compositeInterval = va_arg(args, int64_t*);
+ nsecs_t* compositeToPresentLatency = va_arg(args, int64_t*);
+ return getCompositorTiming(compositeDeadline, compositeInterval,
+ compositeToPresentLatency);
+}
+
int Surface::dispatchGetFrameTimestamps(va_list args) {
uint64_t frameId = va_arg(args, uint64_t);
nsecs_t* outRequestedPresentTime = va_arg(args, int64_t*);
@@ -994,11 +1044,6 @@
outDisplayRetireTime, outDequeueReadyTime, outReleaseTime);
}
-int Surface::dispatchGetDisplayRefreshCycleDuration(va_list args) {
- nsecs_t* outRefreshDuration = va_arg(args, int64_t*);
- return getDisplayRefreshCycleDuration(outRefreshDuration);
-}
-
int Surface::connect(int api) {
static sp<IProducerListener> listener = new DummyProducerListener();
return connect(api, listener);
diff --git a/libs/gui/tests/Surface_test.cpp b/libs/gui/tests/Surface_test.cpp
index 3f56665..5298027 100644
--- a/libs/gui/tests/Surface_test.cpp
+++ b/libs/gui/tests/Surface_test.cpp
@@ -479,8 +479,17 @@
return mFakeSurfaceComposer;
}
+ nsecs_t now() const override {
+ return mNow;
+ }
+
+ void setNow(nsecs_t now) {
+ mNow = now;
+ }
+
public:
sp<FakeSurfaceComposer> mFakeSurfaceComposer;
+ nsecs_t mNow = 0;
// mFrameEventHistory owns the instance of FakeProducerFrameEventHistory,
// but this raw pointer gives access to test functionality.
@@ -500,10 +509,12 @@
struct RefreshEvents {
RefreshEvents(FenceToFenceTimeMap& fenceMap, nsecs_t refreshStart)
- : mFenceMap(fenceMap),
- kStartTime(refreshStart + 1),
- kGpuCompositionDoneTime(refreshStart + 2),
- kPresentTime(refreshStart + 3) {}
+ : mFenceMap(fenceMap),
+ kCompositorTiming(
+ {refreshStart, refreshStart + 1, refreshStart + 2 }),
+ kStartTime(refreshStart + 3),
+ kGpuCompositionDoneTime(refreshStart + 4),
+ kPresentTime(refreshStart + 5) {}
void signalPostCompositeFences() {
mFenceMap.signalAllForTest(
@@ -516,6 +527,8 @@
FenceAndFenceTime mGpuCompositionDone { mFenceMap };
FenceAndFenceTime mPresent { mFenceMap };
+ const CompositorTiming kCompositorTiming;
+
const nsecs_t kStartTime;
const nsecs_t kGpuCompositionDoneTime;
const nsecs_t kPresentTime;
@@ -592,6 +605,12 @@
native_window_set_buffer_count(mWindow.get(), 4);
}
+ void disableFrameTimestamps() {
+ mFakeConsumer->mGetFrameTimestampsEnabled = false;
+ native_window_enable_frame_timestamps(mWindow.get(), 0);
+ mFrameTimestampsEnabled = false;
+ }
+
void enableFrameTimestamps() {
mFakeConsumer->mGetFrameTimestampsEnabled = true;
native_window_enable_frame_timestamps(mWindow.get(), 1);
@@ -681,7 +700,8 @@
oldFrame->mRefreshes[2].mGpuCompositionDone.mFenceTime :
FenceTime::NO_FENCE;
mCfeh->addPostComposition(nOldFrame, gpuDoneFenceTime,
- oldFrame->mRefreshes[2].mPresent.mFenceTime);
+ oldFrame->mRefreshes[2].mPresent.mFenceTime,
+ oldFrame->mRefreshes[2].kCompositorTiming);
}
// Latch the new frame.
@@ -698,7 +718,8 @@
std::shared_ptr<FenceTime>(oldFrame->mRelease.mFenceTime));
}
mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
- newFrame->mRefreshes[0].mPresent.mFenceTime);
+ newFrame->mRefreshes[0].mPresent.mFenceTime,
+ newFrame->mRefreshes[0].kCompositorTiming);
// Retire the previous buffer just after compositing the new buffer.
if (oldFrame != nullptr) {
@@ -710,7 +731,8 @@
newFrame->mRefreshes[1].mGpuCompositionDone.mFenceTime :
FenceTime::NO_FENCE;
mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
- newFrame->mRefreshes[1].mPresent.mFenceTime);
+ newFrame->mRefreshes[1].mPresent.mFenceTime,
+ newFrame->mRefreshes[1].kCompositorTiming);
}
void QueryPresentRetireSupported(
@@ -740,7 +762,8 @@
int64_t outDequeueReadyTime = -1;
int64_t outReleaseTime = -1;
- FrameEvents mFrames[2] { { mFenceMap, 1000 }, { mFenceMap, 2000 } };
+ FrameEvents mFrames[3] {
+ { mFenceMap, 1000 }, { mFenceMap, 2000 }, { mFenceMap, 3000 } };
};
@@ -773,25 +796,55 @@
int result = getAllFrameTimestamps(fId);
EXPECT_EQ(INVALID_OPERATION, result);
EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
+
+ // Verify compositor timing query fails.
+ nsecs_t compositeDeadline = 0;
+ nsecs_t compositeInterval = 0;
+ nsecs_t compositeToPresentLatency = 0;
+ result = native_window_get_compositor_timing(mWindow.get(),
+ &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+ EXPECT_EQ(INVALID_OPERATION, result);
}
// This test verifies that the frame timestamps are retrieved if explicitly
// enabled via native_window_enable_frame_timestamps.
TEST_F(GetFrameTimestampsTest, EnabledSimple) {
+ CompositorTiming initialCompositorTiming {
+ 1000000000, // 1s deadline
+ 16666667, // 16ms interval
+ 50000000, // 50ms present latency
+ };
+ mCfeh->initializeCompositorTiming(initialCompositorTiming);
+
enableFrameTimestamps();
+ // Verify the compositor timing query gets the initial compositor values
+ // after timststamps are enabled; even before the first frame is queued
+ // or dequeued.
+ nsecs_t compositeDeadline = 0;
+ nsecs_t compositeInterval = 0;
+ nsecs_t compositeToPresentLatency = 0;
+ mSurface->setNow(initialCompositorTiming.deadline - 1);
+ int result = native_window_get_compositor_timing(mWindow.get(),
+ &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+ EXPECT_EQ(NO_ERROR, result);
+ EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
+ EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
+ EXPECT_EQ(initialCompositorTiming.presentLatency,
+ compositeToPresentLatency);
+
int fence;
ANativeWindowBuffer* buffer;
EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
- EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
+ EXPECT_EQ(1, mFakeConsumer->mGetFrameTimestampsCount);
const uint64_t fId1 = getNextFrameId();
// Verify getFrameTimestamps is piggybacked on dequeue.
ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
- EXPECT_EQ(1, mFakeConsumer->mGetFrameTimestampsCount);
+ EXPECT_EQ(2, mFakeConsumer->mGetFrameTimestampsCount);
NewFrameEventsEntry f1;
f1.frameNumber = 1;
@@ -808,13 +861,13 @@
ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount);
EXPECT_EQ(1u, mFakeConsumer->mLastAddedFrameNumber);
- EXPECT_EQ(2, mFakeConsumer->mGetFrameTimestampsCount);
+ EXPECT_EQ(3, mFakeConsumer->mGetFrameTimestampsCount);
// Verify queries for timestamps that the producer doesn't know about
// triggers a call to see if the consumer has any new timestamps.
- int result = getAllFrameTimestamps(fId1);
+ result = getAllFrameTimestamps(fId1);
EXPECT_EQ(NO_ERROR, result);
- EXPECT_EQ(3, mFakeConsumer->mGetFrameTimestampsCount);
+ EXPECT_EQ(4, mFakeConsumer->mGetFrameTimestampsCount);
}
void GetFrameTimestampsTest::QueryPresentRetireSupported(
@@ -842,6 +895,234 @@
QueryPresentRetireSupported(false, true);
}
+TEST_F(GetFrameTimestampsTest, SnapToNextTickBasic) {
+ nsecs_t phase = 4000;
+ nsecs_t interval = 1000;
+
+ // Timestamp in previous interval.
+ nsecs_t timestamp = 3500;
+ EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
+ timestamp, phase, interval));
+
+ // Timestamp in next interval.
+ timestamp = 4500;
+ EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
+ timestamp, phase, interval));
+
+ // Timestamp multiple intervals before.
+ timestamp = 2500;
+ EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
+ timestamp, phase, interval));
+
+ // Timestamp multiple intervals after.
+ timestamp = 6500;
+ EXPECT_EQ(7000, ProducerFrameEventHistory::snapToNextTick(
+ timestamp, phase, interval));
+
+ // Timestamp on previous interval.
+ timestamp = 3000;
+ EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
+ timestamp, phase, interval));
+
+ // Timestamp on next interval.
+ timestamp = 5000;
+ EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
+ timestamp, phase, interval));
+
+ // Timestamp equal to phase.
+ timestamp = 4000;
+ EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
+ timestamp, phase, interval));
+}
+
+// int(big_timestamp / interval) < 0, which can cause a crash or invalid result
+// if the number of intervals elapsed is internally stored in an int.
+TEST_F(GetFrameTimestampsTest, SnapToNextTickOverflow) {
+ nsecs_t phase = 0;
+ nsecs_t interval = 4000;
+ nsecs_t big_timestamp = 8635916564000;
+ int32_t intervals = big_timestamp / interval;
+
+ EXPECT_LT(intervals, 0);
+ EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
+ big_timestamp, phase, interval));
+ EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
+ big_timestamp, big_timestamp, interval));
+}
+
+// This verifies the compositor timing is updated by refresh events
+// and piggy backed on a queue, dequeue, and enabling of timestamps..
+TEST_F(GetFrameTimestampsTest, CompositorTimingUpdatesBasic) {
+ CompositorTiming initialCompositorTiming {
+ 1000000000, // 1s deadline
+ 16666667, // 16ms interval
+ 50000000, // 50ms present latency
+ };
+ mCfeh->initializeCompositorTiming(initialCompositorTiming);
+
+ enableFrameTimestamps();
+
+ // We get the initial values before any frames are submitted.
+ nsecs_t compositeDeadline = 0;
+ nsecs_t compositeInterval = 0;
+ nsecs_t compositeToPresentLatency = 0;
+ mSurface->setNow(initialCompositorTiming.deadline - 1);
+ int result = native_window_get_compositor_timing(mWindow.get(),
+ &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+ EXPECT_EQ(NO_ERROR, result);
+ EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
+ EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
+ EXPECT_EQ(initialCompositorTiming.presentLatency,
+ compositeToPresentLatency);
+
+ const uint64_t fId1 = getNextFrameId();
+ dequeueAndQueue(0);
+ addFrameEvents(true, NO_FRAME_INDEX, 0);
+
+ // Still get the initial values because the frame events for frame 0
+ // didn't get a chance to piggyback on a queue or dequeue yet.
+ result = native_window_get_compositor_timing(mWindow.get(),
+ &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+ EXPECT_EQ(NO_ERROR, result);
+ EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
+ EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
+ EXPECT_EQ(initialCompositorTiming.presentLatency,
+ compositeToPresentLatency);
+
+ const uint64_t fId2 = getNextFrameId();
+ dequeueAndQueue(1);
+ addFrameEvents(true, 0, 1);
+
+ // Now expect the composite values associated with frame 1.
+ mSurface->setNow(mFrames[0].mRefreshes[1].kCompositorTiming.deadline);
+ result = native_window_get_compositor_timing(mWindow.get(),
+ &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+ EXPECT_EQ(NO_ERROR, result);
+ EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.deadline,
+ compositeDeadline);
+ EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.interval,
+ compositeInterval);
+ EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.presentLatency,
+ compositeToPresentLatency);
+
+ dequeueAndQueue(2);
+ addFrameEvents(true, 1, 2);
+
+ // Now expect the composite values associated with frame 2.
+ mSurface->setNow(mFrames[1].mRefreshes[1].kCompositorTiming.deadline);
+ result = native_window_get_compositor_timing(mWindow.get(),
+ &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+ EXPECT_EQ(NO_ERROR, result);
+ EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.deadline,
+ compositeDeadline);
+ EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.interval,
+ compositeInterval);
+ EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.presentLatency,
+ compositeToPresentLatency);
+
+ // Re-enabling frame timestamps should get the latest values.
+ disableFrameTimestamps();
+ enableFrameTimestamps();
+
+ // Now expect the composite values associated with frame 3.
+ mSurface->setNow(mFrames[2].mRefreshes[1].kCompositorTiming.deadline);
+ result = native_window_get_compositor_timing(mWindow.get(),
+ &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+ EXPECT_EQ(NO_ERROR, result);
+ EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.deadline,
+ compositeDeadline);
+ EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.interval,
+ compositeInterval);
+ EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.presentLatency,
+ compositeToPresentLatency);
+}
+
+// This verifies the compositor deadline properly snaps to the the next
+// deadline based on the current time.
+TEST_F(GetFrameTimestampsTest, CompositorTimingDeadlineSnaps) {
+ CompositorTiming initialCompositorTiming {
+ 1000000000, // 1s deadline
+ 16666667, // 16ms interval
+ 50000000, // 50ms present latency
+ };
+ mCfeh->initializeCompositorTiming(initialCompositorTiming);
+
+ enableFrameTimestamps();
+
+ nsecs_t compositeDeadline = 0;
+ nsecs_t compositeInterval = 0;
+ nsecs_t compositeToPresentLatency = 0;
+
+ // A "now" just before the deadline snaps to the deadline.
+ mSurface->setNow(initialCompositorTiming.deadline - 1);
+ int result = native_window_get_compositor_timing(mWindow.get(),
+ &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+ EXPECT_EQ(NO_ERROR, result);
+ EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
+ nsecs_t expectedDeadline = initialCompositorTiming.deadline;
+ EXPECT_EQ(expectedDeadline, compositeDeadline);
+
+ const uint64_t fId1 = getNextFrameId();
+ dequeueAndQueue(0);
+ addFrameEvents(true, NO_FRAME_INDEX, 0);
+
+ // A "now" just after the deadline snaps properly.
+ mSurface->setNow(initialCompositorTiming.deadline + 1);
+ result = native_window_get_compositor_timing(mWindow.get(),
+ &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+ EXPECT_EQ(NO_ERROR, result);
+ expectedDeadline =
+ initialCompositorTiming.deadline +initialCompositorTiming.interval;
+ EXPECT_EQ(expectedDeadline, compositeDeadline);
+
+ const uint64_t fId2 = getNextFrameId();
+ dequeueAndQueue(1);
+ addFrameEvents(true, 0, 1);
+
+ // A "now" just after the next interval snaps properly.
+ mSurface->setNow(
+ mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
+ mFrames[0].mRefreshes[1].kCompositorTiming.interval + 1);
+ result = native_window_get_compositor_timing(mWindow.get(),
+ &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+ EXPECT_EQ(NO_ERROR, result);
+ expectedDeadline =
+ mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
+ mFrames[0].mRefreshes[1].kCompositorTiming.interval * 2;
+ EXPECT_EQ(expectedDeadline, compositeDeadline);
+
+ dequeueAndQueue(2);
+ addFrameEvents(true, 1, 2);
+
+ // A "now" over 1 interval before the deadline snaps properly.
+ mSurface->setNow(
+ mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
+ mFrames[1].mRefreshes[1].kCompositorTiming.interval - 1);
+ result = native_window_get_compositor_timing(mWindow.get(),
+ &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+ EXPECT_EQ(NO_ERROR, result);
+ expectedDeadline =
+ mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
+ mFrames[1].mRefreshes[1].kCompositorTiming.interval;
+ EXPECT_EQ(expectedDeadline, compositeDeadline);
+
+ // Re-enabling frame timestamps should get the latest values.
+ disableFrameTimestamps();
+ enableFrameTimestamps();
+
+ // A "now" over 2 intervals before the deadline snaps properly.
+ mSurface->setNow(
+ mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
+ mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2 - 1);
+ result = native_window_get_compositor_timing(mWindow.get(),
+ &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+ EXPECT_EQ(NO_ERROR, result);
+ expectedDeadline =
+ mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
+ mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2;
+ EXPECT_EQ(expectedDeadline, compositeDeadline);
+}
+
// This verifies the timestamps recorded in the consumer's
// FrameTimestampsHistory are properly retrieved by the producer for the
// correct frames.
diff --git a/libs/vr/libgvr/.clang-format b/libs/vr/libgvr/.clang-format
deleted file mode 100644
index 3287160..0000000
--- a/libs/vr/libgvr/.clang-format
+++ /dev/null
@@ -1,2 +0,0 @@
-Language: Cpp
-DisableFormat: true
diff --git a/libs/vr/libgvr/Android.mk b/libs/vr/libgvr/Android.mk
deleted file mode 100644
index 0daf2ea..0000000
--- a/libs/vr/libgvr/Android.mk
+++ /dev/null
@@ -1,129 +0,0 @@
-# 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.
-LOCAL_PATH := $(call my-dir)
-
-include_dirs := \
- $(LOCAL_PATH)/include \
- $(LOCAL_PATH)/prebuilt/include
-
-# Java platform library for the system implementation of the GVR API.
-include $(CLEAR_VARS)
-LOCAL_MODULE := com.google.vr.gvr.platform
-LOCAL_REQUIRED_MODULES := libgvr_system_loader libgvr_system
-LOCAL_SRC_FILES := $(call all-java-files-under, java)
-include $(BUILD_JAVA_LIBRARY)
-
-# Library to perform dlopen on the actual platform library.
-include $(CLEAR_VARS)
-LOCAL_MODULE := libgvr_system_loader
-LOCAL_SRC_FILES := library_loader.cpp
-include $(BUILD_SHARED_LIBRARY)
-
-# Shared library implementing the GVR API.
-include $(CLEAR_VARS)
-LOCAL_MODULE := libgvr_system
-
-LOCAL_SRC_FILES := \
- shim_gvr.cpp \
- shim_gvr_controller.cpp \
- shim_gvr_private.cpp \
- deviceparams/CardboardDevice.nolite.proto
-
-LOCAL_MODULE_CLASS := SHARED_LIBRARIES
-
-LOCAL_C_INCLUDES := $(include_dirs)
-LOCAL_C_INCLUDES += $(call local-generated-sources-dir)/proto/$(LOCAL_PATH)
-LOCAL_EXPORT_C_INCLUDE_DIRS := $(include_dirs)
-
-gvr_api_linker_script := $(LOCAL_PATH)/exported_apis.lds
-LOCAL_ADDITIONAL_DEPENDENCIES := $(gvr_api_linker_script)
-
-LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES
-LOCAL_CFLAGS += -DEGL_EGLEXT_PROTOTYPES
-LOCAL_LDFLAGS += -Wl,-version-script,$(gvr_api_linker_script)
-
-LOCAL_SHARED_LIBRARIES := \
- libandroid_runtime \
- libbase \
- libbinder \
- libcutils \
- libutils \
- libgui \
- libui \
- libEGL \
- libGLESv2 \
- libvulkan \
- libhardware \
- liblog \
- libsync \
- libprotobuf-cpp-full
-
-LOCAL_STATIC_LIBRARIES := \
- libdisplay \
- libbufferhub \
- libbufferhubqueue \
- libdvrcommon \
- libeds \
- libdvrgraphics \
- libsensor \
- libperformance \
- libpdx_default_transport \
-
-include $(BUILD_SHARED_LIBRARY)
-
-# Prebuilt shared library for libgvr_audio.so
-include $(CLEAR_VARS)
-LOCAL_MODULE := libgvr_audio
-LOCAL_MODULE_CLASS := SHARED_LIBRARIES
-LOCAL_MODULE_SUFFIX := .so
-LOCAL_MULTILIB := both
-LOCAL_MODULE_TARGET_ARCH := arm arm64 x86 x86_64
-LOCAL_SRC_FILES_arm := prebuilt/lib/android_arm/libgvr_audio.so
-LOCAL_SRC_FILES_arm64 := prebuilt/lib/android_arm64/libgvr_audio.so
-LOCAL_SRC_FILES_x86 := prebuilt/lib/android_x86/libgvr_audio.so
-LOCAL_SRC_FILES_x86_64 := prebuilt/lib/android_x86_64/libgvr_audio.so
-include $(BUILD_PREBUILT)
-
-# Prebuilt shared library for libgvr.so
-include $(CLEAR_VARS)
-LOCAL_MODULE := libgvr
-LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/prebuilt/include
-LOCAL_MODULE_CLASS := SHARED_LIBRARIES
-LOCAL_MODULE_SUFFIX := .so
-LOCAL_MULTILIB := both
-LOCAL_MODULE_TARGET_ARCH := arm arm64 x86 x86_64
-LOCAL_SRC_FILES_arm := prebuilt/lib/android_arm/libgvr.so
-LOCAL_SRC_FILES_arm64 := prebuilt/lib/android_arm64/libgvr.so
-LOCAL_SRC_FILES_x86 := prebuilt/lib/android_x86/libgvr.so
-LOCAL_SRC_FILES_x86_64 := prebuilt/lib/android_x86_64/libgvr.so
-include $(BUILD_PREBUILT)
-
-# Prebuilt Java static library for common_library.aar
-include $(CLEAR_VARS)
-LOCAL_PREBUILT_STATIC_JAVA_LIBRARIES := \
- gvr_common_library_aar:prebuilt/lib/common_library.aar
-include $(BUILD_MULTI_PREBUILT)
-
-# Dummy libgvr_ext to be used along side libgvr.so prebuilt.
-# This shall be replaced with Google3 prebuilts in future.
-include $(CLEAR_VARS)
-LOCAL_MODULE := libgvr_ext
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/include
-LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
-LOCAL_SRC_FILES := dummy_gvr_ext.cpp
-LOCAL_LDLIBS := -llog
-LOCAL_MODULE_TAGS := optional
-LOCAL_SHARED_LIBRARIES += libgvr
-LOCAL_MODULE_TARGET_ARCH := arm arm64 x86 x86_64
-include $(BUILD_STATIC_LIBRARY)
diff --git a/libs/vr/libgvr/CPPLINT.cfg b/libs/vr/libgvr/CPPLINT.cfg
deleted file mode 100644
index 2da1c50..0000000
--- a/libs/vr/libgvr/CPPLINT.cfg
+++ /dev/null
@@ -1 +0,0 @@
-filter=-build/header_guard,-build/include_alpha
diff --git a/libs/vr/libgvr/README.dreamos b/libs/vr/libgvr/README.dreamos
deleted file mode 100644
index d847210..0000000
--- a/libs/vr/libgvr/README.dreamos
+++ /dev/null
@@ -1 +0,0 @@
-Files under public/vr/gvr were imported from the public Google VR SDK.
diff --git a/libs/vr/libgvr/com.google.vr.gvr.platform.xml b/libs/vr/libgvr/com.google.vr.gvr.platform.xml
deleted file mode 100644
index 9297c7f..0000000
--- a/libs/vr/libgvr/com.google.vr.gvr.platform.xml
+++ /dev/null
@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- 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.
--->
-
-<permissions>
- <library name="com.google.vr.gvr.platform"
- file="/system/framework/com.google.vr.gvr.platform.jar" />
-</permissions>
diff --git a/libs/vr/libgvr/deviceparams/CardboardDevice.nolite.proto b/libs/vr/libgvr/deviceparams/CardboardDevice.nolite.proto
deleted file mode 100644
index 77b5d72..0000000
--- a/libs/vr/libgvr/deviceparams/CardboardDevice.nolite.proto
+++ /dev/null
@@ -1,299 +0,0 @@
-
-syntax = "proto2";
-
-option java_package = "com.google.vrtoolkit.cardboard.proto";
-option java_outer_classname = "CardboardDevice";
-option optimize_for = SPEED;
-
-package proto;
-
-
-/**
- * Message describing properties of a VR head mount device (HMD) which uses an
- * interchangeable smartphone as a display (e.g. Google Cardboard).
- *
- * While some properties are certain (e.g. inter_lens_distance), others
- * represent nominal values which may be refined depending on context (e.g.
- * viewport_angles).
- *
- * Lengths are in meters unless noted otherwise. Fields are _required_
- * unless noted otherwise.
- *
- * Some context on why this set of parameters are deemed necessary and
- * sufficient:
- * * FOV scale can be reasonably approximated from lens-to-screen distance
- * and display size (i.e. knowing lens focal length isn't crucial).
- * * Lenses are assumed to be horizontally centered with respect to
- * display.
- * * The display is not necessarily vertically centered. For interchangeable
- * phones where the device rests against a tray, we can derive
- * the vertical offset from tray-to-lens height along with phone-specific
- * bezel and screen sizes (supplied separately).
- */
-message DeviceParams {
- // String identifying the device's vendor (e.g. "Google, Inc.").
- // A device's [vendor, model] pair is expected to be globally unique.
- optional string vendor = 1;
-
- // String identifying the device's model, including revision info if
- // needed (e.g. "Cardboard v1"). A device's [vendor, model] pair is
- // expected to be globally unique.
- optional string model = 2;
-
- // Distance from the display screen to the optical center of lenses.
- // This is a required field for distortion rendering, and must be positive.
- optional float screen_to_lens_distance = 3;
-
- // Horizontal distance between optical center of the lenses.
- // This is a required field for distortion rendering, and must be positive.
- optional float inter_lens_distance = 4;
-
- // Four-element tuple (left, right, bottom, top) of left eye's view extent
- // angles relative to center, assuming the following:
- // * eye is aligned with optical center of lens
- // * display screen is equal or larger than extents viewable through lens
- // * nominal eye-to-lens distance
- // * mirrored field of view will be applied to the right eye
- // These values are essentially used as an optimization to avoid rendering
- // pixels which can't be seen.
- // This is a required field for distortion rendering, and angles must be
- // positive.
- repeated float left_eye_field_of_view_angles = 5 [packed = true];
-
- enum VerticalAlignmentType {
- BOTTOM = 0; // phone rests against a fixed bottom tray
- CENTER = 1; // phone screen assumed to be centered w.r.t. lenses
- TOP = 2; // phone rests against a fixed top tray
- }
-
- // Set according to vertical alignment strategy-- see enum comments above.
- // NOTE: If you set this to CENTER, see special instructions for the
- // tray_to_lens_distance field below.
- optional VerticalAlignmentType vertical_alignment = 11 [default = BOTTOM];
-
- // If the phone is aligned vertically within the device by resting against
- // a fixed top or bottom tray, this is the distance from the tray to
- // optical center of the lenses.
- // This is a required field for distortion rendering, and must be positive.
- // NOTE: Due to a bug in initial versions of the SDK's, this field
- // must be set explicitly to .035 when vertical_alignment = CENTER.
- optional float tray_to_lens_distance = 6;
-
- // Coefficients Ki for pincushion distortion function which maps
- // from position on real screen to virtual screen (i.e. texture) relative
- // to optical center:
- //
- // p' = p (1 + K1 r^2 + K2 r^4 + ... + Kn r^(2n))
- //
- // where r is the distance in tan-angle units from the optical center,
- // p the input point, and p' the output point. Tan-angle units can be
- // computed as distance on the screen divided by distance from the
- // virtual eye to the screen.
- repeated float distortion_coefficients = 7 [packed = true];
- // Slots 8, 9 reserved for per-color channel distortion.
-
- // Optionally, whether the head mount uses a magnet in any part of its
- // design. Intended as hint as to whether phone's magnetometer is
- // available for tasks such as orientation tracking.
- optional bool has_magnet = 10;
-
- enum ButtonType {
- // No physical button, and touch screen is not easily accessible.
- NONE = 0;
- // HMD has integrated magnet switch similar to original Cardboard.
- MAGNET = 1;
- // At least a portion of touch screen is easily accessible to user for taps.
- TOUCH = 2;
- // Touch screen is triggered indirectly via integrated button on the HMD.
- INDIRECT_TOUCH = 3;
- }
-
- // Specify primary input mechanism of the HMD. Intended for advisory
- // purposes only, to address simple questions such as "can HMD
- // be used with apps requiring a physical button event?" or "what icon
- // should be used to represent button action to the user?".
- optional ButtonType primary_button = 12 [default = MAGNET];
-
- // Some internal data for Cardboard. This data is not intended to be
- // set or used by developers, and any data in this proto is not guaranteed
- // to be supported with new SDK updates.
- optional CardboardInternalParams internal = 1729;
-
- // Optionally, specifies the additional parameters that are necessary for
- // a Daydream-ready headset. This field is non-null if the headset is
- // Daydream-ready.
- // TODO(b/30112366) The inclusion of this message inside a DeviceParams is a
- // somewhat ugly result of some historical choices in the SDK. We should
- // consider refactoring our code to allow us to remove this, and the
- // CardboardInternalParams messages from this proto.
- optional DaydreamInternalParams daydream_internal = 196883;
-}
-
-// TODO(b/27108179): CardboardInternalParams should be migrated into its own
-// file, and not live in this file.
-
-/**
- * Message describing parameters that are used internally by Cardboard
- * and VRToolkit. These parameters don't necessarily fit into the DeviceParams
- * notion of a VR viewer combined with user's phone (e.g. case of viewer with
- * dedicated display, etc.) and are not intended to be used by developers
- * and may or may not be supported or changed without notice on new releases
- * of the Cardboard SDK or VR Toolkit.
- */
-message CardboardInternalParams {
- // Used to specify a per-eye post-process transformation -- an optional
- // rotation and x-axis reflection -- to be applied after distortion
- // correction.
- enum OrientationType {
- CCW_0_DEGREES = 0;
- CCW_90_DEGREES = 1;
- CCW_180_DEGREES = 2;
- CCW_270_DEGREES = 3;
- CCW_0_DEGREES_MIRRORED = 4;
- CCW_90_DEGREES_MIRRORED = 5;
- CCW_180_DEGREES_MIRRORED = 6;
- CCW_270_DEGREES_MIRRORED = 7;
- }
-
- // Specify a post-process transformation that is applied after the distortion
- // function. This field is optional, if not specified, CCW_0_DEGREES is
- // assumed. If repeated, the first orientation is for the left eye, the second
- // is for the right eye.
- //
- // For example, if [CCW_90_DEGREES, CCW_270_DEGREES_MIRRORED] is specified,
- //
- // this input:
- //
- // ***************** *****************
- // *1 2* *1 2*
- // * * * * *** *
- // * * * * * * *
- // * **** * * * * *
- // *4 3* *4 3*
- // ***************** *****************
- //
- // is rendered on the screen like this:
- //
- // ***************** *****************
- // *2 * 3* *3 * 2*
- // * * * * ** *
- // * * * * * *
- // * *** * * *** *
- // *1 4* *4 1*
- // ***************** *****************
- repeated OrientationType eye_orientations = 1 [packed = true];
-
- // Specify a horizontal offset from the middle of the screen to the center of
- // the lens, in meters. If one is not provided, half of the inter lens
- // distance is used.
- //
- // This is only necessary if the HMD has some sort of periscope effect, where
- // the position of the lenses, relative to the screen, is different than
- // their position relative to the user.
- //
- // For example, in the HMD below, two mirrors reflect the image from the
- // screen to the user, creating a larger inter lens distance than the screen
- // can support.
- //
- // [In the diagram below, S = screen, L = lens]
- //
- // screen_center_to_lens_distance
- // |--|
- //
- // -------------------------
- // | SSSSSSSSSSSS |
- // | | | | |
- // | /----/ | \----\ |
- // | | | | |
- // | LLL LLL |
- //
- // |---------------|
- // inter_lens_distance
- //
- optional float screen_center_to_lens_distance = 2;
-
- // Optional x-dimension physical pixels per inch of the external display,
- // assuming landscape orientation. If set, this will override OS-reported
- // values.
- optional float x_ppi_override = 3;
-
- // Optional y-dimension physical pixels per inch of the external display,
- // assuming landscape orientation. If set, this will override OS-reported
- // values.
- optional float y_ppi_override = 4;
-
- // Optional string identifying the device's accelerometer and gyroscope.
- // If either field is filled out, the corresponding sensor (gyroscope or
- // accelerometer) will be used for head tracking.
- //
- // Valid strings are usually found in:
- // vendor/<vendorname>/<devicename>/xxx/sensors.cpp
- //
- // For dynamic sensors, this string will be provided in a separate way.
- //
- // NB: Vendors and manufacturers should make the name of the sensor as
- // specific as possible, since if multiple sensors with the same name are
- // connected, the first will be used.
- optional string accelerometer = 5;
- optional string gyroscope = 6;
-}
-
-/**
- * Message describing the additional properties of a Daydream-ready headset that
- * are not used for a normal cardboard viewer. These parameters are not intended
- * to be used, or consumed, by developers and may or may not be supported or
- * changed without notice on new releases of the Cardboard SDK or VR Toolkit.
- */
-message DaydreamInternalParams {
- // The version of the Daydream-ready specification to which this device
- // conforms.
- optional int32 version = 1;
-
- // Optionally, specifies the collection of screen alignment markers in the
- // headset.
- repeated ScreenAlignmentMarker alignment_markers = 2;
-}
-
-/**
- * Message describing a single screen alignment marker.
- *
- * A screen alignment marker is a capacitive touch point affixed to the headset
- * which is capable of making contact with the screen. The location of the touch
- * point is given in meters, measured along a horizontal axis which passes
- * through the center of both lenses, and a vertical axis which is equidistant
- * from the centers of the lenses. A positive vertical value indicates that the
- * point lies above the horizontal axis, and a positive horizontal value
- * indicates that the point lies to the right, as seen by a user of the headset,
- * of the vertical axis. For example, if the following is a representation of a
- * headset, viewed from the point of view of a user, with three points marked by
- * the numbers 1, 2, and 3.
- *
- * *****************************************************************************
- * * ^ *
- * * _____ | _____ *
- * * / \ 1 / \ *
- * * / \ | / \ *
- * * / \ | / \ *
- * * / \ | / \ *
- * * / \ | / \ *
- * *---------|-------*-------|----------+------2---|-------*-------|---------->*
- * * \ / | \ / *
- * * \ / | \ / *
- * * \ / 3 | \ / *
- * * \ / | \ / *
- * * \_____/ | \_____/ *
- * * | *
- * * | *
- * *****************************************************************************
- *
- * Then the coordinates of point 1 could be horizontal = 0.0, vertical = 0.035;
- * point 2 could be horizontal = 0.02; and point 3 could be horizontal = -0.01
- * vertical = -0.012
- */
-message ScreenAlignmentMarker {
- // The horizontal coordinate of the touch point.
- optional float horizontal = 1;
-
- // The vertical coordinate of the touch point.
- optional float vertical = 2;
-}
diff --git a/libs/vr/libgvr/dummy_gvr_ext.cpp b/libs/vr/libgvr/dummy_gvr_ext.cpp
deleted file mode 100644
index f73838d..0000000
--- a/libs/vr/libgvr/dummy_gvr_ext.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include <log/log.h>
-#include <vr/gvr/capi/include/gvr.h>
-#include <vr/gvr/capi/include/gvr_ext.h>
-#include <vr/gvr/capi/include/gvr_types.h>
-
-gvr_frame_schedule* gvr_frame_schedule_create() { return NULL; }
-
-void gvr_frame_schedule_destroy(gvr_frame_schedule** /* schedule */) {}
-
-uint32_t gvr_frame_schedule_get_vsync_count(
- gvr_frame_schedule* /* schedule */) {
- return 0;
-}
-
-gvr_mat4f gvr_get_6dof_head_pose_in_start_space(gvr_context* gvr,
- uint32_t /* vsync_count */) {
- LOG_ALWAYS_FATAL("gvr_get_6dof_head_pose_in_start_space is not implemented. "
- "Use gvr_get_head_space_from_start_space_pose instead.");
- return gvr_mat4f({{{1.0f, 0.0f, 0.0f, 0.0f},
- {0.0f, 1.0f, 0.0f, 0.0f},
- {0.0f, 0.0f, 1.0f, 0.0f},
- {0.0f, 0.0f, 0.0f, 1.0f}}});
-}
-
-void gvr_wait_next_frame(gvr_swap_chain* /* swap_chain */,
- int64_t /* sched_offset_nanos */,
- gvr_frame_schedule* /* out_next_frame_schedule */) {
- LOG_ALWAYS_FATAL("gvr_wait_next_frame is not implemented.");
-}
diff --git a/libs/vr/libgvr/exported_apis.lds b/libs/vr/libgvr/exported_apis.lds
deleted file mode 100644
index 2d19303..0000000
--- a/libs/vr/libgvr/exported_apis.lds
+++ /dev/null
@@ -1,16 +0,0 @@
-{
- global:
- # Export GVR APIs, both public and private.
- gvr_*;
-
- # Whitelist of DVR APIs required by VrCore for Ambrosia controller support.
- dvrPoseCreate;
- dvrPoseDestroy;
- dvrPoseGet;
- dvrPoseGetController;
- dvrPoseGetVsyncCount;
-
- local:
- # Hide everything else.
- *;
-};
diff --git a/libs/vr/libgvr/include/private/dvr/internal_types.h b/libs/vr/libgvr/include/private/dvr/internal_types.h
deleted file mode 100644
index dafdb73..0000000
--- a/libs/vr/libgvr/include/private/dvr/internal_types.h
+++ /dev/null
@@ -1,170 +0,0 @@
-#ifndef ANDROID_DVR_INTERNAL_TYPES_H_
-#define ANDROID_DVR_INTERNAL_TYPES_H_
-
-#include <GLES2/gl2.h>
-#include <atomic>
-#include <memory>
-#include <vector>
-#include <unordered_map>
-
-#include <dvr/graphics.h>
-#include <dvr/pose_client.h>
-#include <gui/Surface.h>
-#include <private/dvr/buffer_hub_queue_core.h>
-#include <private/dvr/display_client.h>
-#include <vr/gvr/capi/include/gvr.h>
-#include <vr/gvr/capi/include/gvr_types.h>
-#include <vr/gvr/capi/src/gvr_types_experimental.h>
-
-typedef struct gvr_user_prefs_ {
-} gvr_user_prefs;
-
-typedef struct gvr_context_ {
- int32_t last_error_;
- JNIEnv* jni_env_;
- DvrPose* pose_client_;
- std::unique_ptr<android::dvr::DisplayClient> display_client_;
- android::dvr::SystemDisplayMetrics display_metrics_;
- gvr_mat4f left_eye_viewport_transform_;
- gvr_mat4f right_eye_viewport_transform_;
- gvr_mat4f next_frame_6dof_pose_;
- gvr_mat4f next_frame_controller_pose_[2];
- gvr_user_prefs user_prefs_;
- bool force_6dof_;
- std::vector<gvr_swap_chain*> swap_chains_;
-
- gvr_context_() :
- last_error_(GVR_ERROR_NONE),
- jni_env_(nullptr),
- pose_client_(nullptr),
- force_6dof_(false) {}
-
- ~gvr_context_();
-} gvr_context;
-
-typedef struct gvr_buffer_spec_ {
- gvr_sizei size;
- int32_t msaa_samples;
- int32_t color_format;
- int32_t depth_stencil_format;
- bool blur_behind;
- bool initially_visible;
- int z_order;
-
- // The default values are configured to match SVR defaults
- gvr_buffer_spec_()
- : size{0, 0},
- msaa_samples(0),
- color_format(GVR_COLOR_FORMAT_RGBA_8888),
- depth_stencil_format(GVR_DEPTH_STENCIL_FORMAT_DEPTH_16),
- blur_behind(true),
- initially_visible(true),
- z_order(0) {}
-} gvr_buffer_spec;
-
-// This isn't a public gvr type
-struct gvr_buffer {
- gvr_buffer_spec spec;
- GLuint frame_buffer;
- GLuint color_render_buffer;
- GLuint depth_stencil_render_buffer;
-
- // requested_size is used for resizing. It will be {-1, -1} when no resize is
- // requested. Any other value indicates the app changed the size.
- gvr_sizei requested_size;
-
- gvr_buffer();
- // If creation fails frame_buffer will be 0
- gvr_buffer(gvr_context* gvr, const gvr_buffer_spec& spec,
- GLuint texture_id, GLenum texture_target);
- ~gvr_buffer();
-
- gvr_buffer(gvr_buffer&& other);
- gvr_buffer& operator=(gvr_buffer&& other);
- gvr_buffer(const gvr_buffer& other) = delete;
- gvr_buffer& operator=(const gvr_buffer& other) = delete;
-
- // Set default values. Doesn't free GL resources first.
- void SetDefaults();
-
- // Frees all GL resources associated with the buffer
- void FreeGl();
-};
-
-typedef struct gvr_swap_chain_ {
- gvr_context* context;
- DvrGraphicsContext* graphics_context_;
- std::vector<gvr_buffer> buffers_;
- bool frame_acquired_;
- bool wait_next_frame_called_by_app_;
- std::atomic<int32_t> next_external_surface_id_;
- std::unordered_map<int32_t, gvr_external_surface*> external_surfaces_;
-
- explicit gvr_swap_chain_(gvr_context* context)
- : context(context),
- graphics_context_(nullptr),
- frame_acquired_(false),
- wait_next_frame_called_by_app_(false),
- next_external_surface_id_(0) {}
- ~gvr_swap_chain_();
-} gvr_swap_chain;
-
-typedef struct gvr_buffer_viewport_ {
- int32_t buffer_index;
- gvr_rectf uv;
- gvr_mat4f transform;
- int32_t eye;
- int32_t external_surface_id;
- gvr_reprojection reprojection;
-
- gvr_buffer_viewport_()
- : buffer_index(0),
- uv{0, 0, 0, 0},
- transform{{{1.f, 0.f, 0.f, 0.f},
- {0.f, 1.f, 0.f, 0.f},
- {0.f, 0.f, 1.f, 0.f},
- {0.f, 0.f, 0.f, 1.f}}},
- eye(0),
- external_surface_id(-1),
- reprojection(GVR_REPROJECTION_FULL) {}
-
- gvr_buffer_viewport_(int32_t /* buffer_index */, gvr_rectf uv,
- const gvr_mat4f& transform, int32_t eye,
- int32_t external_surface_id,
- gvr_reprojection reprojection)
- : buffer_index(0),
- uv(uv),
- transform(transform),
- eye(eye),
- external_surface_id(external_surface_id),
- reprojection(reprojection) {}
-
- bool operator==(const gvr_buffer_viewport_& other) const;
-
- bool operator!=(const gvr_buffer_viewport_& other) const {
- return !operator==(other);
- }
-} gvr_buffer_viewport;
-
-typedef struct gvr_buffer_viewport_list_ {
- std::vector<gvr_buffer_viewport> viewports;
-} gvr_buffer_viewport_list;
-
-typedef struct gvr_frame_schedule_ {
- uint32_t vsync_count;
- gvr_clock_time_point scheduled_finish;
-
- gvr_frame_schedule_() : vsync_count(0) {
- scheduled_finish.monotonic_system_time_nanos = 0;
- }
-} gvr_frame_schedule;
-
-typedef struct gvr_display_synchronizer_ {} gvr_display_synchronizer;
-
-typedef struct gvr_external_surface_ {
- int32_t id;
- gvr_swap_chain* swap_chain;
- DvrVideoMeshSurface* video_surface;
-} gvr_external_surface;
-
-#endif // ANDROID_DVR_INTERNAL_TYPES_H_
diff --git a/libs/vr/libgvr/include/vr/gvr/capi/include/gvr_ext.h b/libs/vr/libgvr/include/vr/gvr/capi/include/gvr_ext.h
deleted file mode 100644
index 8af434f..0000000
--- a/libs/vr/libgvr/include/vr/gvr/capi/include/gvr_ext.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/* Copyright 2016 Google Inc. All rights reserved.
- *
- * 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 VR_GVR_CAPI_INCLUDE_GVR_EXT_H_
-#define VR_GVR_CAPI_INCLUDE_GVR_EXT_H_
-
-#include <stdbool.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/// Constants that represent GVR error codes.
-typedef enum {
- // TODO(steventhomas): All errors should be switched to something more
- // meaningful and this should eventually go away.
- GVR_ERROR_INTERNAL = 9000,
-} gvr_error_ext;
-
-typedef struct gvr_frame_schedule_ gvr_frame_schedule;
-
-gvr_frame_schedule* gvr_frame_schedule_create();
-
-void gvr_frame_schedule_destroy(gvr_frame_schedule** schedule);
-
-uint32_t gvr_frame_schedule_get_vsync_count(gvr_frame_schedule* schedule);
-
-gvr_clock_time_point gvr_frame_schedule_get_scheduled_finish(
- gvr_frame_schedule* schedule);
-
-/// Sleep until it's time to render the next frame.
-// |start_delay_ns| adjusts how long this function blocks the app from starting
-// its next frame. If |start_delay_ns| is 0, the function waits until the
-// scheduled frame finish time for the current frame, which gives the app one
-// full vsync period to render the next frame. If the app needs less than a full
-// vysnc period to render the frame, pass in a non-zero |start_delay_ns| to
-// delay the start of frame rendering further. For example, if the vsync period
-// is 11.1ms and the app takes 6ms to render a frame, consider setting this to
-// 5ms (note that the value is in nanoseconds, so 5,000,000ns) so that the app
-// finishes the frame closer to the scheduled frame finish time. Delaying the
-// start of rendering allows the app to use a more up-to-date pose for
-// rendering.
-// |start_delay_ns| must be a positive value or 0. If you're unsure what to set
-// for |start_delay_ns|, use 0.
-/// |out_next_frame_schedule| is an output parameter that will contain the
-/// schedule for the next frame. It can be null.
-void gvr_wait_next_frame(gvr_swap_chain* swap_chain, int64_t start_delay_nanos,
- gvr_frame_schedule* out_next_frame_schedule);
-
-gvr_mat4f gvr_get_6dof_head_pose_in_start_space(gvr_context* gvr,
- uint32_t vsync_count);
-
-gvr_mat4f gvr_get_head_space_from_start_space_pose(
- gvr_context* gvr, const gvr_clock_time_point time);
-
-gvr_mat4f gvr_get_start_space_from_controller_space_pose(
- gvr_context* gvr, int controller_id, const gvr_clock_time_point time);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-#include <utility>
-
-namespace gvr {
-
-/// Convenience C++ wrapper for gvr_frame_schedule. Frees the underlying
-/// gvr_frame_schedule on destruction.
-class FrameSchedule {
- public:
- FrameSchedule() { schedule_ = gvr_frame_schedule_create(); }
-
- ~FrameSchedule() {
- if (schedule_)
- gvr_frame_schedule_destroy(&schedule_);
- }
-
- FrameSchedule(FrameSchedule&& other) {
- std::swap(schedule_, other.schedule_);
- }
-
- FrameSchedule& operator=(FrameSchedule&& other) {
- std::swap(schedule_, other.schedule_);
- return *this;
- }
-
- gvr_frame_schedule* cobj() { return schedule_; }
- const gvr_frame_schedule* cobj() const { return schedule_; }
-
- uint32_t GetVsyncCount() const {
- return gvr_frame_schedule_get_vsync_count(schedule_);
- }
-
- gvr_clock_time_point GetScheduledFinish() const {
- return gvr_frame_schedule_get_scheduled_finish(schedule_);
- }
-
- private:
- gvr_frame_schedule* schedule_;
-};
-
-} // namespace gvr
-#endif // #if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-
-#endif // VR_GVR_CAPI_INCLUDE_GVR_EXT_H_
diff --git a/libs/vr/libgvr/include/vr/gvr/capi/include/gvr_util.h b/libs/vr/libgvr/include/vr/gvr/capi/include/gvr_util.h
deleted file mode 100644
index 1fae611..0000000
--- a/libs/vr/libgvr/include/vr/gvr/capi/include/gvr_util.h
+++ /dev/null
@@ -1,123 +0,0 @@
-#ifndef VR_GVR_CAPI_INCLUDE_GVR_UTIL_H_
-#define VR_GVR_CAPI_INCLUDE_GVR_UTIL_H_
-
-#include <private/dvr/eigen.h>
-#include <private/dvr/numeric.h>
-#include <private/dvr/types.h>
-#include <vr/gvr/capi/include/gvr_types.h>
-
-namespace android {
-namespace dvr {
-
-inline gvr_rectf FovRadiansToDegrees(const gvr_rectf& fov) {
- return gvr_rectf{ToDeg(fov.left), ToDeg(fov.right), ToDeg(fov.bottom),
- ToDeg(fov.top)};
-}
-
-inline gvr_rectf FovDegreesToRadians(const gvr_rectf& fov) {
- return gvr_rectf{ToRad(fov.left), ToRad(fov.right), ToRad(fov.bottom),
- ToRad(fov.top)};
-}
-
-inline FieldOfView GvrToDvrFov(const gvr_rectf& fov) {
- gvr_rectf fov_rad = FovDegreesToRadians(fov);
- return FieldOfView(fov_rad.left, fov_rad.right, fov_rad.bottom, fov_rad.top);
-}
-
-inline gvr_rectf DvrToGvrFov(const FieldOfView& fov) {
- return FovRadiansToDegrees(
- gvr_rectf{fov.GetLeft(), fov.GetRight(), fov.GetBottom(), fov.GetTop()});
-}
-
-inline gvr_mat4f GvrIdentityMatrix() {
- gvr_mat4f identity;
- memset(&identity.m, 0, sizeof(identity.m));
- for (int i = 0; i < 4; i++)
- identity.m[i][i] = 1;
- return identity;
-}
-
-inline gvr_mat4f GvrTranslationMatrix(float x, float y, float z) {
- gvr_mat4f trans = GvrIdentityMatrix();
- trans.m[0][3] = x;
- trans.m[1][3] = y;
- trans.m[2][3] = z;
- return trans;
-}
-
-inline gvr_mat4f EigenToGvrMatrix(const mat4& m) {
- gvr_mat4f ret;
- for (int i = 0; i < 4; ++i)
- for (int j = 0; j < 4; ++j)
- ret.m[i][j] = m(i, j);
- return ret;
-}
-
-inline mat4 GvrToEigenMatrix(const gvr::Mat4f& m) {
- mat4 ret;
- for (int i = 0; i < 4; ++i)
- for (int j = 0; j < 4; ++j)
- ret(i, j) = m.m[i][j];
- return ret;
-}
-
-inline quat GvrToEigenRotation(const gvr_mat4f& m) {
- mat3 ret;
- for (int r = 0; r < 3; ++r)
- for (int c = 0; c < 3; ++c)
- ret(r, c) = m.m[r][c];
- return quat(ret.matrix());
-}
-
-inline vec3 GvrToEigenTranslation(const gvr_mat4f& m) {
- return vec3(m.m[0][3], m.m[1][3], m.m[2][3]);
-}
-
-// Converts a DVR pose to 6DOF head transform as a GVR matrix.
-inline gvr_mat4f PosefToGvrMatrix(const Posef& pose) {
- return EigenToGvrMatrix(pose.GetObjectFromReferenceMatrix());
-}
-
-// Converts a DVR pose to 3DOF head transform as a GVR matrix by stripping out
-// position translation.
-inline gvr_mat4f PosefTo3DofGvrMatrix(const Posef& pose) {
- gvr_mat4f ret = PosefToGvrMatrix(pose);
- ret.m[0][3] = 0;
- ret.m[1][3] = 0;
- ret.m[2][3] = 0;
- return ret;
-}
-
-// Converts a GVR matrix to a DVR pose.
-inline Posef GvrMatrixToPosef(const gvr_mat4f& m) {
- return Posef(GvrToEigenRotation(m), GvrToEigenTranslation(m)).Inverse();
-}
-
-// Calculates an transform with only the yaw and position components of |pose|.
-// The inverse of this matrix cancels yaw and position without affecting roll or
-// pitch.
-inline mat4 CalculateRecenterTransform(const mat4& pose) {
- const vec4 z_axis = pose * vec4::UnitZ();
- const float yaw = std::atan2(z_axis[0], z_axis[2]);
- const vec3 position = pose.translation();
- return mat4(Eigen::AngleAxis<float>(yaw, vec3::UnitY())).translate(position);
-}
-
-// Calculates a transform that negates the position component of |pose| and
-// offsets the pose by |position|. The inverse of this matrix cancels the
-// position component of pose and translates by |position| without affecting
-// orientation.
-inline mat4 CalculateOffsetTransform(const mat4& pose, const vec3& position) {
- // Transform the origin by the pose matrix to produce the offset that cancels
- // only the position of the pose.
- // -1 T
- // [ R | t ] [ 0 ] = -R * t
- // [ 0 1 ] [ 1 ]
- const vec3 position_offset = (pose.inverse() * vec4(0, 0, 0, 1)).head<3>();
- return mat4(mat4::Identity()).translate(position - position_offset);
-}
-
-} // namespace dvr
-} // namespace android
-
-#endif // VR_GVR_CAPI_INCLUDE_GVR_UTIL_H_
diff --git a/libs/vr/libgvr/java/com/google/vr/gvr/platform/Loader.java b/libs/vr/libgvr/java/com/google/vr/gvr/platform/Loader.java
deleted file mode 100644
index 381175c..0000000
--- a/libs/vr/libgvr/java/com/google/vr/gvr/platform/Loader.java
+++ /dev/null
@@ -1,38 +0,0 @@
-package com.google.vr.gvr.platform;
-
-import android.os.SystemProperties;
-
-/**
- * Auxiliary class to load the system implementation of the GVR API.
- * @hide
- */
-public class Loader {
-
- private static final String VR_MODE_BOOT = "ro.boot.vr";
-
- /**
- * Opens a shared library containing the system implementation for the GVR API and returns the
- * handle to it.
- *
- * @return A Long object describing the handle returned by dlopen.
- */
- public static Long loadLibrary() {
- // Note: caller verifications cannot be safely done here. Any app can find and use this API.
- // Any sensitive functions must have appropriate checks on the service side.
-
- // Load a thin JNI library that runs dlopen on request.
- System.loadLibrary("gvr_system_loader");
-
- // Performs dlopen on the library and returns the handle.
- return nativeLoadLibrary("libgvr_system.so");
- }
-
- /**
- * Returns true if this device boots directly in VR mode.
- */
- public static boolean getVrBoot() {
- return SystemProperties.getBoolean(VR_MODE_BOOT, false);
- }
-
- private static native long nativeLoadLibrary(String library);
-}
diff --git a/libs/vr/libgvr/library_loader.cpp b/libs/vr/libgvr/library_loader.cpp
deleted file mode 100644
index 3cdc7d6..0000000
--- a/libs/vr/libgvr/library_loader.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include <dlfcn.h>
-#include <jni.h>
-
-#include <string>
-
-extern "C" {
-
-JNIEXPORT jlong JNICALL
-Java_com_google_vr_gvr_platform_Loader_nativeLoadLibrary(
- JNIEnv* env, jclass, jstring java_library) {
- if (!java_library)
- return 0;
-
- // Convert the Java String object to a C++ null-terminated string.
- const char* data = env->GetStringUTFChars(java_library, NULL);
- size_t size = env->GetStringUTFLength(java_library);
- std::string library(data, size);
- env->ReleaseStringUTFChars(java_library, data);
-
- // Return the handle to the requested library.
- return reinterpret_cast<jlong>(
- dlopen(library.c_str(), RTLD_NOW | RTLD_LOCAL));
-}
-
-} // extern "C"
diff --git a/libs/vr/libgvr/prebuilt/build_gvr_prebuilts.sh b/libs/vr/libgvr/prebuilt/build_gvr_prebuilts.sh
deleted file mode 100755
index 8e6ca2d..0000000
--- a/libs/vr/libgvr/prebuilt/build_gvr_prebuilts.sh
+++ /dev/null
@@ -1,93 +0,0 @@
-#!/bin/bash
-# Build and copy libgvr from Google3. Make sure that your local Google3 client
-# is up-to-date by running `p4 sync` before executing this script.
-#
-# Usage:
-# build_gvr_prebuilts.sh --google3_dir=<path_google3_client_root>
-
-source gbash.sh || exit
-
-DEFINE_string --required "google3_dir" "" \
- "Path to the root directory of Google3 client"
-
-BLAZE_COMMON_OPTS=(
- --compilation_mode=opt
- --copt=-fdata-sections
- --copt=-ffunction-sections
- --define='prod=1'
- --define='enable_experimental_sdk=1'
- --linkopt=-Wl,--gc-sections
-)
-
-function copy_file() {
- cp -v "${1}" ${CURRENT_DIR}/"${2}"
-}
-
-function copy_gvr_headers() {
- echo "Copy GVR headers ..."
-
- GVR_HEADER_DIR="include/vr/gvr/capi/include"
- GVR_SOURCE_DIR="include/vr/gvr/capi/src"
-
- # GVR public headers
- copy_file "vr/gvr/capi/include/gvr.h" ${GVR_HEADER_DIR}
- copy_file "vr/gvr/capi/include/gvr_audio.h" ${GVR_HEADER_DIR}
- copy_file "vr/gvr/capi/include/gvr_controller.h" ${GVR_HEADER_DIR}
- copy_file "vr/gvr/capi/include/gvr_types.h" ${GVR_HEADER_DIR}
-
- # GVR private and experimental headers
- copy_file "vr/gvr/capi/src/gvr_experimental.h" ${GVR_SOURCE_DIR}
- copy_file "vr/gvr/capi/src/gvr_private.h" ${GVR_SOURCE_DIR}
- copy_file "vr/gvr/capi/src/gvr_types_experimental.h" ${GVR_SOURCE_DIR}
-}
-
-function build_gvr_libs() {
- echo "Build GVR libraries ..."
-
- blaze build \
- //java/com/google/vr/sdk/release:common_library.aar \
- //vr/gvr/platform:libgvr.so \
- //vr/gvr/platform:libgvr_audio.so \
- ${BLAZE_COMMON_OPTS[@]} --config=android_arm --symlink_prefix blaze-arm-
-
- blaze build \
- //vr/gvr/platform:libgvr.so \
- //vr/gvr/platform:libgvr_audio.so \
- ${BLAZE_COMMON_OPTS[@]} --config=android_arm64 --symlink_prefix blaze-arm64-
-
- blaze build \
- //java/com/google/vr/sdk/release:common_library.aar \
- //vr/gvr/platform:libgvr.so \
- //vr/gvr/platform:libgvr_audio.so \
- ${BLAZE_COMMON_OPTS[@]} --config=android_x86 --symlink_prefix blaze-x86-
-
- blaze build \
- //vr/gvr/platform:libgvr.so \
- //vr/gvr/platform:libgvr_audio.so \
- ${BLAZE_COMMON_OPTS[@]} --config=android_x86_64 --symlink_prefix blaze-x86_64-
-
- copy_file "blaze-arm-genfiles/java/com/google/vr/sdk/release/common_library.aar" \
- "lib/common_library.aar"
- copy_file "blaze-arm-genfiles/vr/gvr/platform/libgvr.so" "lib/android_arm"
- copy_file "blaze-arm-genfiles/vr/gvr/platform/libgvr_audio.so" "lib/android_arm"
- copy_file "blaze-arm64-genfiles/vr/gvr/platform/libgvr.so" "lib/android_arm64"
- copy_file "blaze-arm64-genfiles/vr/gvr/platform/libgvr_audio.so" "lib/android_arm64"
- copy_file "blaze-x86-genfiles/vr/gvr/platform/libgvr.so" "lib/android_x86"
- copy_file "blaze-x86-genfiles/vr/gvr/platform/libgvr_audio.so" "lib/android_x86"
- copy_file "blaze-x86_64-genfiles/vr/gvr/platform/libgvr.so" "lib/android_x86_64"
- copy_file "blaze-x86_64-genfiles/vr/gvr/platform/libgvr_audio.so" "lib/android_x86_64"
-}
-
-function main() {
- set -ex
-
- CURRENT_DIR=$(pwd)
- GOOGLE3_DIR=${FLAGS_google3_dir}
-
- cd ${GOOGLE3_DIR}
- copy_gvr_headers
- build_gvr_libs
-}
-
-gbash::init_google "$@"
-main "$@"
diff --git a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr.h b/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr.h
deleted file mode 100644
index c459eca..0000000
--- a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr.h
+++ /dev/null
@@ -1,1751 +0,0 @@
-/* Copyright 2016 Google Inc. All rights reserved.
- *
- * 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 VR_GVR_CAPI_INCLUDE_GVR_H_
-#define VR_GVR_CAPI_INCLUDE_GVR_H_
-
-#ifdef __ANDROID__
-#include <jni.h>
-#endif
-
-#include <stdint.h>
-#include <stdlib.h>
-
-#if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-#include <array>
-#include <memory>
-#include <vector>
-#endif
-
-#include "vr/gvr/capi/include/gvr_types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/// @defgroup base Google VR Base C API
-/// @brief This is the Google VR C API. It supports clients writing VR
-/// experiences for head mounted displays that consist of a mobile phone and a
-/// VR viewer.
-///
-/// Example API usage:
-///
-/// #ifdef __ANDROID__
-/// // On Android, the gvr_context should almost always be obtained from
-/// // the Java GvrLayout object via
-/// // GvrLayout.getGvrApi().getNativeGvrContext().
-/// gvr_context* gvr = ...;
-/// #else
-/// gvr_context* gvr = gvr_create();
-/// #endif
-///
-/// gvr_initialize_gl(gvr);
-///
-/// gvr_buffer_viewport_list* viewport_list =
-/// gvr_buffer_viewport_list_create(gvr);
-/// gvr_get_recommended_buffer_viewports(gvr, viewport_list);
-/// gvr_buffer_viewport* left_eye_vp = gvr_buffer_viewport_create(gvr);
-/// gvr_buffer_viewport* right_eye_vp = gvr_buffer_viewport_create(gvr);
-/// gvr_buffer_viewport_list_get_item(viewport_list, 0, left_eye_vp);
-/// gvr_buffer_viewport_list_get_item(viewport_list, 1, right_eye_vp);
-///
-/// while (client_app_should_render) {
-/// // A client app should be ready for the render target size to change
-/// // whenever a new QR code is scanned, or a new viewer is paired.
-/// gvr_sizei render_target_size =
-/// gvr_get_maximum_effective_render_target_size(gvr);
-/// // The maximum effective render target size can be very large, most
-/// // applications need to scale down to compensate.
-/// render_target_size.width /= 2;
-/// render_target_size.height /= 2;
-/// gvr_swap_chain_resize_buffer(swap_chain, 0, render_target_size);
-///
-/// // This function will depend on your render loop's implementation.
-/// gvr_clock_time_point next_vsync = AppGetNextVsyncTime();
-///
-/// const gvr_mat4f head_view =
-/// gvr_get_head_space_from_start_space_rotation(gvr, next_vsync);
-/// const gvr_mat4f left_eye_view = MatrixMultiply(
-/// gvr_get_eye_from_head_matrix(gvr, GVR_LEFT_EYE), head_view);
-/// const gvr::Mat4f right_eye_view = MatrixMultiply(
-/// gvr_get_eye_from_head_matrix(gvr, GVR_RIGHT_EYE), head_view);
-///
-/// // Insert client rendering code here.
-///
-/// AppSetRenderTarget(offscreen_texture_id);
-///
-/// AppDoSomeRenderingForEye(
-/// gvr_buffer_viewport_get_source_uv(left_eye_view),
-/// left_eye_matrix);
-/// AppDoSomeRenderingForEye(
-/// gvr_buffer_viewport_get_source_uv(right_eye_view),
-/// right_eye_matrix);
-/// AppSetRenderTarget(primary_display);
-///
-/// gvr_frame_submit(&frame, viewport_list, head_matrix);
-/// }
-///
-/// // Cleanup memory.
-/// gvr_buffer_viewport_list_destroy(&viewport_list);
-/// gvr_buffer_viewport_destroy(&left_eye_vp);
-/// gvr_buffer_viewport_destroy(&right_eye_vp);
-///
-/// #ifdef __ANDROID__
-/// // On Android, The Java GvrLayout owns the gvr_context.
-/// #else
-/// gvr_destroy(gvr);
-/// #endif
-///
-/// Head tracking is enabled by default, and will begin as soon as the
-/// gvr_context is created. The client should call gvr_pause_tracking() and
-/// gvr_resume_tracking() when the app is paused and resumed, respectively.
-///
-/// Note: Unless otherwise noted, the functions in this API may not be
-/// thread-safe with respect to the gvr_context, and it is up the caller to use
-/// the API in a thread-safe manner.
-///
-/// @{
-
-/// Creates a new gvr instance.
-///
-/// The instance must remain valid as long as any GVR object is in use. When
-/// the application no longer needs to use the GVR SDK, call gvr_destroy().
-///
-///
-/// On Android, the gvr_context should *almost always* be obtained from the Java
-/// GvrLayout object, rather than explicitly created here. The GvrLayout should
-/// live in the app's View hierarchy, and its use is required to ensure
-/// consistent behavior across all varieties of GVR-compatible viewers. See
-/// the Java GvrLayout and GvrApi documentation for more details.
-///
-#ifdef __ANDROID__
-/// @param env The JNIEnv associated with the current thread.
-/// @param app_context The Android application context. This must be the
-/// application context, NOT an Activity context (Note: from any Android
-/// Activity in your app, you can call getApplicationContext() to
-/// retrieve the application context).
-/// @param class_loader The class loader to use when loading Java classes.
-/// This must be your app's main class loader (usually accessible through
-/// activity.getClassLoader() on any of your Activities).
-///
-/// @return Pointer to the created gvr instance, NULL on failure.
-gvr_context* gvr_create(JNIEnv* env, jobject app_context, jobject class_loader);
-#else
-/// @return Pointer to the created gvr instance, NULL on failure.
-gvr_context* gvr_create();
-#endif // #ifdef __ANDROID__
-
-/// Gets the current GVR runtime version.
-///
-/// Note: This runtime version may differ from the version against which the
-/// client app is compiled, as defined by the semantic version components in
-/// gvr_version.h.
-///
-/// @return The version as a gvr_version.
-gvr_version gvr_get_version();
-
-/// Gets a string representation of the current GVR runtime version. This is of
-/// the form "MAJOR.MINOR.PATCH".
-///
-/// Note: This runtime version may differ from the version against which the
-/// client app is compiled, as defined in gvr_version.h by
-/// GVR_SDK_VERSION_STRING.
-///
-/// @return The version as a static char pointer.
-const char* gvr_get_version_string();
-
-/// Gets the current GVR error code, or GVR_ERROR_NONE if there is no error.
-/// This function doesn't clear the error code; see gvr_clear_error().
-///
-/// @param gvr Pointer to the gvr instance.
-/// @return The current gvr_error code, or GVR_ERROR_NONE if no error has
-/// occurred.
-int32_t gvr_get_error(gvr_context* gvr);
-
-/// Clears the current GVR error code, and returns the error code that was
-/// cleared.
-///
-/// @param gvr Pointer to the gvr instance.
-/// @return The gvr_error code that was cleared by this function, or
-/// GVR_ERROR_NONE if no error has occurred.
-int32_t gvr_clear_error(gvr_context* gvr);
-
-/// Gets a human-readable string representing the given error code.
-///
-/// @param error_code The gvr_error code.
-/// @return A human-readable string representing the error code.
-const char* gvr_get_error_string(int32_t error_code);
-
-/// Returns an opaque struct containing information about user preferences.
-///
-/// The returned struct will remain valid as long as the context is valid.
-/// The returned struct may be updated when the user changes their preferences,
-/// so this function only needs to be called once, and calling it multiple
-/// times will return the same object each time.
-///
-/// @param gvr Pointer to the gvr instance.
-/// @return An opaque struct containing information about user preferences.
-const gvr_user_prefs* gvr_get_user_prefs(gvr_context* gvr);
-
-/// Returns the controller handedness of the given gvr_user_prefs struct.
-///
-/// @param user_prefs Pointer to the gvr_user_prefs object returned by
-/// gvr_get_user_prefs.
-/// @return Either GVR_CONTROLLER_RIGHT_HANDED or GVR_CONTROLLER_LEFT_HANDED
-/// depending on which hand the user holds the controller in.
-int32_t gvr_user_prefs_get_controller_handedness(
- const gvr_user_prefs* user_prefs);
-
-/// Destroys a gvr_context instance. The parameter will be nulled by this
-/// operation. Once this function is called, the behavior of any subsequent
-/// call to a GVR SDK function that references objects created from this
-/// context is undefined.
-///
-/// @param gvr Pointer to a pointer to the gvr instance to be destroyed and
-/// nulled.
-void gvr_destroy(gvr_context** gvr);
-
-/// Initializes necessary GL-related objects and uses the current thread and
-/// GL context for rendering. Please make sure that a valid GL context is
-/// available when this function is called. This should never be called more
-/// than once on the same GL context (doing so would cause resource leaks).
-///
-/// @param gvr Pointer to the gvr instance to be initialized.
-void gvr_initialize_gl(gvr_context* gvr);
-
-/// Gets whether asynchronous reprojection is currently enabled.
-///
-/// If enabled, frames will be collected by the rendering system and
-/// asynchronously re-projected in sync with the scanout of the display. This
-/// feature may not be available on every platform, and requires a
-/// high-priority render thread with special extensions to function properly.
-///
-/// Note: On Android, this feature can be enabled solely via the GvrLayout Java
-/// instance which (indirectly) owns this gvr_context. The corresponding
-/// method call is GvrLayout.setAsyncReprojectionEnabled().
-///
-/// Note: Because of the above requirements, asynchronous reprojection is only
-/// currently available on Daydream-ready Android devices. This function will
-/// always return false on other devices.
-///
-/// @param gvr Pointer to the gvr instance.
-/// @return Whether async reprojection is enabled. Defaults to false.
-bool gvr_get_async_reprojection_enabled(const gvr_context* gvr);
-
-/// Gets the recommended buffer viewport configuration, populating a previously
-/// allocated gvr_buffer_viewport_list object. The updated values include the
-/// per-eye recommended viewport and field of view for the target.
-///
-/// When the recommended viewports are used for distortion rendering, this
-/// method should always be called after calling refresh_viewer_profile(). That
-/// will ensure that the populated viewports reflect the currently paired
-/// viewer.
-///
-/// @param gvr Pointer to the gvr instance from which to get the viewports.
-/// @param viewport_list Pointer to a previously allocated viewport list. This
-/// will be populated with the recommended buffer viewports and resized if
-/// necessary.
-void gvr_get_recommended_buffer_viewports(
- const gvr_context* gvr, gvr_buffer_viewport_list* viewport_list);
-
-/// Gets the screen (non-distorted) buffer viewport configuration, populating a
-/// previously allocated gvr_buffer_viewport_list object. The updated values
-/// include the per-eye recommended viewport and field of view for the target.
-///
-/// @param gvr Pointer to the gvr instance from which to get the viewports.
-/// @param viewport_list Pointer to a previously allocated viewport list. This
-/// will be populated with the screen buffer viewports and resized if
-/// necessary.
-void gvr_get_screen_buffer_viewports(const gvr_context* gvr,
- gvr_buffer_viewport_list* viewport_list);
-
-/// Returns the maximum effective size for the client's render target, given the
-/// parameters of the head mounted device selected. At this resolution, we have
-/// a 1:1 ratio between source pixels and screen pixels in the most magnified
-/// region of the screen. Applications should rarely, if ever, need to render
-/// to a larger target, as it will simply result in sampling artifacts.
-///
-/// Note that this is probably too large for most applications to use as a
-/// render target size. Applications should scale this value to be appropriate
-/// to their graphical load.
-///
-/// @param gvr Pointer to the gvr instance from which to get the size.
-///
-/// @return Maximum effective size for the target render target.
-gvr_sizei gvr_get_maximum_effective_render_target_size(const gvr_context* gvr);
-
-/// Returns a non-distorted size for the screen, given the parameters
-/// of the phone and/or the head mounted device selected.
-///
-/// @param gvr Pointer to the gvr instance from which to get the size.
-///
-/// @return Screen (non-distorted) size for the render target.
-gvr_sizei gvr_get_screen_target_size(const gvr_context* gvr);
-
-// Sets the size of the underlying render surface.
-//
-// By default, it is assumed that the display size matches the surface
-// size. If that is the case for the client app, this method need never be
-// called. However, in certain cases (e.g., hardware scaling), this will not
-// always hold, in which case the distortion pass must be informed of the
-// custom surface size.
-//
-// Note that the caller is responsible for resizing any BufferSpec objects
-// created before this function is called. Otherwise there will be rendering
-// artifacts, such as edges appearing pixelated. This function will change the
-// result of get_maximum_effective_render_target_size(), so that function can be
-// used to compute the appropriate size for buffers.
-//
-// @param gvr Pointer to the gvr_context instance.
-// @param surface_size_pixels The size in pixels of the display surface. If
-// non-empty, this will be used in conjunction with the current display to
-// perform properly scaled distortion. If empty, it is assumed that the
-// rendering surface dimensions match that of the active display.
-void gvr_set_surface_size(gvr_context* gvr, gvr_sizei surface_size_pixels);
-
-/// Performs postprocessing, including lens distortion, on the contents of the
-/// passed texture and shows the result on the screen. Lens distortion is
-/// determined by the parameters of the viewer encoded in its QR code. The
-/// passed texture is not modified.
-///
-/// If the application does not call gvr_initialize_gl() before calling this
-/// function, the results are undefined.
-///
-/// @deprecated This function exists only to support legacy rendering pathways
-/// for Cardboard devices. It is incompatible with the low-latency
-/// experiences supported by async reprojection. Use the swap chain API
-/// instead.
-///
-/// @param gvr Pointer to the gvr instance which will do the distortion.
-/// @param texture_id The OpenGL ID of the texture that contains the next frame
-/// to be displayed.
-/// @param viewport_list Rendering parameters.
-/// @param head_space_from_start_space This parameter is ignored.
-/// @param target_presentation_time This parameter is ignored.
-void gvr_distort_to_screen(gvr_context* gvr, int32_t texture_id,
- const gvr_buffer_viewport_list* viewport_list,
- gvr_mat4f head_space_from_start_space,
- gvr_clock_time_point target_presentation_time);
-
-/// Queries whether a particular GVR feature is supported by the underlying
-/// platform.
-///
-/// @param gvr The context to query against.
-/// @param feature The gvr_feature type being queried.
-/// @return true if feature is supported, false otherwise.
-bool gvr_is_feature_supported(const gvr_context* gvr, int32_t feature);
-
-/// @}
-
-/////////////////////////////////////////////////////////////////////////////
-// Viewports and viewport lists
-/////////////////////////////////////////////////////////////////////////////
-/// @defgroup viewport Viewports and viewport lists
-/// @brief Objects to define the mapping between the application's rendering
-/// output and the user's field of view.
-/// @{
-
-/// Creates a gvr_buffer_viewport instance.
-gvr_buffer_viewport* gvr_buffer_viewport_create(gvr_context* gvr);
-
-/// Frees a gvr_buffer_viewport instance and clears the pointer.
-void gvr_buffer_viewport_destroy(gvr_buffer_viewport** viewport);
-
-/// Gets the UV coordinates specifying where the output buffer is sampled.
-///
-/// @param viewport The buffer viewport.
-/// @return UV coordinates as a rectangle.
-gvr_rectf gvr_buffer_viewport_get_source_uv(
- const gvr_buffer_viewport* viewport);
-
-/// Sets the UV coordinates specifying where the output buffer should be
-/// sampled when compositing the final distorted image.
-///
-/// @param viewport The buffer viewport.
-/// @param uv The new UV coordinates for sampling. The coordinates must be
-/// valid, that is, left <= right and bottom <= top. Otherwise an empty
-/// source region is set, which will result in no output for this viewport.
-void gvr_buffer_viewport_set_source_uv(gvr_buffer_viewport* viewport,
- gvr_rectf uv);
-
-/// Retrieves the field of view for the referenced buffer region.
-///
-/// This is a helper that converts the stored projection matrix to a field of
-/// view. Note that if the previously set projection matrix cannot be expressed
-/// as a view frustum aligned with the eye's optical axis, the result will be
-/// incorrect.
-///
-/// @param viewport The buffer viewport.
-/// @return The field of view of the rendered image, in degrees.
-gvr_rectf gvr_buffer_viewport_get_source_fov(
- const gvr_buffer_viewport* viewport);
-
-/// Sets the field of view for the viewport contents.
-///
-/// This is a helper that sets the projection matrix in such a way that the
-/// viewport's contents fill the specified FOV around the eye's optical axis.
-///
-/// @param viewport The buffer viewport.
-/// @param fov The field of view to use when compositing the rendered image,
-/// in degrees.
-void gvr_buffer_viewport_set_source_fov(gvr_buffer_viewport* viewport,
- gvr_rectf fov);
-
-/// Gets the matrix that positions the viewport in eye space.
-///
-/// @param viewport The buffer viewport.
-/// @return Matrix that transforms a quad with vertices (-1, -1, 0), (1, -1, 0),
-/// (-1, 1, 0), (1, 1, 0) representing the viewport contents to its desired
-/// eye space position for the target eye.
-gvr_mat4f gvr_buffer_viewport_get_transform(
- const gvr_buffer_viewport* viewport);
-
-/// Sets the matrix that positions the viewport in eye space.
-///
-/// @param viewport The buffer viewport.
-/// @param transform Matrix that transforms a quad with vertices (-1, -1, 0),
-/// (1, -1, 0), (-1, 1, 0), (1, 1, 0) representing the viewport contents to
-/// its desired eye space position for the target eye.
-void gvr_buffer_viewport_set_transform(gvr_buffer_viewport* viewport,
- gvr_mat4f transform);
-
-/// Gets the target logical eye for the specified viewport.
-///
-/// @param viewport The buffer viewport.
-/// @return Index of the target logical eye for this viewport.
-int32_t gvr_buffer_viewport_get_target_eye(const gvr_buffer_viewport* viewport);
-
-/// Sets the target logical eye for the specified viewport.
-///
-/// @param viewport The buffer viewport.
-/// @param index Index of the target logical eye.
-void gvr_buffer_viewport_set_target_eye(gvr_buffer_viewport* viewport,
- int32_t index);
-
-/// Gets the index of the source buffer from which the viewport reads its
-/// undistorted pixels.
-///
-/// @param viewport The buffer viewport.
-/// @return Index of the source buffer. This corresponds to the index in the
-/// list of buffer specs that was passed to gvr_swap_chain_create().
-int32_t gvr_buffer_viewport_get_source_buffer_index(
- const gvr_buffer_viewport* viewport);
-
-/// Sets the buffer from which the viewport reads its undistorted pixels.
-///
-/// To use the contents of the external surface as buffer contents, associate an
-/// external surface with the viewport by calling
-/// gvr_buffer_viewport_set_external_surface_id(), then call this function and
-/// pass GVR_BUFFER_INDEX_EXTERNAL_SURFACE.
-///
-/// @param viewport The buffer viewport.
-/// @param buffer_index The index of the source buffer. This is either an index
-/// in the list of buffer specs that was passed to
-/// gvr_swap_chain_create(), or GVR_BUFFER_INDEX_EXTERNAL_SURFACE.
-void gvr_buffer_viewport_set_source_buffer_index(
- gvr_buffer_viewport* viewport, int32_t buffer_index);
-
-/// Gets the ID of the externally-managed Surface texture from which this
-/// viewport reads undistored pixels.
-///
-/// @param viewport The buffer viewport.
-/// @return ID of the externally-managed Surface of undistorted pixels.
-int32_t gvr_buffer_viewport_get_external_surface_id(
- const gvr_buffer_viewport* viewport);
-
-/// Sets the ID of the externally-managed Surface texture from which this
-/// viewport reads. The ID is issued by GvrLayout.
-///
-/// @param viewport The buffer viewport.
-/// @param external_surface_id The ID of the surface to read from.
-void gvr_buffer_viewport_set_external_surface_id(
- gvr_buffer_viewport* viewport, int32_t external_surface_id);
-
-/// Gets the type of reprojection to perform on the specified viewport.
-///
-/// @param viewport The buffer viewport.
-/// @return Type of reprojection that is applied to the viewport.
-int32_t gvr_buffer_viewport_get_reprojection(
- const gvr_buffer_viewport* viewport);
-
-/// Sets the type of reprojection to perform on the specified viewport.
-/// Viewports that display world content should use full reprojection.
-/// Viewports that display head-locked UI should disable reprojection to avoid
-/// excessive judder. The default is to perform full reprojection.
-///
-/// @param viewport The buffer viewport.
-/// @param reprojection Type of reprojection that will be applied to the passed
-/// viewport.
-void gvr_buffer_viewport_set_reprojection(gvr_buffer_viewport* viewport,
- int32_t reprojection);
-
-/// Compares two gvr_buffer_viewport instances and returns true if they specify
-/// the same view mapping.
-///
-/// @param a Instance of a buffer viewport.
-/// @param b Another instance of a buffer viewport.
-/// @return True if the passed viewports are the same.
-bool gvr_buffer_viewport_equal(const gvr_buffer_viewport* a,
- const gvr_buffer_viewport* b);
-
-/// Creates a new, empty list of viewports. The viewport list defines how the
-/// application's rendering output should be transformed into the stabilized,
-/// lens-distorted image that is sent to the screen.
-///
-/// The caller should populate the returned viewport using one of:
-/// - gvr_get_recommended_buffer_viewports()
-/// - gvr_get_screen_buffer_viewports()
-/// - gvr_buffer_viewport_list_set_item()
-///
-/// @param gvr Pointer the gvr instance from which to allocate the viewport
-/// list.
-/// @return Pointer to an allocated gvr_buffer_viewport_list object. The caller
-// is responsible for calling gvr_buffer_viewport_list_destroy() on the
-/// returned object when it is no longer needed.
-gvr_buffer_viewport_list* gvr_buffer_viewport_list_create(
- const gvr_context* gvr);
-
-/// Destroys a gvr_buffer_viewport_list instance. The parameter will be nulled
-/// by this operation.
-///
-/// @param viewport_list Pointer to a pointer to the viewport list instance to
-/// be destroyed and nulled.
-void gvr_buffer_viewport_list_destroy(gvr_buffer_viewport_list** viewport_list);
-
-/// Returns the size of the given viewport list.
-///
-/// @param viewport_list Pointer to a viewport list.
-/// @return The number of entries in the viewport list.
-size_t gvr_buffer_viewport_list_get_size(
- const gvr_buffer_viewport_list* viewport_list);
-
-/// Retrieve a buffer viewport entry from a list.
-///
-/// @param viewport_list Pointer to the previously allocated viewport list.
-/// @param index Zero-based index of the viewport entry to query. Must be
-/// smaller than the list size.
-/// @param viewport The buffer viewport structure that will be populated with
-/// retrieved data.
-void gvr_buffer_viewport_list_get_item(
- const gvr_buffer_viewport_list* viewport_list, size_t index,
- gvr_buffer_viewport* viewport);
-
-/// Update an element of the viewport list or append a new one at the end.
-///
-/// @param viewport_list Pointer to a previously allocated viewport list.
-/// @param index Index of the buffer viewport entry to update. If the
-/// `viewport_list` size is equal to the index, a new viewport entry will be
-/// added. The `viewport_list` size must *not* be less than the index value.
-/// @param viewport A pointer to the buffer viewport object.
-void gvr_buffer_viewport_list_set_item(gvr_buffer_viewport_list* viewport_list,
- size_t index,
- const gvr_buffer_viewport* viewport);
-
-/// @}
-
-/////////////////////////////////////////////////////////////////////////////
-// Swapchains and frames
-/////////////////////////////////////////////////////////////////////////////
-/// @defgroup swap_chain Swap chains and frames
-/// @brief Functions to create a swap chain, manipulate it and submit frames
-/// for lens distortion and presentation on the screen.
-/// @{
-
-/// Creates a default buffer specification.
-gvr_buffer_spec* gvr_buffer_spec_create(gvr_context* gvr);
-
-/// Destroy the buffer specification and null the pointer.
-void gvr_buffer_spec_destroy(gvr_buffer_spec** spec);
-
-/// Gets the size of the buffer to be created.
-///
-/// @param spec Buffer specification.
-/// @return Size of the pixel buffer. The default is equal to the recommended
-/// render target size at the time when the specification was created.
-gvr_sizei gvr_buffer_spec_get_size(const gvr_buffer_spec* spec);
-
-/// Sets the size of the buffer to be created.
-///
-/// @param spec Buffer specification.
-/// @param size The size. Width and height must both be greater than zero.
-/// Otherwise, the application is aborted.
-void gvr_buffer_spec_set_size(gvr_buffer_spec* spec, gvr_sizei size);
-
-/// Gets the number of samples per pixel in the buffer to be created.
-///
-/// @param spec Buffer specification.
-/// @return Value >= 1 giving the number of samples. 1 means multisampling is
-/// disabled. Negative values and 0 are never returned.
-int32_t gvr_buffer_spec_get_samples(const gvr_buffer_spec* spec);
-
-/// Sets the number of samples per pixel in the buffer to be created.
-///
-/// @param spec Buffer specification.
-/// @param num_samples The number of samples. Negative values are an error.
-/// The values 0 and 1 are treated identically and indicate that
-// multisampling should be disabled.
-void gvr_buffer_spec_set_samples(gvr_buffer_spec* spec, int32_t num_samples);
-
-/// Sets the color format for the buffer to be created. Default format is
-/// GVR_COLOR_FORMAT_RGBA_8888.
-///
-/// @param spec Buffer specification.
-/// @param color_format The color format for the buffer. Valid formats are in
-/// the gvr_color_format_type enum.
-void gvr_buffer_spec_set_color_format(gvr_buffer_spec* spec,
- int32_t color_format);
-
-/// Sets the depth and stencil format for the buffer to be created. Currently,
-/// only packed stencil formats are supported. Default format is
-/// GVR_DEPTH_STENCIL_FORMAT_DEPTH_16.
-///
-/// @param spec Buffer specification.
-/// @param depth_stencil_format The depth and stencil format for the buffer.
-/// Valid formats are in the gvr_depth_stencil_format_type enum.
-void gvr_buffer_spec_set_depth_stencil_format(gvr_buffer_spec* spec,
- int32_t depth_stencil_format);
-
-/// Creates a swap chain from the given buffer specifications.
-/// This is a potentially time-consuming operation. All frames within the
-/// swapchain will be allocated. Once rendering is stopped, call
-/// gvr_swap_chain_destroy() to free GPU resources. The passed gvr_context must
-/// not be destroyed until then.
-///
-/// Swap chains can have no buffers. This is useful when only displaying
-/// external surfaces. When `count` is zero, `buffers` must be null.
-///
-/// @param gvr GVR instance for which a swap chain will be created.
-/// @param buffers Array of pixel buffer specifications. Each frame in the
-/// swap chain will be composed of these buffers.
-/// @param count Number of buffer specifications in the array.
-/// @return Opaque handle to the newly created swap chain.
-gvr_swap_chain* gvr_swap_chain_create(gvr_context* gvr,
- const gvr_buffer_spec** buffers,
- int32_t count);
-
-/// Destroys the swap chain and nulls the pointer.
-void gvr_swap_chain_destroy(gvr_swap_chain** swap_chain);
-
-/// Gets the number of buffers in each frame of the swap chain.
-int32_t gvr_swap_chain_get_buffer_count(const gvr_swap_chain* swap_chain);
-
-/// Retrieves the size of the specified pixel buffer. Note that if the buffer
-/// was resized while the current frame was acquired, the return value will be
-/// different than the value obtained from the equivalent function for the
-/// current frame.
-///
-/// @param swap_chain The swap chain.
-/// @param index Index of the pixel buffer.
-/// @return Size of the specified pixel buffer in frames that will be returned
-/// from gvr_swap_chain_acquire_frame().
-gvr_sizei gvr_swap_chain_get_buffer_size(gvr_swap_chain* swap_chain,
- int32_t index);
-
-/// Resizes the specified pixel buffer to the given size. The frames are resized
-/// when they are unused, so the currently acquired frame will not be resized
-/// immediately.
-///
-/// @param swap_chain The swap chain.
-/// @param index Index of the pixel buffer to resize.
-/// @param size New size for the specified pixel buffer.
-void gvr_swap_chain_resize_buffer(gvr_swap_chain* swap_chain, int32_t index,
- gvr_sizei size);
-
-/// Acquires a frame from the swap chain for rendering. Buffers that are part of
-/// the frame can then be bound with gvr_frame_bind_buffer(). Once the frame
-/// is finished and all its constituent buffers are ready, call
-/// gvr_frame_submit() to display it while applying lens distortion.
-///
-/// @param swap_chain The swap chain.
-/// @return Handle to the acquired frame. NULL if the swap chain is invalid,
-/// or if acquire has already been called on this swap chain.
-gvr_frame* gvr_swap_chain_acquire_frame(gvr_swap_chain* swap_chain);
-
-/// Binds a pixel buffer that is part of the frame to the OpenGL framebuffer.
-///
-/// @param frame Frame handle acquired from the swap chain.
-/// @param index Index of the pixel buffer to bind. This corresponds to the
-/// index in the buffer spec list that was passed to
-/// gvr_swap_chain_create().
-void gvr_frame_bind_buffer(gvr_frame* frame, int32_t index);
-
-/// Unbinds any buffers bound from this frame and binds the default OpenGL
-/// framebuffer.
-void gvr_frame_unbind(gvr_frame* frame);
-
-/// Returns the dimensions of the pixel buffer with the specified index. Note
-/// that a frame that was acquired before resizing a swap chain buffer will not
-/// be resized until it is submitted to the swap chain.
-///
-/// @param frame Frame handle.
-/// @param index Index of the pixel buffer to inspect.
-/// @return Dimensions of the specified pixel buffer.
-gvr_sizei gvr_frame_get_buffer_size(const gvr_frame* frame, int32_t index);
-
-/// Gets the name (ID) of the framebuffer object associated with the specified
-/// buffer. The OpenGL state is not modified.
-///
-/// @param frame Frame handle.
-/// @param index Index of a pixel buffer.
-/// @return OpenGL object name (ID) of a framebuffer object which can be used
-/// to render into the buffer. The ID is valid only until the frame is
-/// submitted.
-int32_t gvr_frame_get_framebuffer_object(const gvr_frame* frame, int32_t index);
-
-/// Submits the frame for distortion and display on the screen. The passed
-/// pointer is nulled to prevent reuse.
-///
-/// @param frame The frame to submit.
-/// @param list Buffer view configuration to be used for this frame.
-/// @param head_space_from_start_space Transform from start space (space with
-/// head at the origin at last tracking reset) to head space (space with
-/// head at the origin and axes aligned to the view vector).
-void gvr_frame_submit(gvr_frame** frame, const gvr_buffer_viewport_list* list,
- gvr_mat4f head_space_from_start_space);
-
-/// Resets the OpenGL framebuffer binding to what it was at the time the
-/// passed gvr_context was created.
-void gvr_bind_default_framebuffer(gvr_context* gvr);
-
-/// @}
-
-/////////////////////////////////////////////////////////////////////////////
-// Head tracking
-/////////////////////////////////////////////////////////////////////////////
-/// @defgroup Headtracking Head tracking
-/// @brief Functions for managing head tracking.
-/// @{
-
-/// Gets the current monotonic system time.
-///
-/// @return The current monotonic system time.
-gvr_clock_time_point gvr_get_time_point_now();
-
-/// Gets the rotation from start space to head space. The head space is a
-/// space where the head is at the origin and faces the -Z direction.
-///
-/// @param gvr Pointer to the gvr instance from which to get the pose.
-/// @param time The time at which to get the head pose. The time should be in
-/// the future. If the time is not in the future, it will be clamped to now.
-/// @return A matrix representation of the rotation from start space (the space
-/// where the head was last reset) to head space (the space with the head
-/// at the origin, and the axes aligned to the view vector).
-gvr_mat4f gvr_get_head_space_from_start_space_rotation(
- const gvr_context* gvr, const gvr_clock_time_point time);
-
-/// Applies a simple neck model translation based on the rotation of the
-/// provided head pose.
-///
-/// Note: Neck model application may not be appropriate for all tracking
-/// scenarios, e.g., when tracking is non-biological.
-///
-/// @param gvr Pointer to the context instance from which the pose was obtained.
-/// @param head_space_from_start_space_rotation The head rotation as returned by
-/// gvr_get_head_space_from_start_space_rotation().
-/// @param factor A scaling factor for the neck model offset, clamped from 0 to
-/// 1. This should be 1 for most scenarios, while 0 will effectively disable
-/// neck model application. This value can be animated to smoothly
-/// interpolate between alternative (client-defined) neck models.
-/// @return The new head pose with the neck model applied.
-gvr_mat4f gvr_apply_neck_model(const gvr_context* gvr,
- gvr_mat4f head_space_from_start_space_rotation,
- float factor);
-
-/// Pauses head tracking, disables all sensors (to save power).
-///
-/// @param gvr Pointer to the gvr instance for which tracking will be paused and
-/// sensors disabled.
-void gvr_pause_tracking(gvr_context* gvr);
-
-/// Resumes head tracking, re-enables all sensors.
-///
-/// @param gvr Pointer to the gvr instance for which tracking will be resumed.
-void gvr_resume_tracking(gvr_context* gvr);
-
-/// Resets head tracking.
-///
-/// This API call is deprecated. Use gvr_recenter_tracking instead, which
-/// accomplishes the same effects but avoids the undesirable side-effects of
-/// a full reset (temporary loss of tracking quality).
-///
-/// Only to be used by Cardboard apps. Daydream apps must not call this. On the
-/// Daydream platform, recentering is handled automatically and should never
-/// be triggered programatically by applications. Hybrid apps that support both
-/// Cardboard and Daydream must only call this function when in Cardboard mode
-/// (that is, when the phone is paired with a Cardboard viewer), never in
-/// Daydream mode.
-///
-/// @param gvr Pointer to the gvr instance for which tracking will be reseted.
-/// @deprecated Calls to this method can be safely replaced by calls to
-// gvr_recenter_tracking.
-void gvr_reset_tracking(gvr_context* gvr);
-
-/// Recenters the head orientation (resets the yaw to zero, leaving pitch and
-/// roll unmodified).
-///
-/// Only to be used by Cardboard apps. Daydream apps must not call this. On the
-/// Daydream platform, recentering is handled automatically and should never
-/// be triggered programatically by applications. Hybrid apps that support both
-/// Cardboard and Daydream must only call this function when in Cardboard mode
-/// (that is, when the phone is paired with a Cardboard viewer), never in
-/// Daydream mode.
-///
-/// @param gvr Pointer to the gvr instance for which tracking will be
-/// recentered.
-void gvr_recenter_tracking(gvr_context* gvr);
-
-/// @}
-
-
-/////////////////////////////////////////////////////////////////////////////
-// Head mounted display.
-/////////////////////////////////////////////////////////////////////////////
-/// @defgroup HMD Head Mounted Display
-/// @brief Functions for managing viewer information.
-/// @{
-
-/// Sets the default viewer profile specified by viewer_profile_uri.
-/// The viewer_profile_uri that is passed in will be ignored if a valid
-/// viewer profile has already been stored on the device that the app
-/// is running on.
-///
-/// Note: This function has the potential of blocking for up to 30 seconds for
-/// each redirect if a shortened URI is passed in as argument. It will try to
-/// unroll the shortened URI for a maximum number of 5 times if the redirect
-/// continues. In that case, it is recommended to create a separate thread to
-/// call this function so that other tasks like rendering will not be blocked
-/// on this. The blocking can be avoided if a standard URI is passed in.
-///
-/// @param gvr Pointer to the gvr instance which to set the profile on.
-/// @param viewer_profile_uri A string that contains either the shortened URI or
-/// the standard URI representing the viewer profile that the app should be
-/// using. If the valid viewer profile can be found on the device, the URI
-/// that is passed in will be ignored and nothing will happen. Otherwise,
-/// gvr will look for the viewer profile specified by viewer_profile_uri,
-/// and it will be stored if found. Also, the values will be applied to gvr.
-/// A valid standard URI can be generated from this page:
-/// https://www.google.com/get/cardboard/viewerprofilegenerator/
-/// @return True if the viewer profile specified by viewer_profile_uri was
-/// successfully stored and applied, false otherwise.
-bool gvr_set_default_viewer_profile(gvr_context* gvr,
- const char* viewer_profile_uri);
-
-/// Refreshes gvr_context with the viewer profile that is stored on the device.
-/// If it can not find the viewer profile, nothing will happen.
-///
-/// @param gvr Pointer to the gvr instance to refresh the profile on.
-void gvr_refresh_viewer_profile(gvr_context* gvr);
-
-/// Gets the name of the viewer vendor.
-///
-/// @param gvr Pointer to the gvr instance from which to get the vendor.
-/// @return A pointer to the vendor name. May be NULL if no viewer is paired.
-/// WARNING: This method guarantees the validity of the returned pointer
-/// only until the next use of the `gvr` context. The string should be
-/// copied immediately if persistence is required.
-const char* gvr_get_viewer_vendor(const gvr_context* gvr);
-
-/// Gets the name of the viewer model.
-///
-/// @param gvr Pointer to the gvr instance from which to get the name.
-/// @return A pointer to the model name. May be NULL if no viewer is paired.
-/// WARNING: This method guarantees the validity of the returned pointer
-/// only until the next use of the `gvr` context. The string should be
-/// copied immediately if persistence is required.
-const char* gvr_get_viewer_model(const gvr_context* gvr);
-
-/// Gets the type of the viewer, as defined by gvr_viewer_type.
-///
-/// @param gvr Pointer to the gvr instance from which to get the viewer type.
-/// @return The gvr_viewer_type of the currently paired viewer.
-int32_t gvr_get_viewer_type(const gvr_context* gvr);
-
-/// Gets the transformation matrix to convert from Head Space to Eye Space for
-/// the given eye.
-///
-/// @param gvr Pointer to the gvr instance from which to get the matrix.
-/// @param eye Selected gvr_eye type.
-/// @return Transformation matrix from Head Space to selected Eye Space.
-gvr_mat4f gvr_get_eye_from_head_matrix(const gvr_context* gvr,
- const int32_t eye);
-
-/// Gets the window bounds.
-///
-/// @param gvr Pointer to the gvr instance from which to get the bounds.
-///
-/// @return Window bounds in physical pixels.
-gvr_recti gvr_get_window_bounds(const gvr_context* gvr);
-
-/// Computes the distorted point for a given point in a given eye. The
-/// distortion inverts the optical distortion caused by the lens for the eye.
-/// Due to chromatic aberration, the distortion is different for each
-/// color channel.
-///
-/// @param gvr Pointer to the gvr instance which will do the computing.
-/// @param eye The gvr_eye type (left or right).
-/// @param uv_in A point in screen eye Viewport Space in [0,1]^2 with (0, 0)
-/// in the lower left corner of the eye's viewport and (1, 1) in the
-/// upper right corner of the eye's viewport.
-/// @param uv_out A pointer to an array of (at least) 3 elements, with each
-/// element being a Point2f representing a point in render texture eye
-/// Viewport Space in [0,1]^2 with (0, 0) in the lower left corner of the
-/// eye's viewport and (1, 1) in the upper right corner of the eye's
-/// viewport.
-/// `uv_out[0]` is the corrected position of `uv_in` for the red channel
-/// `uv_out[1]` is the corrected position of `uv_in` for the green channel
-/// `uv_out[2]` is the corrected position of `uv_in` for the blue channel
-void gvr_compute_distorted_point(const gvr_context* gvr, const int32_t eye,
- const gvr_vec2f uv_in, gvr_vec2f uv_out[3]);
-
-/// @}
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-namespace gvr {
-
-/// Convenience C++ wrapper for gvr_user_prefs.
-class UserPrefs {
- public:
- /// Creates a C++ wrapper for a gvr_user_prefs object. Note that unlike most
- /// of the C++ wrappers in the API, this does not take ownership, as the
- /// gvr_user_prefs will remain valid for the lifetime of the GVR context.
- explicit UserPrefs(const gvr_user_prefs* user_prefs)
- : user_prefs_(user_prefs) {}
-
- UserPrefs(UserPrefs&& other) : user_prefs_(nullptr) {
- std::swap(user_prefs_, other.user_prefs_);
- }
-
- UserPrefs& operator=(UserPrefs&& other) {
- std::swap(user_prefs_, other.user_prefs_);
- return *this;
- }
-
- /// For more information, see gvr_user_prefs_get_controller_handedness().
- ControllerHandedness GetControllerHandedness() const {
- return static_cast<ControllerHandedness>(
- gvr_user_prefs_get_controller_handedness(user_prefs_));
- }
-
- /// Returns the wrapped C object. Does not affect ownership.
- const gvr_user_prefs* cobj() const { return user_prefs_; }
-
- private:
- const gvr_user_prefs* user_prefs_;
-
- // Disallow copy and assign.
- UserPrefs(const UserPrefs&);
- void operator=(const UserPrefs&);
-};
-
-/// Convenience C++ wrapper for the opaque gvr_buffer_viewport type.
-/// The constructor allocates memory, so when used in tight loops, instances
-/// should be reused.
-class BufferViewport {
- public:
- BufferViewport(BufferViewport&& other)
- : viewport_(nullptr) {
- std::swap(viewport_, other.viewport_);
- }
-
- BufferViewport& operator=(BufferViewport&& other) {
- std::swap(viewport_, other.viewport_);
- return *this;
- }
-
- ~BufferViewport() {
- if (viewport_) gvr_buffer_viewport_destroy(&viewport_);
- }
-
- /// For more information, see gvr_buffer_viewport_get_source_fov().
- Rectf GetSourceFov() const {
- return gvr_buffer_viewport_get_source_fov(viewport_);
- }
-
- /// For more information, see gvr_buffer_viewport_set_source_fov().
- void SetSourceFov(const Rectf& fov) {
- gvr_buffer_viewport_set_source_fov(viewport_, fov);
- }
-
- /// For more information, see gvr_buffer_viewport_get_transform().
- Mat4f GetTransform() const {
- return gvr_buffer_viewport_get_transform(viewport_);
- }
-
- /// For more information, see gvr_buffer_viewport_set_transform().
- void SetTransform(const Mat4f& transform) {
- gvr_buffer_viewport_set_transform(viewport_, transform);
- }
-
- /// For more information, see gvr_buffer_viewport_get_source_uv().
- Rectf GetSourceUv() const {
- return gvr_buffer_viewport_get_source_uv(viewport_);
- }
-
- /// For more information, see gvr_buffer_viewport_set_source_uv().
- void SetSourceUv(const Rectf& uv) {
- gvr_buffer_viewport_set_source_uv(viewport_, uv);
- }
-
- /// For more information, see gvr_buffer_viewport_get_target_eye().
- Eye GetTargetEye() const {
- return static_cast<Eye>(gvr_buffer_viewport_get_target_eye(viewport_));
- }
-
- /// For more information, see gvr_buffer_viewport_set_target_eye().
- void SetTargetEye(Eye eye) {
- gvr_buffer_viewport_set_target_eye(viewport_, eye);
- }
-
- /// For more information, see gvr_buffer_viewport_get_source_buffer_index().
- int32_t GetSourceBufferIndex() const {
- return gvr_buffer_viewport_get_source_buffer_index(viewport_);
- }
-
- /// For more information, see gvr_buffer_viewport_set_source_buffer_index().
- void SetSourceBufferIndex(int32_t buffer_index) {
- gvr_buffer_viewport_set_source_buffer_index(viewport_, buffer_index);
- }
-
- /// For more information, see gvr_buffer_viewport_get_external_surface_id().
- int32_t GetExternalSurfaceId() const {
- return gvr_buffer_viewport_get_external_surface_id(viewport_);
- }
-
- /// For more information, see gvr_buffer_viewport_set_external_surface_id().
- void SetExternalSurfaceId(const int32_t external_surface_id) {
- gvr_buffer_viewport_set_external_surface_id(viewport_, external_surface_id);
- }
-
- /// For more information, see gvr_buffer_viewport_get_reprojection().
- gvr_reprojection GetReprojection() const {
- return static_cast<gvr_reprojection>(
- gvr_buffer_viewport_get_reprojection(viewport_));
- }
- /// For more information, see gvr_buffer_viewport_set_reprojection().
- void SetReprojection(gvr_reprojection reprojection) {
- gvr_buffer_viewport_set_reprojection(viewport_, reprojection);
- }
-
- /// For more information, see gvr_buffer_viewport_equal().
- bool operator==(const BufferViewport& other) const {
- return gvr_buffer_viewport_equal(viewport_, other.viewport_) ? true : false;
- }
- bool operator!=(const BufferViewport& other) const {
- return !(*this == other);
- }
-
- /// @name Wrapper manipulation
- /// @{
- /// Creates a C++ wrapper for a C object and takes ownership.
- explicit BufferViewport(gvr_buffer_viewport* viewport)
- : viewport_(viewport) {}
-
- /// Returns the wrapped C object. Does not affect ownership.
- gvr_buffer_viewport* cobj() { return viewport_; }
- const gvr_buffer_viewport* cobj() const { return viewport_; }
-
- /// Returns the wrapped C object and transfers its ownership to the caller.
- /// The wrapper becomes invalid and should not be used.
- gvr_buffer_viewport* release() {
- auto result = viewport_;
- viewport_ = nullptr;
- return result;
- }
- /// @}
-
- private:
- friend class GvrApi;
- friend class BufferViewportList;
-
- explicit BufferViewport(gvr_context* gvr)
- : viewport_(gvr_buffer_viewport_create(gvr)) {}
-
- gvr_buffer_viewport* viewport_;
-};
-
-/// Convenience C++ wrapper for the opaque gvr_buffer_viewport_list type. This
-/// class will automatically release the wrapped gvr_buffer_viewport_list upon
-/// destruction. It can only be created via a `GvrApi` instance, and its
-/// validity is tied to the lifetime of that instance.
-class BufferViewportList {
- public:
- BufferViewportList(BufferViewportList&& other)
- : context_(nullptr), viewport_list_(nullptr) {
- std::swap(context_, other.context_);
- std::swap(viewport_list_, other.viewport_list_);
- }
-
- BufferViewportList& operator=(BufferViewportList&& other) {
- std::swap(context_, other.context_);
- std::swap(viewport_list_, other.viewport_list_);
- return *this;
- }
-
- ~BufferViewportList() {
- if (viewport_list_) {
- gvr_buffer_viewport_list_destroy(&viewport_list_);
- }
- }
-
- /// For more information, see gvr_get_recommended_buffer_viewports().
- void SetToRecommendedBufferViewports() {
- gvr_get_recommended_buffer_viewports(context_, viewport_list_);
- }
-
- /// For more information, see gvr_get_screen_buffer_viewports().
- void SetToScreenBufferViewports() {
- gvr_get_screen_buffer_viewports(context_, viewport_list_);
- }
-
- /// For more information, see gvr_buffer_viewport_list_set_item().
- void SetBufferViewport(size_t index, const BufferViewport& viewport) {
- gvr_buffer_viewport_list_set_item(viewport_list_, index,
- viewport.viewport_);
- }
-
- /// For more information, see gvr_buffer_viewport_list_get_item().
- void GetBufferViewport(size_t index, BufferViewport* viewport) const {
- gvr_buffer_viewport_list_get_item(viewport_list_, index,
- viewport->viewport_);
- }
-
- /// For more information, see gvr_buffer_viewport_list_get_size().
- size_t GetSize() const {
- return gvr_buffer_viewport_list_get_size(viewport_list_);
- }
-
- /// @name Wrapper manipulation
- /// @{
- /// Creates a C++ wrapper for a C object and takes ownership.
- BufferViewportList(gvr_buffer_viewport_list* viewport_list,
- gvr_context* context)
- : context_(context),
- viewport_list_(viewport_list) {}
-
- /// Returns the wrapped C object. Does not affect ownership.
- gvr_buffer_viewport_list* cobj() { return viewport_list_; }
- const gvr_buffer_viewport_list* cobj() const { return viewport_list_; }
-
- /// Returns the wrapped C object and transfers its ownership to the caller.
- /// The wrapper becomes invalid and should not be used.
- gvr_buffer_viewport_list* release() {
- auto result = viewport_list_;
- viewport_list_ = nullptr;
- return result;
- }
- /// @}
-
- private:
- friend class Frame;
- friend class GvrApi;
- friend class SwapChain;
-
- explicit BufferViewportList(gvr_context* context)
- : context_(context),
- viewport_list_(gvr_buffer_viewport_list_create(context)) {}
-
- const gvr_context* context_;
- gvr_buffer_viewport_list* viewport_list_;
-
- // Disallow copy and assign.
- BufferViewportList(const BufferViewportList&) = delete;
- void operator=(const BufferViewportList&) = delete;
-};
-
-/// Convenience C++ wrapper for gvr_buffer_spec, an opaque pixel buffer
-/// specification. Frees the underlying gvr_buffer_spec on destruction.
-class BufferSpec {
- public:
- BufferSpec(BufferSpec&& other)
- : spec_(nullptr) {
- std::swap(spec_, other.spec_);
- }
-
- BufferSpec& operator=(BufferSpec&& other) {
- std::swap(spec_, other.spec_);
- return *this;
- }
-
- ~BufferSpec() {
- if (spec_) gvr_buffer_spec_destroy(&spec_);
- }
-
- /// Gets the buffer's size. The default value is the recommended render
- /// target size. For more information, see gvr_buffer_spec_get_size().
- Sizei GetSize() const {
- return gvr_buffer_spec_get_size(spec_);
- }
-
- /// Sets the buffer's size. For more information, see
- /// gvr_buffer_spec_set_size().
- void SetSize(const Sizei& size) {
- gvr_buffer_spec_set_size(spec_, size);
- }
-
- /// Sets the buffer's size to the passed width and height. For more
- /// information, see gvr_buffer_spec_set_size().
- ///
- /// @param width The width in pixels. Must be greater than 0.
- /// @param height The height in pixels. Must be greater than 0.
- void SetSize(int32_t width, int32_t height) {
- gvr_sizei size{width, height};
- gvr_buffer_spec_set_size(spec_, size);
- }
-
- /// Gets the number of samples per pixel in the buffer. For more
- /// information, see gvr_buffer_spec_get_samples().
- int32_t GetSamples() const { return gvr_buffer_spec_get_samples(spec_); }
-
- /// Sets the number of samples per pixel. For more information, see
- /// gvr_buffer_spec_set_samples().
- void SetSamples(int32_t num_samples) {
- gvr_buffer_spec_set_samples(spec_, num_samples);
- }
-
- /// Sets the color format for this buffer. For more information, see
- /// gvr_buffer_spec_set_color_format().
- void SetColorFormat(ColorFormat color_format) {
- gvr_buffer_spec_set_color_format(spec_, color_format);
- }
-
- /// Sets the depth and stencil format for this buffer. For more
- /// information, see gvr_buffer_spec_set_depth_stencil_format().
- void SetDepthStencilFormat(DepthStencilFormat depth_stencil_format) {
- gvr_buffer_spec_set_depth_stencil_format(spec_, depth_stencil_format);
- }
-
- /// @name Wrapper manipulation
- /// @{
- /// Creates a C++ wrapper for a C object and takes ownership.
- explicit BufferSpec(gvr_buffer_spec* spec) : spec_(spec) {}
-
- /// Returns the wrapped C object. Does not affect ownership.
- gvr_buffer_spec* cobj() { return spec_; }
- const gvr_buffer_spec* cobj() const { return spec_; }
-
- /// Returns the wrapped C object and transfers its ownership to the caller.
- /// The wrapper becomes invalid and should not be used.
- gvr_buffer_spec* release() {
- auto result = spec_;
- spec_ = nullptr;
- return result;
- }
- /// @}
-
- private:
- friend class GvrApi;
- friend class SwapChain;
-
- explicit BufferSpec(gvr_context* gvr) {
- spec_ = gvr_buffer_spec_create(gvr);
- }
-
- gvr_buffer_spec* spec_;
-};
-
-/// Convenience C++ wrapper for gvr_frame, which represents a single frame
-/// acquired for rendering from the swap chain.
-class Frame {
- public:
- Frame(Frame&& other) : frame_(nullptr) {
- std::swap(frame_, other.frame_);
- }
-
- Frame& operator=(Frame&& other) {
- std::swap(frame_, other.frame_);
- return *this;
- }
-
- ~Frame() {
- // The swap chain owns the frame, so no clean-up is required.
- }
-
- /// For more information, see gvr_frame_get_buffer_size().
- Sizei GetBufferSize(int32_t index) const {
- return gvr_frame_get_buffer_size(frame_, index);
- }
-
- /// For more information, see gvr_frame_bind_buffer().
- void BindBuffer(int32_t index) {
- gvr_frame_bind_buffer(frame_, index);
- }
-
- /// For more information, see gvr_frame_unbind().
- void Unbind() {
- gvr_frame_unbind(frame_);
- }
-
- /// For more information, see gvr_frame_get_framebuffer_object().
- int32_t GetFramebufferObject(int32_t index) {
- return gvr_frame_get_framebuffer_object(frame_, index);
- }
-
- /// For more information, see gvr_frame_submit().
- void Submit(const BufferViewportList& viewport_list,
- const Mat4f& head_space_from_start_space) {
- gvr_frame_submit(&frame_, viewport_list.viewport_list_,
- head_space_from_start_space);
- }
-
- /// @name Wrapper manipulation
- /// @{
- /// Creates a C++ wrapper for a C object and takes ownership.
- explicit Frame(gvr_frame* frame) : frame_(frame) {}
-
- /// Returns the wrapped C object. Does not affect ownership.
- gvr_frame* cobj() { return frame_; }
- const gvr_frame* cobj() const { return frame_; }
-
- /// Returns whether the wrapped gvr_frame reference is valid.
- bool is_valid() const { return frame_ != nullptr; }
- explicit operator bool const() { return is_valid(); }
-
- /// Returns the wrapped C object and transfers its ownership to the caller.
- /// The wrapper becomes invalid and should not be used.
- gvr_frame* release() {
- auto result = frame_;
- frame_ = nullptr;
- return result;
- }
- /// @}
-
- private:
- friend class SwapChain;
-
- gvr_frame* frame_;
-};
-
-/// Convenience C++ wrapper for gvr_swap_chain, which represents a queue of
-/// frames. The GvrApi object must outlive any SwapChain objects created from
-/// it.
-class SwapChain {
- public:
- SwapChain(SwapChain&& other)
- : swap_chain_(nullptr) {
- std::swap(swap_chain_, other.swap_chain_);
- }
-
- SwapChain& operator=(SwapChain&& other) {
- std::swap(swap_chain_, other.swap_chain_);
- return *this;
- }
-
- ~SwapChain() {
- if (swap_chain_) gvr_swap_chain_destroy(&swap_chain_);
- }
-
- /// For more information, see gvr_swap_chain_get_buffer_count().
- int32_t GetBufferCount() const {
- return gvr_swap_chain_get_buffer_count(swap_chain_);
- }
-
- /// For more information, see gvr_swap_chain_get_buffer_size().
- Sizei GetBufferSize(int32_t index) const {
- return gvr_swap_chain_get_buffer_size(swap_chain_, index);
- }
-
- /// For more information, see gvr_swap_chain_resize_buffer().
- void ResizeBuffer(int32_t index, Sizei size) {
- gvr_swap_chain_resize_buffer(swap_chain_, index, size);
- }
-
- /// For more information, see gvr_swap_chain_acquire_frame().
- /// Note that if Frame acquisition fails, the returned Frame may not be valid.
- /// The caller should inspect the returned Frame's validity before using,
- /// and reschedule frame acquisition upon failure.
- Frame AcquireFrame() {
- Frame result(gvr_swap_chain_acquire_frame(swap_chain_));
- return result;
- }
-
- /// @name Wrapper manipulation
- /// @{
- /// Creates a C++ wrapper for a C object and takes ownership.
- explicit SwapChain(gvr_swap_chain* swap_chain) : swap_chain_(swap_chain) {}
-
- /// Returns the wrapped C object. Does not affect ownership.
- gvr_swap_chain* cobj() { return swap_chain_; }
- const gvr_swap_chain* cobj() const { return swap_chain_; }
-
- /// Returns the wrapped C object and transfers its ownership to the caller.
- /// The wrapper becomes invalid and should not be used.
- gvr_swap_chain* release() {
- auto result = swap_chain_;
- swap_chain_ = nullptr;
- return result;
- }
- /// @}
-
- private:
- friend class GvrApi;
-
- SwapChain(gvr_context* gvr, const std::vector<BufferSpec>& specs) {
- std::vector<const gvr_buffer_spec*> c_specs;
- for (const auto& spec : specs)
- c_specs.push_back(spec.spec_);
- swap_chain_ = gvr_swap_chain_create(gvr, c_specs.data(),
- static_cast<int32_t>(c_specs.size()));
- }
-
- gvr_swap_chain* swap_chain_;
-
- // Disallow copy and assign.
- SwapChain(const SwapChain&);
- void operator=(const SwapChain&);
-};
-
-/// This is a convenience C++ wrapper for the Google VR C API.
-///
-/// This wrapper strategy prevents ABI compatibility issues between compilers
-/// by ensuring that the interface between client code and the implementation
-/// code in libgvr.so is a pure C interface. The translation from C++ calls
-/// to C calls provided by this wrapper runs entirely in the client's binary
-/// and is compiled by the client's compiler.
-///
-/// Methods in this class are only documented insofar as the C++ wrapping logic
-/// is concerned; for information about the method itself, please refer to the
-/// corresponding function in the C API.
-///
-/// Example API usage:
-///
-/// // Functionality supplied by the application in the example below has
-/// // the "app-" prefix.
-/// #ifdef __ANDROID__
-/// // On Android, the gvr_context should almost always be obtained from the
-/// // Java GvrLayout object via
-/// // GvrLayout.getGvrApi().getNativeGvrContext().
-/// std::unique_ptr<GvrApi> gvr = GvrApi::WrapNonOwned(gvr_context);
-/// #else
-/// std::unique_ptr<GvrApi> gvr = GvrApi::Create();
-/// #endif
-///
-/// gvr->InitializeGl();
-///
-/// gvr::BufferViewportList viewport_list =
-/// gvr->CreateEmptyBufferViewportList();
-/// gvr->GetRecommendedBufferViewports(&viewport_list);
-/// gvr::BufferViewport left_eye_viewport = gvr->CreateBufferViewport();
-/// gvr::BufferViewport right_eye_viewport = gvr->CreateBufferViewport();
-/// viewport_list.Get(0, &left_eye_view);
-/// viewport_list.Get(1, &right_eye_view);
-///
-/// std::vector<gvr::BufferSpec> specs;
-/// specs.push_back(gvr->CreateBufferSpec());
-/// specs[0].SetSamples(app_samples);
-/// gvr::SwapChain swap_chain = gvr->CreateSwapChain(specs);
-///
-/// while (client_app_should_render) {
-/// // A client app should be ready for the render target size to change
-/// // whenever a new QR code is scanned, or a new viewer is paired.
-/// gvr::Sizei render_target_size =
-/// gvr->GetRecommendedRenderTargetSize();
-/// swap_chain.ResizeBuffer(0, render_target_size);
-/// gvr::Frame frame = swap_chain.AcquireFrame();
-/// while (!frame) {
-/// std::this_thread::sleep_for(2ms);
-/// frame = swap_chain.AcquireFrame();
-/// }
-///
-/// // This function will depend on your render loop's implementation.
-/// gvr::ClockTimePoint next_vsync = AppGetNextVsyncTime();
-///
-/// const gvr::Mat4f head_view =
-/// gvr->GetHeadSpaceFromStartSpaceRotation(next_vsync);
-/// const gvr::Mat4f left_eye_view = MatrixMultiply(
-/// gvr->GetEyeFromHeadMatrix(kLeftEye), head_view);
-/// const gvr::Mat4f right_eye_view = MatrixMultiply(
-/// gvr->GetEyeFromHeadMatrix(kRightEye), head_view);
-///
-/// frame.BindBuffer(0);
-/// // App does its rendering to the current framebuffer here.
-/// AppDoSomeRenderingForEye(
-/// left_eye_viewport.GetSourceUv(), left_eye_view);
-/// AppDoSomeRenderingForEye(
-/// right_eye_viewport.GetSourceUv(), right_eye_view);
-/// frame.Unbind();
-/// frame.Submit(viewport_list, head_matrix);
-/// }
-///
-class GvrApi {
- public:
-#ifdef __ANDROID__
- /// Instantiates and returns a GvrApi instance that owns a gvr_context.
- ///
- /// @param env The JNIEnv associated with the current thread.
- /// @param app_context The Android application context. This must be the
- /// application context, NOT an Activity context (Note: from any Android
- /// Activity in your app, you can call getApplicationContext() to
- /// retrieve the application context).
- /// @param class_loader The class loader to use when loading Java classes.
- /// This must be your app's main class loader (usually accessible through
- /// activity.getClassLoader() on any of your Activities).
- /// @return unique_ptr to the created GvrApi instance, nullptr on failure.
- static std::unique_ptr<GvrApi> Create(JNIEnv* env, jobject app_context,
- jobject class_loader) {
- gvr_context* context = gvr_create(env, app_context, class_loader);
- if (!context) {
- return nullptr;
- }
- return std::unique_ptr<GvrApi>(new GvrApi(context, true /* owned */));
- }
-#else
- /// Instantiates and returns a GvrApi instance that owns a gvr_context.
- ///
- /// @return unique_ptr to the created GvrApi instance, nullptr on failure.
- static std::unique_ptr<GvrApi> Create() {
- gvr_context* context = gvr_create();
- if (!context) {
- return nullptr;
- }
- return std::unique_ptr<GvrApi>(new GvrApi(context, true /* owned */));
- }
-#endif // #ifdef __ANDROID__
-
- ~GvrApi() {
- if (context_ && owned_) {
- gvr_destroy(&context_);
- }
- }
-
- /// @name Error handling
- /// @{
-
- /// For more information, see gvr_get_error().
- Error GetError() { return static_cast<Error>(gvr_get_error(context_)); }
-
- /// For more information, see gvr_clear_error().
- Error ClearError() { return static_cast<Error>(gvr_clear_error(context_)); }
-
- /// For more information, see gvr_get_error_string().
- static const char* GetErrorString(Error error_code) {
- return gvr_get_error_string(error_code);
- }
-
- /// For more information, see gvr_get_user_prefs().
- UserPrefs GetUserPrefs() { return UserPrefs(gvr_get_user_prefs(context_)); }
-
- /// @}
-
- /// @name Rendering
- /// @{
-
- /// For more information, see gvr_initialize_gl().
- void InitializeGl() { gvr_initialize_gl(context_); }
-
- /// For more information, see gvr_get_async_reprojection_enabled().
- bool GetAsyncReprojectionEnabled() const {
- return gvr_get_async_reprojection_enabled(context_);
- }
-
- /// Constructs a C++ wrapper for a gvr_buffer_viewport object. For more
- /// information, see gvr_buffer_viewport_create().
- ///
- /// @return A new BufferViewport instance with memory allocated for an
- /// underlying gvr_buffer_viewport.
- BufferViewport CreateBufferViewport() const {
- return BufferViewport(context_);
- }
-
- /// Constructs a C++ wrapper for a gvr_buffer_viewport_list object.
- /// For more information, see gvr_buffer_viewport_list_create().
- ///
- /// @return A new, empty BufferViewportList instance.
- /// Note: The validity of the returned object is closely tied to the
- /// lifetime of the member gvr_context. The caller is responsible for
- /// ensuring correct usage accordingly.
- BufferViewportList CreateEmptyBufferViewportList() const {
- return BufferViewportList(context_);
- }
-
- /// For more information, see gvr_get_maximum_effective_render_target_size().
- Sizei GetMaximumEffectiveRenderTargetSize() const {
- return gvr_get_maximum_effective_render_target_size(context_);
- }
-
- /// For more information, see gvr_get_screen_target_size().
- Sizei GetScreenTargetSize() const {
- return gvr_get_screen_target_size(context_);
- }
-
- /// For more information, see gvr_set_surface_size().
- void SetSurfaceSize(Sizei surface_size_pixels) {
- gvr_set_surface_size(context_, surface_size_pixels);
- }
-
- /// For more information, see gvr_distort_to_screen().
- void DistortToScreen(int32_t texture_id,
- const BufferViewportList& viewport_list,
- const Mat4f& rendered_head_pose_in_start_space_matrix,
- const ClockTimePoint& texture_presentation_time) {
- gvr_distort_to_screen(context_, texture_id, viewport_list.viewport_list_,
- rendered_head_pose_in_start_space_matrix,
- texture_presentation_time);
- }
-
- /// For more information, see gvr_is_feature_supported().
- bool IsFeatureSupported(int32_t feature) {
- return gvr_is_feature_supported(context_, feature);
- }
-
- /// For more information, see gvr_buffer_spec_create().
- BufferSpec CreateBufferSpec() {
- return BufferSpec(context_);
- }
-
- /// For more information, see gvr_swap_chain_create().
- SwapChain CreateSwapChain(const std::vector<BufferSpec>& specs) {
- return SwapChain(context_, specs);
- }
-
- /// For more information, see gvr_bind_default_framebuffer().
- void BindDefaultFramebuffer() {
- gvr_bind_default_framebuffer(context_);
- }
- /// @}
-
- /// @name Head tracking
- /// @{
-
- /// For more information see gvr_get_head_space_from_start_space_rotation.
- ///
- /// @param time_point The time at which to calculate the head pose in start
- /// space.
- /// @return The matrix representation of the rotation from start space
- /// (the space with the head pose at the last tracking reset at origin) to
- /// head space (the space with the head at origin and axes aligned to the
- /// view vector).
- Mat4f GetHeadSpaceFromStartSpaceRotation(const ClockTimePoint& time_point) {
- return gvr_get_head_space_from_start_space_rotation(context_, time_point);
- }
-
- /// For more information, see gvr_apply_neck_model().
- Mat4f ApplyNeckModel(const Mat4f& head_pose_in_start_space, float factor) {
- return gvr_apply_neck_model(context_, head_pose_in_start_space, factor);
- }
-
- /// For more information, see gvr_pause_tracking().
- void PauseTracking() { gvr_pause_tracking(context_); }
-
- /// For more information, see gvr_resume_tracking().
- void ResumeTracking() { gvr_resume_tracking(context_); }
-
- /// For more information, see gvr_reset_tracking().
- void ResetTracking() { gvr_reset_tracking(context_); }
-
- // For more information, see gvr_recenter_tracking().
- void RecenterTracking() { gvr_recenter_tracking(context_); }
-
- /// For more information, see gvr_get_time_point_now().
- static ClockTimePoint GetTimePointNow() { return gvr_get_time_point_now(); }
- /// @}
-
- /// @name Viewer parameters
- /// @{
-
- /// For more information, see gvr_set_default_viewer_profile().
- bool SetDefaultViewerProfile(const char* viewer_profile_uri) {
- return gvr_set_default_viewer_profile(context_, viewer_profile_uri);
- }
-
- /// For more information, see gvr_refresh_viewer_profile().
- void RefreshViewerProfile() { gvr_refresh_viewer_profile(context_); }
-
- /// For more information, see gvr_get_viewer_vendor().
- const char* GetViewerVendor() const {
- return gvr_get_viewer_vendor(context_);
- }
-
- /// For more information, see gvr_get_viewer_model().
- const char* GetViewerModel() const { return gvr_get_viewer_model(context_); }
-
- /// For more information, see gvr_get_viewer_type().
- ViewerType GetViewerType() const {
- return static_cast<ViewerType>(gvr_get_viewer_type(context_));
- }
-
- /// For more information, see gvr_get_eye_from_head_matrix().
- Mat4f GetEyeFromHeadMatrix(Eye eye) const {
- return gvr_get_eye_from_head_matrix(context_, eye);
- }
-
- /// For more information, see gvr_get_window_bounds().
- Recti GetWindowBounds() const { return gvr_get_window_bounds(context_); }
-
- /// For more information, see gvr_compute_distorted_point().
- std::array<Vec2f, 3> ComputeDistortedPoint(Eye eye, const Vec2f& uv_in) {
- std::array<Vec2f, 3> uv_out = {{{}}};
- gvr_compute_distorted_point(context_, eye, uv_in, uv_out.data());
- return uv_out;
- }
- /// @}
-
- /// @name Wrapper manipulation
- /// @{
- /// Creates a C++ wrapper for a C object and optionally takes ownership.
- ///
- /// @param context C object to wrap.
- /// @param owned Whether the wrapper will own the underlying C object.
- explicit GvrApi(gvr_context* context, bool owned = true)
- : context_(context), owned_(owned) {}
-
- /// Returns the wrapped C object. Does not affect ownership.
- gvr_context* cobj() { return context_; }
- const gvr_context* cobj() const { return context_; }
-
- /// @deprecated Use cobj() instead.
- gvr_context* GetContext() { return context_; }
- /// @deprecated Use cobj() instead.
- const gvr_context* GetContext() const { return context_; }
-
- /// Returns the wrapped C object and transfers its ownership to the caller.
- /// The wrapper becomes invalid and should not be used.
- gvr_context* release() {
- auto result = context_;
- context_ = nullptr;
- return result;
- }
-
- /// Instantiates a GvrApi instance that wraps a *non-owned* gvr_context.
- ///
- /// Ownership of the provided `context` remains with the caller, and they
- /// are responsible for ensuring proper disposal of the context.
- ///
- /// @param context Pointer to a non-null, non-owned gvr_context instance.
- /// @return unique_ptr to the created GvrApi instance. Never null.
- static std::unique_ptr<GvrApi> WrapNonOwned(gvr_context* context) {
- return std::unique_ptr<GvrApi>(new GvrApi(context, false /* owned */));
- }
- /// @}
-
- private:
- gvr_context* context_;
-
- // Whether context_ is owned by the GvrApi instance. If owned, the context
- // will be released upon destruction.
- const bool owned_;
-
- // Disallow copy and assign.
- GvrApi(const GvrApi&);
- void operator=(const GvrApi&);
-};
-
-} // namespace gvr
-#endif // #if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-
-#endif // VR_GVR_CAPI_INCLUDE_GVR_H_
diff --git a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr_audio.h b/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr_audio.h
deleted file mode 100644
index d34c84d..0000000
--- a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr_audio.h
+++ /dev/null
@@ -1,852 +0,0 @@
-/* Copyright 2016 Google Inc. All rights reserved.
- *
- * 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 VR_GVR_CAPI_INCLUDE_GVR_AUDIO_H_
-#define VR_GVR_CAPI_INCLUDE_GVR_AUDIO_H_
-
-#if __ANDROID__
-#include <jni.h>
-#endif // __ANDROID__
-
-#include <stdint.h>
-
-#include "vr/gvr/capi/include/gvr.h"
-#include "vr/gvr/capi/include/gvr_types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif // __cplusplus
-
-/// @defgroup Audio Spatial Audio API
-/// @brief This is the GVR Audio C API, a spatial audio rendering engine,
-/// optimized for mobile VR.
-///
-/// It allows the user to spatialize sound sources in 3D space, including
-/// distance and elevation cues. Specifically, the API is capable of playing
-/// back spatial sound in three ways:
-///
-/// - **Sound object rendering**: This allows the user to create a virtual sound
-/// source in 3D space. These sources, while spatialized, are fed with mono
-/// audio data.
-///
-/// - **Ambisonic soundfields**: Ambisonic recordings are multi-channel audio
-/// files which are spatialized all around the listener in 360 degrees. These
-/// can be thought of as recorded or pre-baked soundfields. They can be of
-/// great use for background effects which sound perfectly spatial. Examples
-/// include rain noise, crowd noise or even the sound of the ocean off to one
-/// side.
-///
-/// - **Stereo Sounds**: This allows the user to directly play back
-/// non-spatialized mono or stereo audio files. This is useful for music and
-/// other such audio.
-///
-/// **Initialization**
-///
-/// gvr_audio_context* gvr_audio_create(int32_t rendering_mode);
-///
-/// The rendering_mode argument corresponds to a `gvr_audio_rendering_mode` enum
-/// value, which specifies a rendering configuration setting:
-///
-/// - `GVR_AUDIO_RENDERING_STEREO_PANNING`:
-/// Stereo panning of all sound objects. This disables HRTF-based rendering.
-/// - `GVR_AUDIO_RENDERING_BINAURAL_LOW_QUALITY`:
-/// This renders sound objects over a virtual array of 8 loudspeakers arranged
-/// in a cube configuration around the listener’s head. HRTF-based rendering
-/// is enabled.
-/// - `GVR_AUDIO_RENDERING_BINAURAL_HIGH_QUALITY`:
-/// This renders sound objects over a virtual array of 16 loudspeakers
-/// arranged in an approximate equidistribution about the listener’s
-/// head. HRTF-based rendering is enabled.
-///
-/// For most modern phones, the high quality mode offers a good balance between
-/// performance and audio quality. To optimize the rendering performance for
-/// headphones *and* speaker playback, the stereo speaker mode can be enabled
-/// which automatically switches to stereo panning when no headphone is plugin.
-/// Note that this can lead to varying CPU usage based on headphone and speaker
-/// playback.
-///
-/// **Sound engine control**
-///
-/// Audio playback on the default audio device can be started and stopped by
-/// calling the following two methods:
-///
-/// void gvr_audio_pause(gvr_audio_context* api);
-/// void gvr_audio_resume(gvr_audio_context* api);
-///
-/// Note that:
-///
-/// void gvr_audio_update(gvr_audio_context* api);
-///
-/// must be called from the main thread at a regular rate. It is used to execute
-/// background operations outside of the audio thread.
-///
-/// **Listener position and rotation**
-///
-/// To ensure that the audio in your application reacts to listener head
-/// movement, it is important to update the listener's head orientation in the
-/// graphics callback using the head orientation matrix.
-///
-/// The following methods can be used to control the listener’s head position
-/// and orientation with the audio engine:
-///
-/// void gvr_audio_set_head_position(gvr_audio_context* api, float x,
-/// float y, float z);
-/// or
-///
-/// void gvr_audio_set_head_position_gvr(gvr_audio_context* api,
-/// const gvr_vec3f& position);
-///
-/// and
-///
-/// void gvr_audio_set_head_rotation(gvr_audio_context* api,
-/// float x, float y, float z, float w);
-/// or
-///
-/// void gvr_audio_set_head_rotation_gvr(gvr_audio_context* api,
-/// const gvr_quatf& rotation);
-///
-/// **Preloading Sounds**
-///
-/// Both mono sound files for use with Sound Objects and multi-channel Ambisonic
-/// soundfield files can be preloaded into memory before playback or
-/// alternatively streamed during playback. Preloading can be useful to reduce
-/// CPU usage especially if the same audio clip is likely to be played back many
-/// times. In this case playback latency is also reduced.
-///
-/// Sound files can be preloaded into memory by calling:
-///
-/// bool gvr_audio_preload_soundfile(gvr_audio_context* api,
-/// const char* filename);
-///
-/// Unused sound files can be unloaded with a call to:
-///
-/// void gvr_audio_unload_soundfile(gvr_audio_context* api,
-/// const char* filename);
-///
-/// NOTE: If a sound object, soundfield or stereo sound is created with a file
-/// that has not been preloaded, that audio will be streamed.
-///
-/// **Spatializtion of sound objects**
-///
-/// The GVR Audio System allows the user to create virtual sound objects which
-/// can be placed anywhere in space around the listener.
-///
-/// To create a new sound object, call:
-///
-/// gvr_audio_source_id
-/// gvr_audio_create_sound_object(gvr_audio_context* api,
-/// const char* filename);
-///
-/// This returns a handle that can be used to set properties such as the
-/// position and the volume of the sound object via calls to the following two
-/// functions:
-///
-/// void
-/// gvr_audio_set_sound_object_position(gvr_audio_context* api,
-/// gvr_audio_source_id sound_object_id,
-/// float x, float y, float z);
-///
-/// void
-/// gvr_audio_set_sound_volume(gvr_audio_context* api,
-/// gvr_audio_source_id source_id, float volume);
-///
-/// The behavior of Sound Objects with respect to their distance from the
-/// listener can be controlled via calls to the following method:
-///
-/// void gvr_audio_set_sound_object_distance_rolloff_model(
-/// gvr_audio_context* api, gvr_audio_source_id sound_object_id,
-/// int32_t rolloff_model, float min_distance, float max_distance);
-///
-/// This enables a user to choose between logarithmic and linear distance
-/// rolloff methods, or to completely disable distance rolloff effects.
-///
-///
-/// The spatialized playback of a sound object can be triggered with a call to:
-///
-/// void gvr_audio_play_sound(gvr_audio_context* api,
-/// gvr_audio_source_id source_id,
-/// bool looping_enabled);
-///
-/// and stopped with a call to:
-///
-/// void gvr_audio_stop_sound(gvr_audio_context* api,
-/// gvr_audio_source_id source_id);
-///
-/// Note that the sound object handle destroys itself at the moment the sound
-/// playback has stopped. This way, no clean up of sound object handles is
-/// needed. On subsequent calls to this function the corresponding
-/// gvr_audio_source_id no longer refers to a valid sound object.
-///
-/// The following function can be used to check if a sound object is currently
-/// active:
-///
-/// bool gvr_audio_is_sound_playing(const gvr_audio_context* api,
-/// gvr_audio_source_id source_id);
-///
-/// **Rendering of ambisonic soundfields**
-///
-/// The GVR Audio System also provides the user with the ability to play back
-/// ambisonic soundfields. Ambisonic soundfields are captured or pre-rendered
-/// 360 degree recordings. It is best to think of them as equivalent to 360
-/// degree video. While they envelop and surround the listener, they only react
-/// to the listener's rotational movement. That is, one cannot walk towards
-/// features in the soundfield. Soundfields are ideal for accompanying 360
-/// degree video playback, for introducing background and environmental effects
-/// such as rain or crowd noise, or even for pre baking 3D audio to reduce
-/// rendering costs. The GVR Audio System supports full 3D First Order
-/// Ambisonic recordings using ACN channel ordering and SN3D normalization. For
-/// more information please see our Spatial Audio specification at:
-/// https://github.com/google/spatial-media/blob/master/docs/spatial-audio-rfc.md#semantics
-///
-/// Note that Soundfield playback is directly streamed from the sound file and
-/// no sound file preloading is needed.
-///
-/// To obtain a soundfield handler, call:
-///
-/// gvr_audio_source_id gvr_audio_create_soundfield(gvr_audio_context* api,
-/// const char* filename);
-///
-/// This returns a gvr_audio_source_id handle that allows the user to begin
-/// playback of the soundfield, to alter the soundfield’s volume or to stop
-/// soundfield playback and as such destroy the object. These actions can be
-/// achieved with calls to the following functions:
-///
-/// void gvr_audio_play_sound(gvr_audio_context* api,
-/// gvr_audio_source_id source_id,
-/// bool looping_enabled);
-///
-/// void gvr_audio_set_sound_volume(gvr_audio_context* api,
-/// gvr_audio_source_id source_id,
-/// float volume);
-///
-/// void gvr_audio_stop_sound(gvr_audio_context* api,
-/// gvr_audio_source_id source_id);
-///
-/// Ambisonic soundfields can also be rotated about the listener's head in order
-/// to align the components of the soundfield with the visuals of the game/app.
-///
-/// void gvr_audio_set_soundfield_rotation(gvr_audio_context* api,
-/// gvr_audio_source_id soundfield_id,
-/// const gvr_quatf&
-/// soundfield_rotation);
-///
-/// **Direct Playback of Stereo or Mono Sounds**
-///
-/// The GVR Audio System allows the direct non-spatialized playback of both
-/// stereo and mono audio. Such audio is often used for music or sound effects
-/// that should not be spatialized.
-///
-/// A stereo sound can be created with a call to:
-///
-/// gvr_audio_source_id gvr_audio_create_stereo_sound(gvr_audio_context* api,
-/// const char* filename);
-///
-/// **Paused Sounds and Stopped Sounds**
-///
-/// When using sound sources of any of the above types, the user can ensure that
-/// the given source is currently playing before calling.
-///
-/// bool gvr_audio_is_sound_playing(gvr_audio_source_id source_id);
-///
-/// This method will return false if the source has been either paused or
-/// stopped, and true if the source is currently playing.
-///
-/// Once one is finished with a Sound Object and wish to remove it, a call can
-/// be placed to:
-///
-/// void gvr_audio_stop_sound(gvr_audio_source_id source_id);
-///
-/// Once a source has been stopped it is destroyed and the corresponding
-/// gvr_audio_source_id will be invalid. Sources which have been played with the
-/// |looping_enabled| parameter disabled will also be destroyed once playback
-/// of the full audio clip has completed.
-///
-/// To check whether a given gvr_audio_source_id corresponds to a valid source
-/// which exists and is in a playable state, a call can be made to:
-///
-/// bool gvr_audio_is_source_id_valid(gvr_audio_source_id source_id);
-///
-/// By using this pair of methods a user can differentiate between sources which
-/// have been paused and those which have ceased.
-///
-/// **Room effects**
-///
-/// The GVR Audio System provides a powerful reverb engine which can be used to
-/// create customized room effects by specifying the size of a room and a
-/// material for each surface of the room from the gvr_audio_material_name enum.
-/// Each of these surface materials has unique absorption properties which
-/// differ with frequency. The room created will be centered around the
-/// listener. Note that the Google VR Audio System uses meters as the unit of
-/// distance throughout.
-///
-/// The following methods are used to control room effects:
-///
-/// void gvr_audio_enable_room(gvr_audio_context* api, bool enable);
-///
-/// enables or disables room effects with smooth transitions.
-///
-/// and
-///
-/// void
-/// gvr_audio_set_room_properties(gvr_audio_context* api, float size_x,
-/// float size_y, float size_z,
-/// gvr_audio_material_name wall_material,
-/// gvr_audio_material_name ceiling_material,
-/// gvr_audio_material_name floor_material);
-///
-/// allows the user to describe the room based on its dimensions and its surface
-/// properties. For example, one can expect very large rooms to be more
-/// reverberant than smaller rooms, and a room with with hard surface materials
-/// such as brick to be more reverberant than one with soft absorbent materials
-/// such as heavy curtains on every surface.
-///
-/// Note that when a sound source is located outside of the listener's room,
-/// it will sound different from sources located within the room due to
-/// attenuation of both the direct sound and the reverb on that source. Sources
-/// located far outside of the listener's room will not be audible to the
-/// listener.
-///
-/// The following method can be used to subtly adjust the reverb in a room by
-/// changing the gain/attenuation on the reverb, setting a multiplier on the
-/// reverberation time to control the reverb's length, or adjusting the balance
-/// between the low and high frequency components of the reverb.
-///
-/// void gvr_audio_set_room_reverb_adjustments(gvr_audio_context* api,
-/// float gain,
-/// float time_adjust,
-/// float brightness_adjust);
-///
-/// If you are writing C++ code, you might prefer to use the C++ wrapper
-/// rather than implement this C API directly.
-///
-/// **Example usage (C++ API)**
-///
-/// Construction:
-///
-/// std::unique_ptr<gvr::AudioApi> gvr_audio_api(new gvr::AudioApi);
-/// gvr_audio_api->Init(GVR_AUDIO_RENDERING_BINAURAL_HIGH_QUALITY);
-///
-/// Update head rotation in DrawFrame():
-///
-/// head_pose_ = gvr_api_->GetHeadSpaceFromStartSpaceRotation(target_time);
-/// gvr_audio_api_->SetHeadPose(head_pose_);
-/// gvr_audio_api_->Update();
-///
-/// Preload sound file, create sound handle and start playback:
-///
-/// gvr_audio_api->PreloadSoundfile(kSoundFile);
-/// AudioSourceId source_id =
-/// gvr_audio_api_->CreateSoundObject("sound.wav");
-/// gvr_audio_api->SetSoundObjectPosition(source_id,
-/// position_x,
-/// position_y,
-/// position_z);
-/// gvr_audio_api->PlaySound(source_id, true /* looped playback */);
-///
-
-/// @{
-
-typedef struct gvr_audio_context_ gvr_audio_context;
-
-/// Creates and initializes a gvr_audio_context. This call also initializes
-/// the audio interface and starts the audio engine. Note that the returned
-/// instance must be deleted with gvr_audio_destroy.
-///
-#ifdef __ANDROID__
-/// @param env The JNI Env associated with the current thread.
-/// @param android_context The Android application context. This must be the
-/// application context, NOT an Activity context (Note: from any Android
-/// Activity in your app, you can call getApplicationContext() to
-/// retrieve the application context).
-/// @param class_loader The class loader to use when loading Java
-/// classes. This must be your app's main class loader (usually
-/// accessible through activity.getClassLoader() on any of your Activities).
-/// @param rendering_mode The gvr_audio_rendering_mode value which determines
-/// the rendering configuration preset. This is passed as an int32_t to
-/// ensure API compatibility.
-/// @return gvr_audio_context instance.
-gvr_audio_context* gvr_audio_create(JNIEnv* env, jobject android_context,
- jobject class_loader,
- int32_t rendering_mode);
-#else
-/// @param rendering_mode The gvr_audio_rendering_mode value which determines
-/// the rendering configuration preset. This is passed as an int32_t to
-/// ensure API compatibility.
-/// @return gvr_audio_context instance.
-gvr_audio_context* gvr_audio_create(int32_t rendering_mode);
-#endif // #ifdef __ANDROID__
-
-/// Destroys a gvr_audio_context that was previously created with
-/// gvr_audio_create or gvr_audio_create_android.
-///
-/// @param api Pointer to a pointer to a gvr_audio_context. The pointer
-/// will be set to NULL after destruction.
-void gvr_audio_destroy(gvr_audio_context** api);
-
-/// Resumes the VR Audio system.
-/// Call this when your app/game loses focus.
-/// Calling this when not paused is a no-op.
-/// Thread-safe (call from any thread).
-///
-/// @param api Pointer to a gvr_audio_context.
-void gvr_audio_resume(gvr_audio_context* api);
-
-/// Pauses the VR Audio system.
-/// Calling this when already paused is a no-op.
-/// Thread-safe (call from any thread).
-///
-/// @param api Pointer to a gvr_audio_context.
-void gvr_audio_pause(gvr_audio_context* api);
-
-/// This method must be called from the main thread at a regular rate. It is
-/// used to execute background operations outside of the audio thread.
-///
-/// @param api Pointer to a gvr_audio_context.
-void gvr_audio_update(gvr_audio_context* api);
-
-/// Preloads a local sound file. Note that the local file access method
-/// depends on the target platform.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param filename Name of the file, used as identifier.
-/// @return True on success or if file has already been preloaded.
-bool gvr_audio_preload_soundfile(gvr_audio_context* api, const char* filename);
-
-/// Unloads a previously preloaded sample from memory. Note that if the sample
-/// is currently used, the memory is freed at the moment playback stops.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param filename Name of the file, used as identifier.
-void gvr_audio_unload_soundfile(gvr_audio_context* api, const char* filename);
-
-/// Returns a new sound object. Note that the sample should only contain a
-/// single audio channel (stereo sources are automatically downmixed to mono).
-/// The handle automatically destroys itself at the moment the sound playback
-/// has stopped.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param filename The path/name of the file to be played.
-/// @return Id of new sound object. Returns kInvalidId if the sound file has not
-/// been preloaded or if the number of input channels is > 1.
-gvr_audio_source_id gvr_audio_create_sound_object(gvr_audio_context* api,
- const char* filename);
-
-/// Returns a new ambisonic sound field. Note that the sample needs to be
-/// preloaded and must have 4 separate audio channels. The handle automatically
-/// destroys itself at the moment the sound playback has stopped.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param filename The path/name of the file to be played.
-/// @return Id of new soundfield. Returns kInvalidId if the sound file has not
-/// been preloaded or if the number of input channels does not match that
-/// required.
-gvr_audio_source_id gvr_audio_create_soundfield(gvr_audio_context* api,
- const char* filename);
-
-/// Returns a new stereo non-spatialized source, which directly plays back mono
-/// or stereo audio. Note the sample needs to be preloaded and may contain only
-/// one (mono) or two (stereo) audio channels.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param filename The path/name of the file to be played..
-/// @return Id of new stereo non-spatialized source. Returns kInvalidId if the
-/// sound file has not been preloaded or if the number of input channels is
-/// > 2;
-gvr_audio_source_id gvr_audio_create_stereo_sound(gvr_audio_context* api,
- const char* filename);
-
-/// Starts the playback of a sound.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param source_id Id of the audio source to be stopped.
-/// @param looping_enabled Enables looped audio playback.
-void gvr_audio_play_sound(gvr_audio_context* api, gvr_audio_source_id source_id,
- bool looping_enabled);
-
-/// Pauses the playback of a sound.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param source_id Id of the audio source to be paused.
-void gvr_audio_pause_sound(gvr_audio_context* api,
- gvr_audio_source_id source_id);
-
-/// Resumes the playback of a sound.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param source_id Id of the audio source to be resumed.
-void gvr_audio_resume_sound(gvr_audio_context* api,
- gvr_audio_source_id source_id);
-
-/// Stops the playback of a sound and destroys the corresponding sound object
-/// or Soundfield.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param source_id Id of the audio source to be stopped.
-void gvr_audio_stop_sound(gvr_audio_context* api,
- gvr_audio_source_id source_id);
-
-/// Checks if a sound is playing.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param source_id Id of the audio source to be checked.
-/// @return True if the sound is being played.
-bool gvr_audio_is_sound_playing(const gvr_audio_context* api,
- gvr_audio_source_id source_id);
-
-/// Checks if a |source_id| is valid, and that the corresponding source is in a
-/// playable state. Sources that have been stopped will be reported as invalid.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param source_id Id of the audio source to be checked.
-/// @return True if the source exists and is in a playable state.
-bool gvr_audio_is_source_id_valid(const gvr_audio_context* api,
- gvr_audio_source_id source_id);
-
-/// Repositions an existing sound object.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param sound_object_id Id of the sound object to be moved.
-/// @param x X coordinate the sound will be placed at.
-/// @param y Y coordinate the sound will be placed at.
-/// @param z Z coordinate the sound will be placed at.
-void gvr_audio_set_sound_object_position(gvr_audio_context* api,
- gvr_audio_source_id sound_object_id,
- float x, float y, float z);
-
-/// Sets the given ambisonic soundfields's rotation.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param soundfield_id Id of the soundfield source to be rotated.
-/// @param soundfield_rotation Quaternion representing the soundfield rotation.
-void gvr_audio_set_soundfield_rotation(gvr_audio_context* api,
- gvr_audio_source_id soundfield_id,
- const gvr_quatf& soundfield_rotation);
-
-/// Sets the given sound object source's distance attenuation method with
-/// minimum and maximum distances. Maximum distance must be greater than the
-/// minimum distance for the method to be set.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param sound_object_id Id of sound object source.
-/// @param rolloff_model Linear or logarithmic distance rolloff models. Note
-/// setting the rolloff model to |GVR_AUDIO_ROLLOFF_NONE| will allow
-/// distance attenuation values to be set manually.
-/// @param min_distance Minimum distance to apply distance attenuation method.
-/// @param max_distance Maximum distance to apply distance attenuation method.
-void gvr_audio_set_sound_object_distance_rolloff_model(
- gvr_audio_context* api, gvr_audio_source_id sound_object_id,
- int32_t rolloff_model, float min_distance, float max_distance);
-
-/// Changes the master volume.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param volume Volume value. Should range from 0 (mute) to 1 (max).
-void gvr_audio_set_master_volume(gvr_audio_context* api, float volume);
-
-/// Changes the volume of an existing sound.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param source_id Id of the audio source to be modified.
-/// @param volume Volume value. Should range from 0 (mute) to 1 (max).
-void gvr_audio_set_sound_volume(gvr_audio_context* api,
- gvr_audio_source_id source_id, float volume);
-
-/// Sets the head pose from a matrix representation of the same.
-///
-/// @param api Pointer to a gvr_audio_context on which to set the pose.
-/// @param head_pose_matrix Matrix representing the head transform to be set.
-void gvr_audio_set_head_pose(gvr_audio_context* api,
- const gvr_mat4f& head_pose_matrix);
-
-/// Turns on/off the room reverberation effect.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param enable True to enable room effect.
-void gvr_audio_enable_room(gvr_audio_context* api, bool enable);
-
-/// Sets the room properties describing the dimensions and surface materials of
-/// a given room.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param size_x Dimension along X axis.
-/// @param size_y Dimension along Y axis.
-/// @param size_z Dimension along Z axis.
-/// @param wall_material Surface gvr_audio_material_type for the four walls.
-/// @param ceiling_material Surface gvr_audio_material_type for the ceiling.
-/// @param floor_material Surface gvr_audio_material_type for the floor.
-void gvr_audio_set_room_properties(gvr_audio_context* api, float size_x,
- float size_y, float size_z,
- int32_t wall_material,
- int32_t ceiling_material,
- int32_t floor_material);
-
-/// Adjusts the properties of the current reverb, allowing changes to the
-/// reverb's gain, duration and low/high frequency balance.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param gain Reverb volume (linear) adjustment in range [0, 1] for
-/// attenuation, range [1, inf) for gain boost.
-/// @param time_adjust Reverb time adjustment multiplier to scale the
-/// reverberation tail length. This value should be >= 0.
-/// @param brightness_adjust Reverb brightness adjustment that controls the
-/// reverberation ratio across low and high frequency bands.
-void gvr_audio_set_room_reverb_adjustments(gvr_audio_context* api, float gain,
- float time_adjust,
- float brightness_adjust);
-
-/// Enables the stereo speaker mode. It enforces stereo-panning when headphones
-/// are *not* plugged into the phone. This helps to avoid HRTF-based coloring
-/// effects and reduces computational complexity when speaker playback is
-/// active. By default the stereo speaker mode optimization is disabled.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param enable True to enable the stereo speaker mode.
-void gvr_audio_enable_stereo_speaker_mode(gvr_audio_context* api, bool enable);
-
-/// @}
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-// Convenience C++ wrapper.
-#if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-
-#include <memory>
-#include <string>
-
-namespace gvr {
-/// This is a convenience C++ wrapper for the Audio C API.
-///
-/// This wrapper strategy prevents ABI compatibility issues between compilers
-/// by ensuring that the interface between client code and the implementation
-/// code in libgvr.so is a pure C interface. The translation from C++ calls
-/// to C calls provided by this wrapper runs entirely in the client's binary
-/// and is compiled by the client's compiler.
-///
-/// Methods in this class are only documented insofar as the C++ wrapping logic
-/// is concerned; for information about the method itself, please refer to the
-/// corresponding function in the C API.
-///
-///
-/// THREADING: this class is thread-safe and reentrant after initialized
-/// with Init().
-class AudioApi {
- public:
- /// Creates an (uninitialized) ControllerApi object. You must initialize
- /// it by calling Init() before interacting with it.
- AudioApi() : context_(nullptr) {}
-
- ~AudioApi() {
- if (context_) {
- gvr_audio_destroy(&context_);
- }
- }
-
-/// Creates and initializes a gvr_audio_context.
-/// For more information, see gvr_audio_create().
-#ifdef __ANDROID__
- bool Init(JNIEnv* env, jobject android_context, jobject class_loader,
- AudioRenderingMode rendering_mode) {
- context_ =
- gvr_audio_create(env, android_context, class_loader, rendering_mode);
- return context_ != nullptr;
- }
-#else
- bool Init(AudioRenderingMode rendering_mode) {
- context_ = gvr_audio_create(rendering_mode);
- return context_ != nullptr;
- }
-#endif // #ifdef __ANDROID__
-
- /// Pauses the audio engine.
- /// For more information, see gvr_audio_pause().
- void Pause() { gvr_audio_pause(context_); }
-
- /// Resumes the audio engine.
- /// For more information, see gvr_audio_resume().
- void Resume() { gvr_audio_resume(context_); }
-
- /// For more information, see gvr_audio_update().
- void Update() { gvr_audio_update(context_); }
-
- /// Preloads a local sound file.
- /// For more information, see gvr_audio_preload_soundfile().
- bool PreloadSoundfile(const std::string& filename) {
- return gvr_audio_preload_soundfile(context_, filename.c_str());
- }
-
- /// Unloads a previously preloaded sample from memory.
- /// For more information, see gvr_audio_preload_soundfile().
- void UnloadSoundfile(const std::string& filename) {
- gvr_audio_unload_soundfile(context_, filename.c_str());
- }
-
- /// Returns a new sound object.
- /// For more information, see gvr_audio_create_sound_object().
- AudioSourceId CreateSoundObject(const std::string& filename) {
- return gvr_audio_create_sound_object(context_, filename.c_str());
- }
-
- /// Returns a new sound field.
- /// For more information, see gvr_audio_create_soundfield().
- AudioSourceId CreateSoundfield(const std::string& filename) {
- return gvr_audio_create_soundfield(context_, filename.c_str());
- }
-
- /// Returns a new stereo sound.
- /// For more information, see gvr_audio_create_stereo_sound().
- AudioSourceId CreateStereoSound(const std::string& filename) {
- return gvr_audio_create_stereo_sound(context_, filename.c_str());
- }
-
- /// Starts the playback of a sound.
- /// For more information, see gvr_audio_play_sound().
- void PlaySound(AudioSourceId source_id, bool looping_enabled) {
- gvr_audio_play_sound(context_, source_id, looping_enabled);
- }
-
- /// Pauses the playback of a sound.
- /// For more information, see gvr_audio_pause_sound().
- void PauseSound(AudioSourceId source_id) {
- gvr_audio_pause_sound(context_, source_id);
- }
-
- /// Resumes the playback of a sound.
- /// For more information, see gvr_audio_resume_sound().
- void ResumeSound(AudioSourceId source_id) {
- gvr_audio_resume_sound(context_, source_id);
- }
-
- /// Stops the playback of a sound.
- /// For more information, see gvr_audio_stop_sound().
- void StopSound(AudioSourceId source_id) {
- gvr_audio_stop_sound(context_, source_id);
- }
-
- /// Checks if a sound is playing.
- /// For more information, see gvr_audio_is_sound_playing().
- bool IsSoundPlaying(AudioSourceId source_id) const {
- return gvr_audio_is_sound_playing(context_, source_id);
- }
-
- /// Checks if a source is in a valid playable state.
- /// For more information, see gvr_audio_is_source_id_valid().
- bool IsSourceIdValid(AudioSourceId source_id) {
- return gvr_audio_is_source_id_valid(context_, source_id);
- }
-
- /// Repositions an existing sound object.
- /// For more information, see gvr_audio_set_sound_object_position().
- void SetSoundObjectPosition(AudioSourceId sound_object_id, float x, float y,
- float z) {
- gvr_audio_set_sound_object_position(context_, sound_object_id, x, y, z);
- }
-
- void SetSoundObjectDistanceRolloffModel(
- AudioSourceId sound_object_id,
- gvr_audio_distance_rolloff_type rolloff_model, float min_distance,
- float max_distance) {
- gvr_audio_set_sound_object_distance_rolloff_model(
- context_, sound_object_id, rolloff_model, min_distance, max_distance);
- }
-
- /// Rotates an existing soundfield.
- /// For more information, see gvr_audio_set_soundfield_rotation().
- void SetSoundfieldRotation(AudioSourceId soundfield_id,
- const Quatf& soundfield_rotation) {
- gvr_audio_set_soundfield_rotation(context_, soundfield_id,
- soundfield_rotation);
- }
-
- /// Changes the master volume.
- /// For more information, see gvr_audio_set_master_volume().
- void SetMasterVolume(float volume) {
- gvr_audio_set_master_volume(context_, volume);
- }
-
- /// Changes the volume of an existing sound.
- /// For more information, see gvr_audio_set_sound_volume().
- void SetSoundVolume(AudioSourceId source_id, float volume) {
- gvr_audio_set_sound_volume(context_, source_id, volume);
- }
-
- /// Sets the head position from a matrix representation.
- /// For more information, see gvr_audio_set_head_pose().
- void SetHeadPose(const Mat4f& head_pose_matrix) {
- gvr_audio_set_head_pose(context_, head_pose_matrix);
- }
-
- /// Turns on/off the room reverberation effect.
- /// For more information, see gvr_audio_enable_room().
- void EnableRoom(bool enable) { gvr_audio_enable_room(context_, enable); }
-
- /// Sets the room properties describing the dimensions and surface materials
- /// of a given room. For more information, see
- /// gvr_audio_set_room_properties().
- void SetRoomProperties(float size_x, float size_y, float size_z,
- gvr_audio_material_type wall_material,
- gvr_audio_material_type ceiling_material,
- gvr_audio_material_type floor_material) {
- gvr_audio_set_room_properties(context_, size_x, size_y, size_z,
- wall_material, ceiling_material,
- floor_material);
- }
-
- /// Adjusts the properties of the current reverb, allowing changes to the
- /// reverb's gain, duration and low/high frequency balance. For more
- /// information see gvr_audio_set_room_reverb_adjustments().
- void SetRoomReverbAdjustments(float gain, float time_adjust,
- float brightness_adjust) {
- gvr_audio_set_room_reverb_adjustments(context_, gain, time_adjust,
- brightness_adjust);
- }
-
- /// Enables the stereo speaker mode. For more information see
- /// gvr_audio_enable_stereo_speaker_mode().
- void EnableStereoSpeakerMode(bool enable) {
- gvr_audio_enable_stereo_speaker_mode(context_, enable);
- }
-
- /// @name Wrapper manipulation
- /// @{
- /// Creates a C++ wrapper for a C object and takes ownership.
- explicit AudioApi(gvr_audio_context* context) : context_(context) {}
-
- /// Returns the wrapped C object. Does not affect ownership.
- gvr_audio_context* cobj() { return context_; }
- const gvr_audio_context* cobj() const { return context_; }
-
- /// Returns the wrapped C object and transfers its ownership to the caller.
- /// The wrapper becomes invalid and should not be used.
- gvr_audio_context* Release() {
- auto result = context_;
- context_ = nullptr;
- return result;
- }
- /// @}
-
- private:
- gvr_audio_context* context_;
-
- // Disallow copy and assign:
- AudioApi(const AudioApi&);
- void operator=(const AudioApi&);
-};
-
-} // namespace gvr
-#endif // #if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-
-#endif // VR_GVR_CAPI_INCLUDE_GVR_AUDIO_H_
diff --git a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr_controller.h b/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr_controller.h
deleted file mode 100644
index 8347393..0000000
--- a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr_controller.h
+++ /dev/null
@@ -1,793 +0,0 @@
-/* Copyright 2016 Google Inc. All rights reserved.
- *
- * 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 VR_GVR_CAPI_INCLUDE_GVR_CONTROLLER_H_
-#define VR_GVR_CAPI_INCLUDE_GVR_CONTROLLER_H_
-
-#ifdef __ANDROID__
-#include <jni.h>
-#endif
-
-#include <stdint.h>
-
-#include "vr/gvr/capi/include/gvr.h"
-#include "vr/gvr/capi/include/gvr_types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/// @defgroup Controller Controller API
-/// @brief This is the Controller C API, which allows access to a VR controller.
-///
-/// If you are writing C++ code, you might prefer to use the C++ wrapper rather
-/// than implement this C API directly.
-///
-/// Typical initialization example:
-///
-/// // Get your gvr_context* pointer from GvrLayout:
-/// gvr_context* gvr = ......; // (get from GvrLayout in Java)
-///
-/// // Set up the API features:
-/// int32_t options = gvr_controller_get_default_options();
-///
-/// // Enable non-default options, if needed:
-/// options |= GVR_CONTROLLER_ENABLE_GYRO | GVR_CONTROLLER_ENABLE_ACCEL;
-///
-/// // Create and init:
-/// gvr_controller_context* context =
-/// gvr_controller_create_and_init(options, gvr);
-///
-/// // Check if init was successful.
-/// if (!context) {
-/// // Handle error.
-/// return;
-/// }
-///
-/// gvr_controller_state* state = gvr_controller_state_create();
-///
-/// // Resume:
-/// gvr_controller_resume(api);
-///
-/// Usage:
-///
-/// void DrawFrame() {
-/// gvr_controller_state_update(context, 0, state);
-/// // ... process controller state ...
-/// }
-///
-/// // When your application gets paused:
-/// void OnPause() {
-/// gvr_controller_pause(context);
-/// }
-///
-/// // When your application gets resumed:
-/// void OnResume() {
-/// gvr_controller_resume(context);
-/// }
-///
-/// To conserve battery, be sure to call gvr_controller_pause and
-/// gvr_controller_resume when your app gets paused and resumed, respectively.
-///
-/// THREADING: unless otherwise noted, all functions are thread-safe, so
-/// you can operate on the same gvr_controller_context object from multiple
-/// threads.
-/// @{
-
-/// Represents a Daydream Controller API object, used to invoke the
-/// Daydream Controller API.
-typedef struct gvr_controller_context_ gvr_controller_context;
-
-/// Returns the default features for the controller API.
-///
-/// @return The set of default features, as bit flags (an OR'ed combination of
-/// the GVR_CONTROLLER_ENABLE_* feature flags).
-int32_t gvr_controller_get_default_options();
-
-/// Creates and initializes a gvr_controller_context instance which can be used
-/// to invoke the Daydream Controller API functions. Important: after creation
-/// the API will be in the paused state (the controller will be inactive).
-/// You must call gvr_controller_resume() explicitly (typically, in your Android
-/// app's onResume() callback).
-///
-/// @param options The API options. To get the defaults, use
-/// gvr_controller_get_default_options().
-/// @param context The GVR Context object to sync with (optional).
-/// This can be nullptr. If provided, the context's state will
-/// be synchronized with the controller's state where possible. For
-/// example, when the user recenters the controller, this will
-/// automatically recenter head tracking as well.
-/// WARNING: the caller is responsible for making sure the pointer
-/// remains valid for the lifetime of this object.
-/// @return A pointer to the initialized API, or NULL if an error occurs.
-gvr_controller_context* gvr_controller_create_and_init(
- int32_t options, gvr_context* context);
-
-#ifdef __ANDROID__
-/// Creates and initializes a gvr_controller_context instance with an explicit
-/// Android context and class loader.
-///
-/// @param env The JNI Env associated with the current thread.
-/// @param android_context The Android application context. This must be the
-/// application context, NOT an Activity context (Note: from any Android
-/// Activity in your app, you can call getApplicationContext() to
-/// retrieve the application context).
-/// @param class_loader The class loader to use when loading Java
-/// classes. This must be your app's main class loader (usually
-/// accessible through activity.getClassLoader() on any of your Activities).
-/// @param options The API options. To get the defaults, use
-/// gvr_controller_get_default_options().
-/// @param context The GVR Context object to sync with (optional).
-/// This can be nullptr. If provided, the context's state will
-/// be synchronized with the controller's state where possible. For
-/// example, when the user recenters the controller, this will
-/// automatically recenter head tracking as well.
-/// WARNING: the caller is responsible for making sure the pointer
-/// remains valid for the lifetime of this object.
-/// @return A pointer to the initialized API, or NULL if an error occurs.
-gvr_controller_context* gvr_controller_create_and_init_android(
- JNIEnv *env, jobject android_context, jobject class_loader,
- int32_t options, gvr_context* context);
-#endif // #ifdef __ANDROID__
-
-/// Destroys a gvr_controller_context that was previously created with
-/// gvr_controller_init.
-///
-/// @param api Pointer to a pointer to a gvr_controller_context. The pointer
-/// will be set to NULL after destruction.
-void gvr_controller_destroy(gvr_controller_context** api);
-
-/// Pauses the controller, possibly releasing resources.
-/// Call this when your app/game loses focus.
-/// Calling this when already paused is a no-op.
-/// Thread-safe (call from any thread).
-///
-/// @param api Pointer to a pointer to a gvr_controller_context.
-void gvr_controller_pause(gvr_controller_context* api);
-
-/// Resumes the controller. Call this when your app/game regains focus.
-/// Calling this when already resumed is a no-op.
-/// Thread-safe (call from any thread).
-///
-/// @param api Pointer to a pointer to a gvr_controller_context.
-void gvr_controller_resume(gvr_controller_context* api);
-
-/// Convenience to convert an API status code to string. The returned pointer
-/// is static and valid throughout the lifetime of the application.
-///
-/// @param status The gvr_controller_api_status to convert to string.
-/// @return A pointer to a string that describes the value.
-const char* gvr_controller_api_status_to_string(int32_t status);
-
-/// Convenience to convert an connection state to string. The returned pointer
-/// is static and valid throughout the lifetime of the application.
-///
-/// @param state The state to convert to string.
-/// @return A pointer to a string that describes the value.
-const char* gvr_controller_connection_state_to_string(int32_t state);
-
-/// Convenience to convert an connection state to string. The returned pointer
-/// is static and valid throughout the lifetime of the application.
-///
-/// @param button The gvr_controller_button to convert to string.
-/// @return A pointer to a string that describes the value.
-const char* gvr_controller_button_to_string(int32_t button);
-
-/// Creates a gvr_controller_state.
-gvr_controller_state* gvr_controller_state_create();
-
-/// Destroys a a gvr_controller_state that was previously created with
-/// gvr_controller_state_create.
-void gvr_controller_state_destroy(gvr_controller_state** state);
-
-/// Updates the controller state. Reading the controller state is not a
-/// const getter: it has side-effects. In particular, some of the
-/// gvr_controller_state fields (the ones documented as "transient") represent
-/// one-time events and will be true for only one read operation, and false
-/// in subsequente reads.
-///
-/// @param api Pointer to a pointer to a gvr_controller_context.
-/// @param flags Optional flags reserved for future use. A value of 0 should be
-/// used until corresponding flag attributes are defined and documented.
-/// @param out_state A pointer where the controller's state
-/// is to be written. This must have been allocated with
-/// gvr_controller_state_create().
-void gvr_controller_state_update(gvr_controller_context* api, int32_t flags,
- gvr_controller_state* out_state);
-
-/// Gets the API status of the controller state. Returns one of the
-/// gvr_controller_api_status variants, but returned as an int32_t for ABI
-/// compatibility.
-int32_t gvr_controller_state_get_api_status(const gvr_controller_state* state);
-
-/// Gets the connection state of the controller. Returns one of the
-/// gvr_controller_connection_state variants, but returned as an int32_t for ABI
-/// compatibility.
-int32_t gvr_controller_state_get_connection_state(
- const gvr_controller_state* state);
-
-/// Returns the current controller orientation, in Start Space. The Start Space
-/// is the same space as the headset space and has these three axes
-/// (right-handed):
-///
-/// * The positive X axis points to the right.
-/// * The positive Y axis points upwards.
-/// * The positive Z axis points backwards.
-///
-/// The definition of "backwards" and "to the right" are based on the position
-/// of the controller when tracking started. For Daydream, this is when the
-/// controller was first connected in the "Connect your Controller" screen
-/// which is shown when the user enters VR.
-///
-/// The definition of "upwards" is given by gravity (away from the pull of
-/// gravity). This API may not work in environments without gravity, such
-/// as space stations or near the center of the Earth.
-///
-/// Since the coordinate system is right-handed, rotations are given by the
-/// right-hand rule. For example, rotating the controller counter-clockwise
-/// on a table top as seen from above means a positive rotation about the
-/// Y axis, while clockwise would mean negative.
-///
-/// Note that this is the Start Space for the *controller*, which initially
-/// coincides with the Start Space for the headset, but they may diverge over
-/// time due to controller/headset drift. A recentering operation will bring
-/// the two spaces back into sync.
-///
-/// Remember that a quaternion expresses a rotation. Given a rotation of theta
-/// radians about the (x, y, z) axis, the corresponding quaternion (in
-/// xyzw order) is:
-///
-/// (x * sin(theta/2), y * sin(theta/2), z * sin(theta/2), cos(theta/2))
-///
-/// Here are some examples of orientations of the controller and their
-/// corresponding quaternions, all given in xyzw order:
-///
-/// * Initial pose, pointing forward and lying flat on a surface: identity
-/// quaternion (0, 0, 0, 1). Corresponds to "no rotation".
-///
-/// * Flat on table, rotated 90 degrees counter-clockwise: (0, 0.7071, 0,
-/// 0.7071). Corresponds to a +90 degree rotation about the Y axis.
-///
-/// * Flat on table, rotated 90 degrees clockwise: (0, -0.7071, 0, 0.7071).
-/// Corresponds to a -90 degree rotation about the Y axis.
-///
-/// * Flat on table, rotated 180 degrees (pointing backwards): (0, 1, 0, 0).
-/// Corresponds to a 180 degree rotation about the Y axis.
-///
-/// * Pointing straight up towards the sky: (0.7071, 0, 0, 0.7071).
-/// Corresponds to a +90 degree rotation about the X axis.
-///
-/// * Pointing straight down towards the ground: (-0.7071, 0, 0, 0.7071).
-/// Corresponds to a -90 degree rotation about the X axis.
-///
-/// * Banked 90 degrees to the left: (0, 0, 0.7071, 0.7071). Corresponds
-/// to a +90 degree rotation about the Z axis.
-///
-/// * Banked 90 degrees to the right: (0, 0, -0.7071, 0.7071). Corresponds
-/// to a -90 degree rotation about the Z axis.
-gvr_quatf gvr_controller_state_get_orientation(
- const gvr_controller_state* state);
-
-/// Returns the current controller gyro reading, in Start Space.
-///
-/// The gyro measures the controller's angular speed in radians per second.
-/// Note that this is an angular *speed*, so it reflects how fast the
-/// controller's orientation is changing with time.
-/// In particular, if the controller is not being rotated, the angular speed
-/// will be zero on all axes, regardless of the current pose.
-///
-/// The axes are in the controller's device space. Specifically:
-///
-/// * The X axis points to the right of the controller.
-/// * The Y axis points upwards perpendicular to the top surface of the
-/// controller.
-/// * The Z axis points backwards along the body of the controller,
-/// towards its rear, where the charging port is.
-///
-/// As usual in a right-handed coordinate system, the sign of the angular
-/// velocity is given by the right-hand rule. So, for example:
-///
-/// * If the controller is flat on a table top spinning counter-clockwise
-/// as seen from above, you will read a positive angular velocity
-/// about the Y axis. Clockwise would be negative.
-/// * If the controller is initially pointing forward and lying flat and
-/// is then gradually angled up so that its tip points towards the sky,
-/// it will report a positive angular velocity about the X axis during
-/// that motion. Likewise, angling it down will report a negative angular
-/// velocity about the X axis.
-/// * If the controller is banked (rolled) to the right, this will
-/// report a negative angular velocity about the Z axis during the
-/// motion (remember the Z axis points backwards along the controller).
-/// Banking to the left will report a positive angular velocity about
-/// the Z axis.
-gvr_vec3f gvr_controller_state_get_gyro(const gvr_controller_state* state);
-
-/// Current (latest) controller accelerometer reading, in Start Space.
-///
-/// The accelerometer indicates the direction in which the controller feels
-/// an acceleration, including gravity. The reading is given in meters
-/// per second squared (m/s^2). The axes are the same as for the gyro.
-/// To have an intuition for the signs used in the accelerometer, it is useful
-/// to imagine that, when at rest, the controller is being "pushed" by a
-/// force opposite to gravity. It is as if, by the equivalency princle, it were
-/// on a frame of reference that is accelerating in the opposite direction to
-/// gravity. For example:
-///
-/// * If the controller is lying flat on a table top, it will read a positive
-/// acceleration of about 9.8 m/s^2 along the Y axis, corresponding to
-/// the acceleration of gravity (as if the table were pushing the controller
-/// upwards at 9.8 m/s^2 to counteract gravity).
-/// * If, in that situation, the controller is now accelerated upwards at
-/// 3.0 m/s^2, then the reading will be 12.8 m/s^2 along the Y axis,
-/// since the controller will now feel a stronger acceleration corresponding
-/// to the 9.8 m/s^2 plus the upwards push of 3.0 m/s^2.
-/// * If, the controller is accelerated downwards at 5.0 m/s^2, then the
-/// reading will now be 4.8 m/s^2 along the Y axis, since the controller
-/// will now feel a weaker acceleration (as the acceleration is giving in
-/// to gravity).
-/// * If you were to give in to gravity completely, letting the controller
-/// free fall towards the ground, it will read 0 on all axes, as there
-/// will be no force acting on the controller. (Please do not put your
-/// controller in a free-fall situation. This is just a theoretical
-/// example.)
-gvr_vec3f gvr_controller_state_get_accel(const gvr_controller_state* state);
-
-/// Returns whether the user is touching the touchpad.
-bool gvr_controller_state_is_touching(const gvr_controller_state* state);
-
-/// If the user is touching the touchpad, this returns the touch position in
-/// normalized coordinates, where (0,0) is the top-left of the touchpad
-/// and (1,1) is the bottom right. If the user is not touching the touchpad,
-/// then this is the position of the last touch.
-gvr_vec2f gvr_controller_state_get_touch_pos(const gvr_controller_state* state);
-
-/// Returns true if user just started touching touchpad (this is a transient
-/// event:
-/// it is true for only one frame after the event).
-bool gvr_controller_state_get_touch_down(const gvr_controller_state* state);
-
-/// Returns true if user just stopped touching touchpad (this is a transient
-/// event:
-/// it is true for only one frame after the event).
-bool gvr_controller_state_get_touch_up(const gvr_controller_state* state);
-
-/// Returns true if a recenter operation just ended (this is a transient event:
-/// it is true only for one frame after the recenter ended). If this is
-/// true then the `orientation` field is already relative to the new center.
-bool gvr_controller_state_get_recentered(const gvr_controller_state* state);
-
-/// Returns whether the recenter flow is currently in progress.
-///
-/// @deprecated Use gvr_controller_state_get_recentered instead.
-bool gvr_controller_state_get_recentering(const gvr_controller_state* state);
-
-/// Returns whether the given button is currently pressed.
-bool gvr_controller_state_get_button_state(const gvr_controller_state* state,
-
- int32_t button);
-
-/// Returns whether the given button was just pressed (transient).
-bool gvr_controller_state_get_button_down(const gvr_controller_state* state,
- int32_t button);
-
-/// Returns whether the given button was just released (transient).
-bool gvr_controller_state_get_button_up(const gvr_controller_state* state,
- int32_t button);
-
-/// Returns the timestamp (nanos) when the last orientation event was received.
-int64_t gvr_controller_state_get_last_orientation_timestamp(
- const gvr_controller_state* state);
-
-/// Returns the timestamp (nanos) when the last gyro event was received.
-int64_t gvr_controller_state_get_last_gyro_timestamp(
- const gvr_controller_state* state);
-
-/// Returns the timestamp (nanos) when the last accelerometer event was
-/// received.
-int64_t gvr_controller_state_get_last_accel_timestamp(
- const gvr_controller_state* state);
-
-/// Returns the timestamp (nanos) when the last touch event was received.
-int64_t gvr_controller_state_get_last_touch_timestamp(
- const gvr_controller_state* state);
-
-/// Returns the timestamp (nanos) when the last button event was received.
-int64_t gvr_controller_state_get_last_button_timestamp(
- const gvr_controller_state* state);
-
-// Current (latest) controller simulated position for use with an elbow model.
-gvr_vec3f gvr_controller_state_get_position(const gvr_controller_state* state);
-
-// Returns the timestamp (nanos) when the last position event was received.
-int64_t gvr_controller_state_get_last_position_timestamp(
- const gvr_controller_state* state);
-
-/// Returns whether the controller battery is currently charging.
-/// This may not be real time information and may be slow to be updated.
-bool gvr_controller_state_get_battery_charging(
- const gvr_controller_state* state);
-
-/// Returns the bucketed controller battery level.
-/// Note this is a gvr_controller_battery_level and not a percent.
-int32_t gvr_controller_state_get_battery_level(
- const gvr_controller_state* state);
-
-/// Returns the timestamp (nanos) when the last battery event was received.
-int64_t gvr_controller_state_get_last_battery_timestamp(
- const gvr_controller_state* state);
-
-/// Convenience to convert a battery level to string. The returned pointer
-/// is static and valid throughout the lifetime of the application.
-///
-/// @param level The gvr_controller_battery_level to convert to string.
-/// @return A pointer to a string that describes the value.
-const char* gvr_controller_battery_level_to_string(int32_t level);
-
-/// @}
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-
-// Convenience C++ wrapper.
-#if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-
-#include <memory>
-
-namespace gvr {
-/// This is a convenience C++ wrapper for the Controller C API.
-///
-/// This wrapper strategy prevents ABI compatibility issues between compilers
-/// by ensuring that the interface between client code and the implementation
-/// code in libgvr.so is a pure C interface. The translation from C++ calls
-/// to C calls provided by this wrapper runs entirely in the client's binary
-/// and is compiled by the client's compiler.
-///
-/// Methods in this class are only documented insofar as the C++ wrapping logic
-/// is concerned; for information about the method itself, please refer to the
-/// corresponding function in the C API.
-///
-/// Typical C++ initialization example:
-///
-/// std::unique_ptr<ControllerApi> controller_api(new ControllerApi);
-///
-/// // Your GVR context pointer (which can be obtained from GvrLayout)
-/// gvr_context* context = .....; // (get it from GvrLayout)
-///
-/// // Set up the options:
-/// int32_t options = ControllerApi::DefaultOptions();
-///
-/// // Enable non-default options, if you need them:
-/// options |= GVR_CONTROLLER_ENABLE_GYRO;
-///
-/// // Init the ControllerApi object:
-/// bool success = controller_api->Init(options, context);
-/// if (!success) {
-/// // Handle failure.
-/// // Do NOT call other methods (like Resume, etc) if init failed.
-/// return;
-/// }
-///
-/// // Resume the ControllerApi (if your app is on the foreground).
-/// controller_api->Resume();
-///
-/// ControllerState state;
-///
-/// Usage example:
-///
-/// void DrawFrame() {
-/// state.Update(*controller_api);
-/// // ... process controller state ...
-/// }
-///
-/// // When your application gets paused:
-/// void OnPause() {
-/// controller_api->Pause();
-/// }
-///
-/// // When your application gets resumed:
-/// void OnResume() {
-/// controller_api->Resume();
-/// }
-///
-/// To conserve battery, be sure to call Pause() and Resume() when your app
-/// gets paused and resumed, respectively. This will allow the underlying
-/// logic to unbind from the VR service and let the controller sleep when
-/// no apps are using it.
-///
-/// THREADING: this class is thread-safe and reentrant after initialized
-/// with Init().
-class ControllerApi {
- public:
- /// Creates an (uninitialized) ControllerApi object. You must initialize
- /// it by calling Init() before interacting with it.
- ControllerApi() : context_(nullptr) {}
-
- /// Returns the default controller options.
- static int32_t DefaultOptions() {
- return gvr_controller_get_default_options();
- }
-
- // Deprecated factory-style create method.
- // TODO(btco): remove this once no one is using it.
- static std::unique_ptr<ControllerApi> Create() {
- return std::unique_ptr<ControllerApi>(new ControllerApi);
- }
-
- /// Initializes the controller API.
- ///
- /// This method must be called exactly once in the lifetime of this object.
- /// Other methods in this class may only be called after Init() returns true.
- /// Note: this does not cause the ControllerApi to be resumed. You must call
- /// Resume() explicitly in order to start using the controller.
- ///
- /// For more information see gvr_controller_create_and_init().
- ///
- /// @return True if initialization was successful, false if it failed.
- /// Initialization may fail, for example, because invalid options were
- /// supplied.
- bool Init(int32_t options, gvr_context* context) {
- context_ = gvr_controller_create_and_init(options, context);
- return context_ != nullptr;
- }
-
-#ifdef __ANDROID__
- /// Overload of Init() with explicit Android context and class loader
- /// (for Android only). For more information, see:
- /// gvr_controller_create_and_init_android().
- bool Init(JNIEnv *env, jobject android_context, jobject class_loader,
- int32_t options, gvr_context* context) {
- context_ = gvr_controller_create_and_init_android(
- env, android_context, class_loader, options, context);
- return context_ != nullptr;
- }
-#endif // #ifdef __ANDROID__
-
- /// Convenience overload that calls Init without a gvr_context.
- // TODO(btco): remove once it is no longer being used.
- bool Init(int32_t options) {
- return Init(options, nullptr);
- }
-
- /// Pauses the controller.
- /// For more information, see gvr_controller_pause().
- void Pause() {
- gvr_controller_pause(context_);
- }
-
- /// Resumes the controller.
- /// For more information, see gvr_controller_resume().
- void Resume() {
- gvr_controller_resume(context_);
- }
-
- /// Destroys this ControllerApi instance.
- ~ControllerApi() {
- if (context_) gvr_controller_destroy(&context_);
- }
-
- /// Convenience functions to convert enums to strings.
- /// For more information, see the corresponding functions in the C API.
- static const char* ToString(ControllerApiStatus status) {
- return gvr_controller_api_status_to_string(status);
- }
-
- static const char* ToString(ControllerConnectionState state) {
- return gvr_controller_connection_state_to_string(state);
- }
-
- static const char* ToString(ControllerButton button) {
- return gvr_controller_button_to_string(button);
- }
-
- static const char* ToString(ControllerBatteryLevel level) {
- return gvr_controller_battery_level_to_string(level);
- }
-
- /// @name Wrapper manipulation
- /// @{
- /// Creates a C++ wrapper for a C object and takes ownership.
- explicit ControllerApi(gvr_controller_context* context)
- : context_(context) {}
-
- /// Returns the wrapped C object. Does not affect ownership.
- gvr_controller_context* cobj() { return context_; }
- const gvr_controller_context* cobj() const { return context_; }
-
- /// Returns the wrapped C object and transfers its ownership to the caller.
- /// The wrapper becomes invalid and should not be used.
- gvr_controller_context* release() {
- auto result = context_;
- context_ = nullptr;
- return result;
- }
- /// @}
-
- protected:
- gvr_controller_context* context_;
-
- private:
- friend class ControllerState;
-
- // Disallow copy and assign:
- ControllerApi(const ControllerApi&);
- void operator=(const ControllerApi&);
-};
-
-/// Convenience C++ wrapper for the opaque gvr_controller_state type. See the
-/// gvr_controller_state functions for more information.
-class ControllerState {
- public:
- ControllerState() : state_(gvr_controller_state_create()) {}
-
- ~ControllerState() {
- if (state_) gvr_controller_state_destroy(&state_);
- }
-
- /// For more information, see gvr_controller_state_update().
- void Update(const ControllerApi& api) {
- gvr_controller_state_update(api.context_, 0, state_);
- }
-
- /// For more information, see gvr_controller_state_update().
- void Update(const ControllerApi& api, int32_t flags) {
- gvr_controller_state_update(api.context_, flags, state_);
- }
-
- /// For more information, see gvr_controller_state_get_api_status().
- ControllerApiStatus GetApiStatus() const {
- return static_cast<ControllerApiStatus>(
- gvr_controller_state_get_api_status(state_));
- }
-
- /// For more information, see gvr_controller_state_get_connection_state().
- ControllerConnectionState GetConnectionState() const {
- return static_cast<ControllerConnectionState>(
- gvr_controller_state_get_connection_state(state_));
- }
-
- /// For more information, see gvr_controller_state_get_orientation().
- gvr_quatf GetOrientation() const {
- return gvr_controller_state_get_orientation(state_);
- }
-
- /// For more information, see gvr_controller_state_get_gyro().
- gvr_vec3f GetGyro() const { return gvr_controller_state_get_gyro(state_); }
-
- /// For more information, see gvr_controller_state_get_accel().
- gvr_vec3f GetAccel() const { return gvr_controller_state_get_accel(state_); }
-
- /// For more information, see gvr_controller_state_is_touching().
- bool IsTouching() const { return gvr_controller_state_is_touching(state_); }
-
- /// For more information, see gvr_controller_state_get_touch_pos().
- gvr_vec2f GetTouchPos() const {
- return gvr_controller_state_get_touch_pos(state_);
- }
-
- /// For more information, see gvr_controller_state_get_touch_down().
- bool GetTouchDown() const {
- return gvr_controller_state_get_touch_down(state_);
- }
-
- /// For more information, see gvr_controller_state_get_touch_up().
- bool GetTouchUp() const { return gvr_controller_state_get_touch_up(state_); }
-
- /// For more information, see gvr_controller_state_get_recentered().
- bool GetRecentered() const {
- return gvr_controller_state_get_recentered(state_);
- }
-
- /// For more information, see gvr_controller_state_get_recentering().
- bool GetRecentering() const {
- return gvr_controller_state_get_recentering(state_);
- }
-
- /// For more information, see gvr_controller_state_get_button_state().
- bool GetButtonState(ControllerButton button) const {
- return gvr_controller_state_get_button_state(state_, button);
- }
-
- /// For more information, see gvr_controller_state_get_button_down().
- bool GetButtonDown(ControllerButton button) const {
- return gvr_controller_state_get_button_down(state_, button);
- }
-
- /// For more information, see gvr_controller_state_get_button_up().
- bool GetButtonUp(ControllerButton button) const {
- return gvr_controller_state_get_button_up(state_, button);
- }
-
- /// For more information, see
- /// gvr_controller_state_get_last_orientation_timestamp().
- int64_t GetLastOrientationTimestamp() const {
- return gvr_controller_state_get_last_orientation_timestamp(state_);
- }
-
- /// For more information, see gvr_controller_state_get_last_gyro_timestamp().
- int64_t GetLastGyroTimestamp() const {
- return gvr_controller_state_get_last_gyro_timestamp(state_);
- }
-
- /// For more information, see gvr_controller_state_get_last_accel_timestamp().
- int64_t GetLastAccelTimestamp() const {
- return gvr_controller_state_get_last_accel_timestamp(state_);
- }
-
- /// For more information, see gvr_controller_state_get_last_touch_timestamp().
- int64_t GetLastTouchTimestamp() const {
- return gvr_controller_state_get_last_touch_timestamp(state_);
- }
-
- /// For more information, see
- /// gvr_controller_state_get_last_button_timestamp().
- int64_t GetLastButtonTimestamp() const {
- return gvr_controller_state_get_last_button_timestamp(state_);
- }
-
- /// For more information, see gvr_controller_state_get_position().
- gvr_vec3f GetPosition() const {
- return gvr_controller_state_get_position(state_);
- }
-
- /// For more information, see
- /// gvr_controller_state_get_last_position_timestamp().
- int64_t GetLastPositionTimestamp() const {
- return gvr_controller_state_get_last_position_timestamp(state_);
- }
-
- /// For more information, see gvr_controller_state_get_battery_charging
- bool GetBatteryCharging() const {
- return gvr_controller_state_get_battery_charging(state_);
- }
-
- /// For more information, see gvr_controller_state_get_battery_level
- ControllerBatteryLevel GetBatteryLevel() const {
- return static_cast<ControllerBatteryLevel>(
- gvr_controller_state_get_battery_level(state_));
- }
-
- /// For more information, see gvr_controller_state_get_last_battery_timestamp
- int64_t GetLastBatteryTimestamp() const {
- return gvr_controller_state_get_last_battery_timestamp(state_);
- }
-
- /// @name Wrapper manipulation
- /// @{
- /// Creates a C++ wrapper for a C object and takes ownership.
- explicit ControllerState(gvr_controller_state* state) : state_(state) {}
-
- /// Returns the wrapped C object. Does not affect ownership.
- gvr_controller_state* cobj() { return state_; }
- const gvr_controller_state* cobj() const { return state_; }
-
- /// Returns the wrapped C object and transfers its ownership to the caller.
- /// The wrapper becomes invalid and should not be used.
- gvr_controller_state* release() {
- auto result = state_;
- state_ = nullptr;
- return result;
- }
- /// @}
-
- private:
- gvr_controller_state* state_;
-};
-
-} // namespace gvr
-#endif // #if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-
-#endif // VR_GVR_CAPI_INCLUDE_GVR_CONTROLLER_H_
diff --git a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr_types.h b/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr_types.h
deleted file mode 100644
index cf81b51..0000000
--- a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr_types.h
+++ /dev/null
@@ -1,658 +0,0 @@
-/* Copyright 2016 Google Inc. All rights reserved.
- *
- * 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 VR_GVR_CAPI_INCLUDE_GVR_TYPES_H_
-#define VR_GVR_CAPI_INCLUDE_GVR_TYPES_H_
-
-#include <stdbool.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/// @defgroup types Google VR Types
-/// @brief Various types used in the Google VR NDK.
-/// @{
-
-/// Primary context for invoking Google VR APIs.
-typedef struct gvr_context_ gvr_context;
-
-/// An enum for the left and right eye.
-typedef enum {
- GVR_LEFT_EYE = 0,
- GVR_RIGHT_EYE,
- GVR_NUM_EYES
-} gvr_eye;
-
-/// The type of VR viewer.
-typedef enum {
- /// A Cardboard-compatible viewer. A typical Cardboard viewer supports a
- /// simple touchscreen-based trigger input mechanism. On most platforms, this
- // is the default viewer type if no viewer has been explicitly paired.
- GVR_VIEWER_TYPE_CARDBOARD = 0,
- /// A Daydream-compatible viewer. A typical Daydream viewer supports 3DOF
- /// controller input (as defined in gvr_controller.h), and is intended only
- /// for Daydream-ready platforms. It does *not* support touchscreen-based
- /// input unless Cardboard emulation is explicitly enabled.
- GVR_VIEWER_TYPE_DAYDREAM = 1,
-} gvr_viewer_type;
-
-// Types of VR-specific features which may or may not be supported on the
-// underlying platform.
-typedef enum {
- // Asynchronous reprojection warps the app's rendered frame using the most
- // recent head pose just before pushing the frame to the display.
- GVR_FEATURE_ASYNC_REPROJECTION = 0,
-} gvr_feature;
-
-/// @}
-
-/// Version information for the Google VR API.
-typedef struct gvr_version_ {
- int32_t major;
- int32_t minor;
- int32_t patch;
-} gvr_version;
-
-/// An integral 2D size. Used for render target sizes.
-typedef struct gvr_sizei {
- int32_t width;
- int32_t height;
-} gvr_sizei;
-
-/// An integral 2D rect. Used for window bounds in pixels.
-typedef struct gvr_recti {
- int32_t left;
- int32_t right;
- int32_t bottom;
- int32_t top;
-} gvr_recti;
-
-/// A floating point 2D rect. Used for field of view, and also for ranges
-/// in texture space. When used for a field of view, all angles are in positive
-/// degrees from the optical axis.
-typedef struct gvr_rectf {
- float left;
- float right;
- float bottom;
- float top;
-} gvr_rectf;
-
-/// A floating point 2D vector.
-typedef struct gvr_vec2f {
- float x;
- float y;
-} gvr_vec2f;
-
-/// A floating point 3D vector.
-typedef struct gvr_vec3f {
- float x;
- float y;
- float z;
-} gvr_vec3f;
-
-/// A floating point 4x4 matrix.
-typedef struct gvr_mat4f { float m[4][4]; } gvr_mat4f;
-
-/// A floating point quaternion, in JPL format.
-/// We use this simple struct in order not to impose a dependency on a
-/// particular math library. The user of this API is free to encapsulate this
-/// into any math library they want.
-typedef struct gvr_quatf {
- /// qx, qy, qz are the vector component.
- float qx;
- float qy;
- float qz;
- /// qw is the linelar component.
- float qw;
-} gvr_quatf;
-
-/// A *monotonic system time* representation. On Android, this is equivalent to
-/// System.nanoTime(), or clock_gettime(CLOCK_MONOTONIC). If there is any doubt
-/// about how to get the current time for the current platform, simply use
-/// gvr_get_time_point_now().
-typedef struct gvr_clock_time_point {
- int64_t monotonic_system_time_nanos;
-} gvr_clock_time_point;
-
-/// A structure that ties together a region of a buffer, the field of view
-/// rendered into that region and a target eye index to define part of the
-/// user's field of view. The SDK implementation uses this information to
-/// transform the images generated by the app output into the final display that
-/// is sent to the screen.
-///
-/// A set of these structures will most often be generated by the API, via
-/// gvr_get_recommended_buffer_viewports() or
-/// gvr_get_screen_buffer_viewports(). However, the client may also customize
-/// these values via gvr_buffer_viewport_list_set(), constructing a custom
-/// gvr_buffer_viewport_list for use in the distortion pass.
-typedef struct gvr_buffer_viewport_ gvr_buffer_viewport;
-
-/// List of buffer viewports that completely specifies how to transform the
-/// frame's buffers into the image displayed on the screen.
-typedef struct gvr_buffer_viewport_list_ gvr_buffer_viewport_list;
-
-/// Specification of a pixel buffer. A pixel buffer can have color, depth and
-/// stencil attachments and mostly corresponds to the OpenGL concept of a
-/// framebuffer object. However, since there can be multiple such objects for
-/// each frame, we avoid calling them "framebuffers". Pixel buffers which are
-/// part of the currently acquired frame are immutable, i.e., they cannot be
-/// resized or otherwise reconfigured.
-typedef struct gvr_buffer_spec_ gvr_buffer_spec;
-
-/// Swap chain that contains some number of frames. Frames in the swap chain
-/// can be unused, in the process of being distorted and presented on the
-/// screen, or acquired and being rendered to by the application. The swap chain
-/// ensures that the most recent available frame is always shown and that the
-/// application never has to wait to render the next frame.
-typedef struct gvr_swap_chain_ gvr_swap_chain;
-
-/// A single frame acquired from the swap chain. Each frame is composed of one
-/// or more buffers, which are then lens distorted and composited into the final
-/// output. Buffers are identified by indices that correspond to the position
-/// of their gvr_buffer_spec in the list passed when constructing the swap
-/// chain.
-typedef struct gvr_frame_ gvr_frame;
-
-/// @addtogroup types
-/// @{
-
-/// Constants that represent GVR error codes.
-typedef enum {
- GVR_ERROR_NONE = 0,
- GVR_ERROR_CONTROLLER_CREATE_FAILED = 2,
- GVR_ERROR_NO_FRAME_AVAILABLE = 3,
-} gvr_error;
-
-/// Controller API options (bit flags).
-enum {
- /// Indicates that controller orientation data should be reported.
- GVR_CONTROLLER_ENABLE_ORIENTATION = 1 << 0,
- /// Indicates that controller touchpad data should be reported.
- GVR_CONTROLLER_ENABLE_TOUCH = 1 << 1,
- /// Indicates that controller gyroscope data should be reported.
- GVR_CONTROLLER_ENABLE_GYRO = 1 << 2,
- /// Indicates that controller accelerometer data should be reported.
- GVR_CONTROLLER_ENABLE_ACCEL = 1 << 3,
- /// Indicates that controller gestures should be reported.
- GVR_CONTROLLER_ENABLE_GESTURES = 1 << 4,
- /// Indicates that controller pose prediction should be enabled.
- GVR_CONTROLLER_ENABLE_POSE_PREDICTION = 1 << 5,
- /// Indicates that controller position data should be reported.
- GVR_CONTROLLER_ENABLE_POSITION = 1 << 6,
- /// Indicates that controller battery data should be reported.
- GVR_CONTROLLER_ENABLE_BATTERY = 1 << 7,
-};
-
-/// Constants that represent the status of the controller API.
-typedef enum {
- /// API is happy and healthy. This doesn't mean the controller itself
- /// is connected, it just means that the underlying service is working
- /// properly.
- GVR_CONTROLLER_API_OK = 0,
-
- /// Any other status represents a permanent failure that requires
- /// external action to fix:
-
- /// API failed because this device does not support controllers (API is too
- /// low, or other required feature not present).
- GVR_CONTROLLER_API_UNSUPPORTED = 1,
- /// This app was not authorized to use the service (e.g., missing permissions,
- /// the app is blacklisted by the underlying service, etc).
- GVR_CONTROLLER_API_NOT_AUTHORIZED = 2,
- /// The underlying VR service is not present.
- GVR_CONTROLLER_API_UNAVAILABLE = 3,
- /// The underlying VR service is too old, needs upgrade.
- GVR_CONTROLLER_API_SERVICE_OBSOLETE = 4,
- /// The underlying VR service is too new, is incompatible with current client.
- GVR_CONTROLLER_API_CLIENT_OBSOLETE = 5,
- /// The underlying VR service is malfunctioning. Try again later.
- GVR_CONTROLLER_API_MALFUNCTION = 6,
-} gvr_controller_api_status;
-
-/// Constants that represent the state of the controller.
-typedef enum {
- /// Controller is disconnected.
- GVR_CONTROLLER_DISCONNECTED = 0,
- /// Controller is scanning.
- GVR_CONTROLLER_SCANNING = 1,
- /// Controller is connecting.
- GVR_CONTROLLER_CONNECTING = 2,
- /// Controller is connected.
- GVR_CONTROLLER_CONNECTED = 3,
-} gvr_controller_connection_state;
-
-/// Controller buttons.
-typedef enum {
- GVR_CONTROLLER_BUTTON_NONE = 0,
- GVR_CONTROLLER_BUTTON_CLICK = 1, ///< Touchpad Click.
- GVR_CONTROLLER_BUTTON_HOME = 2,
- GVR_CONTROLLER_BUTTON_APP = 3,
- GVR_CONTROLLER_BUTTON_VOLUME_UP = 4,
- GVR_CONTROLLER_BUTTON_VOLUME_DOWN = 5,
-
- /// Note: there are 5 buttons on the controller, but the state arrays have
- /// this many elements due to the inclusion of a dummy "none" button.
- GVR_CONTROLLER_BUTTON_COUNT = 6,
-} gvr_controller_button;
-
-/// Controller battery states.
-typedef enum {
- GVR_CONTROLLER_BATTERY_LEVEL_UNKNOWN = 0,
- GVR_CONTROLLER_BATTERY_LEVEL_CRITICAL_LOW = 1,
- GVR_CONTROLLER_BATTERY_LEVEL_LOW = 2,
- GVR_CONTROLLER_BATTERY_LEVEL_MEDIUM = 3,
- GVR_CONTROLLER_BATTERY_LEVEL_ALMOST_FULL = 4,
- GVR_CONTROLLER_BATTERY_LEVEL_FULL = 5,
-
- /// Note: there are 5 distinct levels, but there are 6 due to the inclusion
- /// of an UNKNOWN state before any battery information is collected, etc.
- GVR_CONTROLLER_BATTERY_LEVEL_COUNT = 6,
-} gvr_controller_battery_level;
-
-
-/// @}
-
-/// Opaque handle to controller state.
-typedef struct gvr_controller_state_ gvr_controller_state;
-
-/// @addtogroup types
-/// @{
-
-/// Rendering modes define CPU load / rendering quality balances.
-typedef enum {
- /// Stereo panning of all Sound Objects. This disables HRTF-based rendering.
- GVR_AUDIO_RENDERING_STEREO_PANNING = 0,
- /// HRTF-based rendering over a virtual array of 8 loudspeakers arranged in
- /// a cube configuration around the listener’s head.
- GVR_AUDIO_RENDERING_BINAURAL_LOW_QUALITY = 1,
- /// HRTF-based rendering over a virtual array of 16 loudspeakers arranged in
- /// an approximate equidistribution about the around the listener’s head.
- GVR_AUDIO_RENDERING_BINAURAL_HIGH_QUALITY = 2,
-} gvr_audio_rendering_mode;
-
-/// Room surface material names, used to set room properties.
-typedef enum {
- /// Acoustically transparent material, reflects no sound.
- GVR_AUDIO_MATERIAL_TRANSPARENT = 0,
- /// Acoustic ceiling tiles, absorbs most frequencies.
- GVR_AUDIO_MATERIAL_ACOUSTIC_CEILING_TILES = 1,
- /// Bare brick, relatively reflective.
- GVR_AUDIO_MATERIAL_BRICK_BARE = 2,
- /// Painted brick
- GVR_AUDIO_MATERIAL_BRICK_PAINTED = 3,
- /// Coarse surface concrete block.
- GVR_AUDIO_MATERIAL_CONCRETE_BLOCK_COARSE = 4,
- /// Painted concrete block.
- GVR_AUDIO_MATERIAL_CONCRETE_BLOCK_PAINTED = 5,
- /// Heavy curtains.
- GVR_AUDIO_MATERIAL_CURTAIN_HEAVY = 6,
- /// Fiber glass insulation.
- GVR_AUDIO_MATERIAL_FIBER_GLASS_INSULATION = 7,
- /// Thin glass.
- GVR_AUDIO_MATERIAL_GLASS_THIN = 8,
- /// Thick glass.
- GVR_AUDIO_MATERIAL_GLASS_THICK = 9,
- /// Grass.
- GVR_AUDIO_MATERIAL_GRASS = 10,
- /// Linoleum on concrete.
- GVR_AUDIO_MATERIAL_LINOLEUM_ON_CONCRETE = 11,
- /// Marble.
- GVR_AUDIO_MATERIAL_MARBLE = 12,
- /// Galvanized sheet metal.
- GVR_AUDIO_MATERIAL_METAL = 13,
- /// Wooden parquet on concrete.
- GVR_AUDIO_MATERIAL_PARQUET_ON_CONCRETE = 14,
- /// Rough plaster surface.
- GVR_AUDIO_MATERIAL_PLASTER_ROUGH = 15,
- /// Smooth plaster surface.
- GVR_AUDIO_MATERIAL_PLASTER_SMOOTH = 16,
- /// Plywood panel.
- GVR_AUDIO_MATERIAL_PLYWOOD_PANEL = 17,
- /// Polished concrete OR tile surface.
- GVR_AUDIO_MATERIAL_POLISHED_CONCRETE_OR_TILE = 18,
- /// Sheet rock.
- GVR_AUDIO_MATERIAL_SHEET_ROCK = 19,
- /// Surface of water or ice.
- GVR_AUDIO_MATERIAL_WATER_OR_ICE_SURFACE = 20,
- /// Wooden ceiling.
- GVR_AUDIO_MATERIAL_WOOD_CEILING = 21,
- /// Wood paneling.
- GVR_AUDIO_MATERIAL_WOOD_PANEL = 22,
-} gvr_audio_material_type;
-
-/// Distance rolloff models used for distance attenuation.
-typedef enum {
- /// Logarithmic distance rolloff model.
- GVR_AUDIO_ROLLOFF_LOGARITHMIC = 0,
- /// Linear distance rolloff model.
- GVR_AUDIO_ROLLOFF_LINEAR = 1,
- /// No distance attenuation will be applied.
- GVR_AUDIO_ROLLOFF_NONE = 2,
-} gvr_audio_distance_rolloff_type;
-
-/// Sound object and sound field identifier.
-typedef int32_t gvr_audio_source_id;
-
-/// Supported surround sound formats.
-typedef enum {
- // Enables to initialize a yet undefined rendering mode.
- GVR_AUDIO_SURROUND_FORMAT_INVALID = 0,
-
- // Virtual stereo speakers at -30 degrees and +30 degrees.
- GVR_AUDIO_SURROUND_FORMAT_SURROUND_STEREO = 1,
-
- // 5.1 surround sound according to the ITU-R BS 775 speaker configuration
- // recommendation:
- // - Front left (FL) at 30 degrees.
- // - Front right (FR) at -30 degrees.
- // - Front center (FC) at 0 degrees.
- // - Low frequency effects (LFE) at front center at 0 degrees.
- // - Left side (LS) at 110 degrees.
- // - Right side (RS) at -110 degrees.
- //
- // The 5.1 channel input layout must matches AAC: FL, FR, FC, LFE, LS, RS.
- // Note that this differs from the Vorbis/Opus 5.1 channel layout, which
- // is: FL, FC, FR, LS, RS, LFE.
- GVR_AUDIO_SURROUND_FORMAT_SURROUND_FIVE_DOT_ONE = 2,
-
- // First-order ambisonics (AmbiX format: 4 channels, ACN channel ordering,
- // SN3D normalization).
- GVR_AUDIO_SURROUND_FORMAT_FIRST_ORDER_AMBISONICS = 3,
-
- // Second-order ambisonics (AmbiX format: 9 channels, ACN channel ordering,
- // SN3D normalization).
- GVR_AUDIO_SURROUND_FORMAT_SECOND_ORDER_AMBISONICS = 4,
-
- // Third-order ambisonics (AmbiX format: 16 channels, ACN channel ordering,
- // SN3D normalization).
- GVR_AUDIO_SURROUND_FORMAT_THIRD_ORDER_AMBISONICS = 5,
-} gvr_audio_surround_format_type;
-
-/// Valid color formats for swap chain buffers.
-typedef enum {
- /// Equivalent to GL_RGBA8
- GVR_COLOR_FORMAT_RGBA_8888 = 0,
- /// Equivalent to GL_RGB565
- GVR_COLOR_FORMAT_RGB_565 = 1,
-} gvr_color_format_type;
-
-typedef enum {
- /// No depth or stencil buffer.
- GVR_DEPTH_STENCIL_FORMAT_NONE = 255,
- /// Equivalent to GL_DEPTH_COMPONENT16.
- GVR_DEPTH_STENCIL_FORMAT_DEPTH_16 = 0,
- /// Equivalent to GL_DEPTH_COMPONENT24.
- GVR_DEPTH_STENCIL_FORMAT_DEPTH_24 = 1,
- /// Equivlaent to GL_DEPTH24_STENCIL8.
- GVR_DEPTH_STENCIL_FORMAT_DEPTH_24_STENCIL_8 = 2,
- /// Equivalent to GL_DEPTH_COMPONENT32F.
- GVR_DEPTH_STENCIL_FORMAT_DEPTH_32_F = 3,
- /// Equivalent to GL_DEPTH_32F_STENCIL8.
- GVR_DEPTH_STENCIL_FORMAT_DEPTH_32_F_STENCIL_8 = 4,
- /// Equivalent to GL_STENCIL8.
- GVR_DEPTH_STENCIL_FORMAT_STENCIL_8 = 5,
-} gvr_depth_stencil_format_type;
-
-/// Types of asynchronous reprojection.
-typedef enum {
- /// Do not reproject.
- GVR_REPROJECTION_NONE = 0,
- /// Reproject in all dimensions.
- GVR_REPROJECTION_FULL = 1,
-} gvr_reprojection;
-
-typedef enum {
- GVR_CONTROLLER_RIGHT_HANDED = 0,
- GVR_CONTROLLER_LEFT_HANDED = 1,
-} gvr_controller_handedness;
-
-typedef struct gvr_user_prefs_ gvr_user_prefs;
-
-// Anonymous enum for miscellaneous integer constants.
-enum {
- /// Constant that represents a nonexistent external surface. Pass to
- /// gvr_buffer_viewport_set_external_surface_id() to disable sampling from
- /// an external surface.
- GVR_EXTERNAL_SURFACE_ID_NONE = -1,
- /// Special index for a source buffer that has the same contents as the
- /// external surface attached to the given viewport. Pass this to
- /// gvr_buffer_viewport_set_source_buffer_index() to use the external surface
- /// as the buffer contents.
- GVR_BUFFER_INDEX_EXTERNAL_SURFACE = -1,
-};
-
-/// @}
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-// These typedefs convert the C-style names to C++-style names.
-
-namespace gvr {
-
-const int32_t kControllerEnableOrientation =
- static_cast<int32_t>(GVR_CONTROLLER_ENABLE_ORIENTATION);
-const int32_t kControllerEnableTouch =
- static_cast<int32_t>(GVR_CONTROLLER_ENABLE_TOUCH);
-const int32_t kControllerEnableGyro =
- static_cast<int32_t>(GVR_CONTROLLER_ENABLE_GYRO);
-const int32_t kControllerEnableAccel =
- static_cast<int32_t>(GVR_CONTROLLER_ENABLE_ACCEL);
-const int32_t kControllerEnableGestures =
- static_cast<int32_t>(GVR_CONTROLLER_ENABLE_GESTURES);
-const int32_t kControllerEnablePosePrediction =
- static_cast<int32_t>(GVR_CONTROLLER_ENABLE_POSE_PREDICTION);
-const int32_t kControllerEnablePosition =
- static_cast<int32_t>(GVR_CONTROLLER_ENABLE_POSITION);
-const int32_t kControllerEnableBattery =
- static_cast<int32_t>(GVR_CONTROLLER_ENABLE_BATTERY);
-
-typedef gvr_controller_api_status ControllerApiStatus;
-const ControllerApiStatus kControllerApiOk =
- static_cast<ControllerApiStatus>(GVR_CONTROLLER_API_OK);
-const ControllerApiStatus kControllerApiUnsupported =
- static_cast<ControllerApiStatus>(GVR_CONTROLLER_API_UNSUPPORTED);
-const ControllerApiStatus kControllerApiNotAuthorized =
- static_cast<ControllerApiStatus>(GVR_CONTROLLER_API_NOT_AUTHORIZED);
-const ControllerApiStatus kControllerApiUnavailable =
- static_cast<ControllerApiStatus>(GVR_CONTROLLER_API_UNAVAILABLE);
-const ControllerApiStatus kControllerApiServiceObsolete =
- static_cast<ControllerApiStatus>(GVR_CONTROLLER_API_SERVICE_OBSOLETE);
-const ControllerApiStatus kControllerApiClientObsolete =
- static_cast<ControllerApiStatus>(GVR_CONTROLLER_API_CLIENT_OBSOLETE);
-const ControllerApiStatus kControllerApiMalfunction =
- static_cast<ControllerApiStatus>(GVR_CONTROLLER_API_MALFUNCTION);
-
-typedef gvr_controller_connection_state ControllerConnectionState;
-const ControllerConnectionState kControllerDisconnected =
- static_cast<ControllerConnectionState>(GVR_CONTROLLER_DISCONNECTED);
-const ControllerConnectionState kControllerScanning =
- static_cast<ControllerConnectionState>(GVR_CONTROLLER_SCANNING);
-const ControllerConnectionState kControllerConnecting =
- static_cast<ControllerConnectionState>(GVR_CONTROLLER_CONNECTING);
-const ControllerConnectionState kControllerConnected =
- static_cast<ControllerConnectionState>(GVR_CONTROLLER_CONNECTED);
-
-typedef gvr_controller_button ControllerButton;
-const ControllerButton kControllerButtonNone =
- static_cast<ControllerButton>(GVR_CONTROLLER_BUTTON_NONE);
-const ControllerButton kControllerButtonClick =
- static_cast<ControllerButton>(GVR_CONTROLLER_BUTTON_CLICK);
-const ControllerButton kControllerButtonHome =
- static_cast<ControllerButton>(GVR_CONTROLLER_BUTTON_HOME);
-const ControllerButton kControllerButtonApp =
- static_cast<ControllerButton>(GVR_CONTROLLER_BUTTON_APP);
-const ControllerButton kControllerButtonVolumeUp =
- static_cast<ControllerButton>(GVR_CONTROLLER_BUTTON_VOLUME_UP);
-const ControllerButton kControllerButtonVolumeDown =
- static_cast<ControllerButton>(GVR_CONTROLLER_BUTTON_VOLUME_DOWN);
-const ControllerButton kControllerButtonCount =
- static_cast<ControllerButton>(GVR_CONTROLLER_BUTTON_COUNT);
-
-typedef gvr_controller_battery_level ControllerBatteryLevel;
-const ControllerBatteryLevel kControllerBatteryLevelUnknown =
- static_cast<ControllerBatteryLevel>(
- GVR_CONTROLLER_BATTERY_LEVEL_UNKNOWN);
-const ControllerBatteryLevel kControllerBatteryLevelCriticalLow =
- static_cast<ControllerBatteryLevel>(
- GVR_CONTROLLER_BATTERY_LEVEL_CRITICAL_LOW);
-const ControllerBatteryLevel kControllerBatteryLevelLow =
- static_cast<ControllerBatteryLevel>(
- GVR_CONTROLLER_BATTERY_LEVEL_LOW);
-const ControllerBatteryLevel kControllerBatteryLevelMedium =
- static_cast<ControllerBatteryLevel>(
- GVR_CONTROLLER_BATTERY_LEVEL_MEDIUM);
-const ControllerBatteryLevel kControllerBatteryLevelAlmostFull =
- static_cast<ControllerBatteryLevel>(
- GVR_CONTROLLER_BATTERY_LEVEL_ALMOST_FULL);
-const ControllerBatteryLevel kControllerBatteryLevelFull =
- static_cast<ControllerBatteryLevel>(
- GVR_CONTROLLER_BATTERY_LEVEL_FULL);
-
-/// An uninitialized external surface ID.
-const int32_t kUninitializedExternalSurface = GVR_BUFFER_INDEX_EXTERNAL_SURFACE;
-/// The default source buffer index for viewports.
-const int32_t kDefaultBufferIndex = 0;
-
-typedef gvr_eye Eye;
-
-typedef gvr_viewer_type ViewerType;
-const ViewerType kViewerTypeCardboard =
- static_cast<ViewerType>(GVR_VIEWER_TYPE_CARDBOARD);
-const ViewerType kViewerTypeDaydream =
- static_cast<ViewerType>(GVR_VIEWER_TYPE_DAYDREAM);
-
-typedef gvr_version Version;
-typedef gvr_sizei Sizei;
-typedef gvr_recti Recti;
-typedef gvr_rectf Rectf;
-typedef gvr_vec2f Vec2f;
-typedef gvr_vec3f Vec3f;
-typedef gvr_mat4f Mat4f;
-typedef gvr_quatf Quatf;
-typedef gvr_clock_time_point ClockTimePoint;
-
-typedef gvr_vec2f ControllerVec2;
-typedef gvr_vec3f ControllerVec3;
-typedef gvr_quatf ControllerQuat;
-
-typedef gvr_audio_rendering_mode AudioRenderingMode;
-typedef gvr_audio_material_type AudioMaterialName;
-typedef gvr_audio_distance_rolloff_type AudioRolloffMethod;
-typedef gvr_audio_source_id AudioSourceId;
-typedef gvr_audio_surround_format_type AudioSurroundFormat;
-
-typedef gvr_color_format_type ColorFormat;
-const ColorFormat kColorFormatRgba8888 =
- static_cast<ColorFormat>(GVR_COLOR_FORMAT_RGBA_8888);
-const ColorFormat kColorFormatRgb565 =
- static_cast<ColorFormat>(GVR_COLOR_FORMAT_RGB_565);
-
-typedef gvr_depth_stencil_format_type DepthStencilFormat;
-const DepthStencilFormat kDepthStencilFormatNone =
- static_cast<DepthStencilFormat>(GVR_DEPTH_STENCIL_FORMAT_NONE);
-const DepthStencilFormat kDepthStencilFormatDepth16 =
- static_cast<DepthStencilFormat>(GVR_DEPTH_STENCIL_FORMAT_DEPTH_16);
-const DepthStencilFormat kDepthStencilFormatDepth24 =
- static_cast<DepthStencilFormat>(GVR_DEPTH_STENCIL_FORMAT_DEPTH_24);
-const DepthStencilFormat kDepthStencilFormatDepth24Stencil8 =
- static_cast<DepthStencilFormat>(
- GVR_DEPTH_STENCIL_FORMAT_DEPTH_24_STENCIL_8);
-const DepthStencilFormat kDepthStencilFormatDepth32f =
- static_cast<DepthStencilFormat>(GVR_DEPTH_STENCIL_FORMAT_DEPTH_32_F);
-const DepthStencilFormat kDepthStencilFormatDepth32fStencil8 =
- static_cast<DepthStencilFormat>(
- GVR_DEPTH_STENCIL_FORMAT_DEPTH_32_F_STENCIL_8);
-const DepthStencilFormat kDepthStencilFormatStencil8 =
- static_cast<DepthStencilFormat>(GVR_DEPTH_STENCIL_FORMAT_STENCIL_8);
-
-typedef gvr_controller_handedness ControllerHandedness;
-const ControllerHandedness kControllerRightHanded =
- static_cast<ControllerHandedness>(GVR_CONTROLLER_RIGHT_HANDED);
-const ControllerHandedness kControllerLeftHanded =
- static_cast<ControllerHandedness>(GVR_CONTROLLER_LEFT_HANDED);
-
-typedef gvr_error Error;
-const Error kErrorNone = static_cast<Error>(GVR_ERROR_NONE);
-const Error kErrorControllerCreateFailed =
- static_cast<Error>(GVR_ERROR_CONTROLLER_CREATE_FAILED);
-const Error kErrorNoFrameAvailable =
- static_cast<Error>(GVR_ERROR_NO_FRAME_AVAILABLE);
-
-class AudioApi;
-class BufferSpec;
-class ControllerApi;
-class ControllerState;
-class Frame;
-class GvrApi;
-class BufferViewport;
-class BufferViewportList;
-class SwapChain;
-class UserPrefs;
-
-} // namespace gvr
-
-// Non-member equality operators for convenience. Since typedefs do not trigger
-// argument-dependent lookup, these operators have to be defined for the
-// underlying types.
-inline bool operator==(const gvr_vec2f& lhs, const gvr_vec2f& rhs) {
- return lhs.x == rhs.x && lhs.y == rhs.y;
-}
-
-inline bool operator!=(const gvr_vec2f& lhs, const gvr_vec2f& rhs) {
- return !(lhs == rhs);
-}
-
-inline bool operator==(const gvr_vec3f& lhs, const gvr_vec3f& rhs) {
- return lhs.x == rhs.x && lhs.y == rhs.y;
-}
-
-inline bool operator!=(const gvr_vec3f& lhs, const gvr_vec3f& rhs) {
- return !(lhs == rhs);
-}
-
-inline bool operator==(const gvr_recti& lhs, const gvr_recti& rhs) {
- return lhs.left == rhs.left && lhs.right == rhs.right &&
- lhs.bottom == rhs.bottom && lhs.top == rhs.top;
-}
-
-inline bool operator!=(const gvr_recti& lhs, const gvr_recti& rhs) {
- return !(lhs == rhs);
-}
-
-inline bool operator==(const gvr_rectf& lhs, const gvr_rectf& rhs) {
- return lhs.left == rhs.left && lhs.right == rhs.right &&
- lhs.bottom == rhs.bottom && lhs.top == rhs.top;
-}
-
-inline bool operator!=(const gvr_rectf& lhs, const gvr_rectf& rhs) {
- return !(lhs == rhs);
-}
-
-inline bool operator==(const gvr_sizei& lhs, const gvr_sizei& rhs) {
- return lhs.width == rhs.width && lhs.height == rhs.height;
-}
-
-inline bool operator!=(const gvr_sizei& lhs, const gvr_sizei& rhs) {
- return !(lhs == rhs);
-}
-
-#endif // #if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-
-#endif // VR_GVR_CAPI_INCLUDE_GVR_TYPES_H_
diff --git a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/src/gvr_experimental.h b/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/src/gvr_experimental.h
deleted file mode 100644
index 5bd6174..0000000
--- a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/src/gvr_experimental.h
+++ /dev/null
@@ -1,231 +0,0 @@
-#ifndef VR_GVR_CAPI_SRC_GVR_EXPERIMENTAL_H_
-#define VR_GVR_CAPI_SRC_GVR_EXPERIMENTAL_H_
-
-#include <stdbool.h>
-#include <stdint.h>
-
-#include "vr/gvr/capi/include/gvr_types.h"
-#include "vr/gvr/capi/src/gvr_types_experimental.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// NOTE: APIs added to this file are *not* part of the core GVR library, and
-// should only be used for prototyping or experimental projects. The idea is
-// that APIs added here can be used for testing and development, graduating to
-// the core API (gvr.h or gvr_private.h) after we're ready to commit to them
-// indefinitely.
-
-// ************************************************************************** //
-// * DaydreamOS experimental APIs * //
-// ************************************************************************** //
-
-/// Gets the position and rotation from start space to head space. The head
-/// space is a space where the head is at the origin and faces the -Z direction.
-///
-/// @param gvr Pointer to the gvr instance from which to get the pose.
-/// @param time The time at which to get the head pose. The time should be in
-/// the future. If the time is not in the future, it will be clamped to now.
-/// @return A matrix representation of the position and rotation from start
-// space (the space where the head was last reset) to head space (the space
-/// with the head at the origin, and the axes aligned to the view vector).
-gvr_mat4f gvr_get_head_space_from_start_space_pose(
- gvr_context* gvr, const gvr_clock_time_point time);
-
-/// Sets the compositor z-order of the swap chain.
-///
-/// @param swap_chain the swap chain to change.
-/// @param z_order Z order, higher values are displayed on top of lower ones,
-/// the default value is 0.
-void gvr_swap_chain_set_z_order(const gvr_swap_chain* swap_chain, int z_order);
-
-/// Creates a gvr_external_surface instance.
-/// An external surface is mainly used to pass external content (such as video
-/// frames, pre-rendered 2D Android UI) into distortion pass for compositing.
-/// The method gvr_external_surface_get_surface can be used to bridge Android
-/// components with GVR distortion pass via a traditional Android Surface
-/// instance.
-///
-/// @param gvr Pointer to the gvr instance from which to create the external
-/// surface.
-/// @return Pointer to an allocated gvr_external_surface object. The caller
-// is responsible for calling gvr_external_surface_destroy() on the
-/// returned object when it is no longer needed.
-gvr_external_surface* gvr_external_surface_create(gvr_context* gvr);
-
-/// Frees a gvr_external_surface instance and clears the pointer.
-/// Note that once a gvr_external_surface is destroyed, the Java Surface object
-/// returned from gvr_external_surface_get_surface remains to be accessible and
-/// functioning. It's up to Java's garbage collection to release all resources
-/// behind the Java Surface object.
-///
-/// @param surface Pointer to a pointer to the gvr_external_surface instance to
-/// be destroyed and nulled.
-void gvr_external_surface_destroy(gvr_external_surface** surface);
-
-/// Get an Android Surface as a Java object from the gvr_external_surface. This
-/// API is mainly used by standalone display service (aka when
-/// gvr_using_vr_display_service returns true) to access an Android Surface.
-///
-/// @param surface The gvr_external_surface associated with the Android Surface.
-/// Note that this API has to be called within a JNIEnv and is using the
-/// JNIEnv passed in during gvr_create.
-/// @return A jobject that is an instance of the 'android/view/Surface' Java
-/// class, NULL on failure. Note that the return value is really an opaque
-/// handle to a Java object and the life cycle of that object is maintained
-/// by Java (i.e. it will get garbage collected eventually). Thus, there is
-/// no need for an explicit destroy call.
-void* gvr_external_surface_get_surface(const gvr_external_surface* surface);
-
-/// Get the Surface ID associated with the gvr_external_surface. Note that the
-/// returned ID is used for internal bookkeeping only and should not be used
-/// by the app itself for lookups.
-/// @param surface The gvr_external_surface to query the ID for.
-/// @return The external surface ID associated with the gvr_external_surface.
-int32_t gvr_external_surface_get_surface_id(
- const gvr_external_surface* surface);
-
-/// Sets the z order of the layer to be created.
-/// Note that this API is a short-term workaround for SysUI work and is never
-/// meant to graduate as is to either gvr.h or gvr_private.h. The proper
-/// solution is tracked in b/33946428 and probably involves setting the
-/// attribute on some data structure that represents a layer.
-///
-/// @param spec Buffer specification.
-/// @param z_order Z order, higher values are displayed on top of lower ones,
-/// the default value is 0.
-void gvr_buffer_spec_set_z_order(gvr_buffer_spec* spec, int z_order);
-
-/// Sets the initial visibility of the layer to be created.
-/// Note that this API is a short-term workaround for SysUI work and is never
-/// meant to graduate as is to either gvr.h or gvr_private.h. The proper
-/// solution is tracked in b/33946428 and probably involves setting the
-/// attribute on some data structure that represents a layer.
-///
-/// @param spec Buffer specification.
-/// @param visibility Initial visibility of the layer, defaults to GVR_VISIBLE.
-/// See enum gvr_visibility for possible values.
-void gvr_buffer_spec_set_visibility(gvr_buffer_spec* spec,
- int32_t visibility);
-
-/// Sets whether to blur layers below the layer to be created.
-/// Blurring is applied only to visible layers and only when the layer is
-/// visible.
-/// Note that this API currently is only implemented by the DreamOS
-/// implementation of GVR and is a no-op in other implementations.
-/// TODO(b/33946428): investigate the proper way to surface this feature
-/// to SysUI.
-///
-/// @param spec Buffer specification.
-/// @param blur_behind whether to blur layers behind, defaults to
-/// GVR_BLUR_BEHIND_TRUE. See enum gvr_blur_behind for possible values.
-void gvr_buffer_spec_set_blur_behind(gvr_buffer_spec* spec,
- int32_t blur_behind);
-
-// ************************************************************************** //
-// * Daydream PlexEng experimental APIs * //
-// ************************************************************************** //
-
-// Registers a new performance event listener that will be invoked on points
-// of interest. By default no event listener is attached. If multiple event
-// listeners are attached they will all be invoked. Failures can be checked
-// with gvr_get_error().
-// @param out_handle The pointer to memory where a successfully created handle
-// will be written.
-// @param gvr The context to register callbacks for.
-// @param user_data The pointer that will be passed back on callbacks for
-// user_data.
-// @param event_callback The callback to be invoked when an event is observed.
-// On performance events callback will be invoked with the
-// user_data passed here, the gvr_perf_event_callback_type, and a float
-// value (if applicable) or -1.f.
-// @return Returns GVR_EXPERIMENTAL_ERROR_NONE if a handle was created,
-// GVR_EXPERIMENTAL_ERROR_UNIMPLEMENTED if this feature is disabled,
-// or GVR_EXPERIMENTAL_ERROR_INVALID_ARGUMENT if a null pointer was passed.
-bool gvr_experimental_register_perf_event_callback(
- gvr_context* gvr, int* out_handle, void* user_data,
- void (*event_callback)(void*, int, float));
-
-// Unregisters a previously registered callback by its handle. Failures can be
-// checked with gvr_get_error().
-// @param handle The handle which was returned when registering the callback.
-// @return Returns GVR_EXPERIMENTAL_ERROR_NONE if callback was unregistered,
-// GVR_EXPERIMENTAL_ERROR_INVALID_ARGUMENT if the if the handle wasn't
-// previously
-// registered. If this feature is not enabled it will return
-// GVR_EXPERIMENTAL_ERROR_UNIMPLEMENTED.
-bool gvr_experimental_unregister_perf_event_callback(gvr_context* gvr,
- int handle);
-
-// ************************************************************************** //
-// * GVR Analytics experimental APIs * //
-// ************************************************************************** //
-// TODO(b/31634289): These functions are experimental because their main client
-// case is the performance monitoring HUD, whose form and function is still
-// under development. Consequently, the analytics API may change as the HUD's
-// needs become clearer.
-//
-// These functions will be moved into the main API (probably gvr_private.h) once
-// the HUD is ready to be shipped as part of the SDK.
-//
-// Contacts: georgelu@
-
-/// Returns whether the "Performance Monitoring" developer option is enabled.
-///
-/// @param user_prefs Pointer to the gvr_user_prefs object returned by
-/// gvr_get_user_prefs.
-/// @return True if the "Performance Monitoring" developer option is enabled.
-bool gvr_user_prefs_get_performance_monitoring_enabled(
- const gvr_user_prefs* user_prefs);
-
-// Opaque struct returned by gvr_get_analytics that can be queried through
-// gvr_analytics_get* functions.
-//
-// Note: The struct is never actually defined since gvr_analytics is actually
-// just a static_cast of a gvr_context, similar to how gvr_user_prefs works.
-typedef struct gvr_analytics_ gvr_analytics;
-
-// Returns an opaque struct that can be queried for analytics data. The returned
-// struct remains valid as long as the context is valid.
-//
-// @param gvr Pointer to the current gvr_context instance.
-// @return An opaque struct that can be queried through gvr_analytics_*
-// functions.
-const gvr_analytics* gvr_get_analytics(gvr_context* gvr);
-
-// If the "Performance Monitoring" developer option in VR settings is enabled,
-// returns a gvr_analytics_sample* containing analytics data. Caller is
-// responsible for calling gvr_analytics_destroy_sample on the returned object.
-//
-// @param analytics gvr_analytics* returned by gvr_get_analytics.
-// @return gvr_analytics_sample* containing analytics data.
-const gvr_analytics_sample* gvr_analytics_create_sample(
- const gvr_analytics* analytics);
-
-// Returns pointer to a buffer containing a serialized AnalyticsSample proto.
-// The buffer is valid only for the lifetime of the gvr_analytics_sample.
-//
-// @param Pointer to a gvr_analytics_sample object.
-// @return Pointer to buffer.
-const char* gvr_analytics_sample_get_buffer(const gvr_analytics_sample* sample);
-
-// Returns the length of the buffer returned by gvr_analytics_sample_get_buffer.
-//
-// @param Pointer to a gvr_analytics_sample object.
-// @return Length of buffer.
-size_t gvr_analytics_sample_get_buffer_length(
- const gvr_analytics_sample* sample);
-
-// Destroys a gvr_analytics_sample* previously created through
-// gvr_analytics_create_sample.
-//
-// @param sample Pointer to pointer that will be set to null and whose
-// underlying gvr_analytics_sample will be destroyed.
-void gvr_analytics_destroy_sample(const gvr_analytics_sample** sample);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#endif // VR_GVR_CAPI_SRC_GVR_EXPERIMENTAL_H_
diff --git a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/src/gvr_private.h b/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/src/gvr_private.h
deleted file mode 100644
index 0a9d30e..0000000
--- a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/src/gvr_private.h
+++ /dev/null
@@ -1,378 +0,0 @@
-#ifndef VR_GVR_CAPI_SRC_GVR_PRIVATE_H_
-#define VR_GVR_CAPI_SRC_GVR_PRIVATE_H_
-
-#include <stddef.h>
-
-#include "vr/gvr/capi/include/gvr_types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Opaque handle to gvr_tracker_state object containing serialized state.
-typedef struct gvr_tracker_state_ gvr_tracker_state;
-
-// Opaque handle to gvr_display_synchronizer object for display synchronization.
-typedef struct gvr_display_synchronizer_ gvr_display_synchronizer;
-
-// Internal Google VR C API methods. These methods are exposed only to internal
-// targets, but should follow all the same backwards-compatible restrictions
-// as the public C API.
-
-/// Sets whether asynchronous reprojection is currently enabled.
-///
-/// If enabled, frames will be collected by the rendering system and
-/// asynchronously re-projected in sync with the scanout of the display. This
-/// feature may not be available on every platform, and requires a
-/// high-priority render thread with special extensions to function properly.
-///
-/// Note: On Android, this feature can be enabled solely via the GvrLayout Java
-/// instance which (indirectly) owns this gvr_context. The corresponding
-/// method call is GvrLayout.setAsyncReprojectionEnabled().
-///
-/// @param gvr Pointer to the gvr instance.
-/// @Param enabled Whether to enable async reprojection.
-/// @return Whether the setting was succesfully applied.
-bool gvr_set_async_reprojection_enabled(gvr_context* gvr, bool enabled);
-
-// Initializes necessary GL-related objects and uses the current thread and
-// GL context for racing the scanline. This function should only be called
-// by the SDK itself, not by any application, unless that application is
-// providing a high-priority thread and GL context for async reprojection.
-//
-// Note: This method is private as it is intended for use solely by the
-// hidden async reprojection implementation in ScanlineRacingRenderer.java,
-// called in onSurfaceCreated().
-//
-// @param gvr Pointer to the gvr_context instance.
-void gvr_on_surface_created_reprojection_thread(gvr_context* gvr);
-
-// Renders the scanline layer. This function should only be called
-// in the same thread that gvr_initialize_gl_projection_thread was called in.
-// This function should only be called by the SDK itself, not by any
-// application, unless that application is providing a high-priority
-// thread and GL context for async reprojection.
-//
-// Note: This method is private as it is intended for use solely by the
-// hidden async reprojection implementation in ScanlineRacingRenderer.java.
-//
-// @param gvr Pointer to the gvr_context instance.
-void gvr_render_reprojection_thread(gvr_context* gvr);
-
-// Signals to the reprojection thread that it is paused. This is necessary
-// in case the application render thread is blocked on pending work by the
-// reprojection thread. This function will abort any blocking.
-//
-// @param gvr Pointer to the gvr_context instance.
-void gvr_on_pause_reprojection_thread(gvr_context* gvr);
-
-// Sets the parameters for the external surface managed by the reprojection
-// thread.
-//
-// @param gvr Pointer to the gvr_context instance.
-// @param surface_id The ID of the external Surface managed by the reprojection
-// thread. The ID is issued by the SurfaceTextureManager.
-// @param texture_id The GL texture ID associated with the external Surface.
-// @param timestamp The timestamp of the most recent frame the Surface holds.
-// @param surface_transfrom Matrix that transforms homogeneous texture coords to
-// the external surface texture space.
-void gvr_update_surface_reprojection_thread(gvr_context* gvr,
- int32_t surface_id, int32_t texture_id, gvr_clock_time_point timestamp,
- gvr_mat4f surface_transform);
-
-// Removes all external surfaces managed by the reprojection thread. This does
-// not destoy the surfaces: it removes tracking by the reprojection thread.
-//
-// @param gvr Pointer to the gvr_context instance.
-void gvr_remove_all_surfaces_reprojection_thread(gvr_context* gvr);
-
-// Reconnects the sensors when the sensor producers are created internally.
-//
-// Note: This function is not thread-safe, and should be called only on the
-// rendering thread. It is intended to be used internally by GvrLayout when
-// the target presentation display changes.
-//
-// @param gvr Pointer to the gvr_context instance.
-void gvr_reconnect_sensors(gvr_context* gvr);
-
-// Sets VR viewer params for the current context.
-//
-// Note: This function does not update the viewer proto in the common storage
-// location. Rather, it overrides the viewer params solely for the provided
-// gvr_context.
-//
-// @param gvr Pointer to the gvr_context instance.
-// @param serialized_viewer_params A pointer to the payload containing the
-// serialized viewer params proto.
-// @param serialized_viewer_params_size_bytes The length in bytes of the
-// serialized viewer params payload.
-// @return Whether the serialized viewer params proto was successfully applied.
-bool gvr_set_viewer_params(gvr_context* gvr,
- const void* serialized_viewer_params,
- size_t serialized_viewer_params_size_bytes);
-
-// Sets the lens offset.
-//
-// @param offset The offset of the lens center from the expected location in
-// screen space.
-void gvr_set_lens_offset(gvr_context* gvr, gvr_vec2f offset);
-
-// Sets display metrics for the current context.
-//
-// Note: This function does not update the phone proto in the commom storage
-// location. Rather, it overrides the internal metrics solely for the provided
-// |gvr| context.
-//
-// @param gvr Pointer to the gvr_context instance.
-// @param size_pixels The dimensions in pixels of the active display.
-// @param meters_per_pixel The density of the current display in meters/pixel.
-// @param border_size_meters The size of the border around the display
-// in meters. When the device sits on a surface in the proper
-// orientation this is the distance from the surface to the edge
-// of the display.
-void gvr_set_display_metrics(gvr_context* gvr, gvr_sizei size_pixels,
- gvr_vec2f meters_per_pixel,
- float border_size_meters);
-
-// Sets the display rotation offset that is applied at distortion correction
-// time to take into account the device's display orientation.
-//
-// For instance, calling this with display_output_rotation set to 1 allows
-// clients to lock their phone orientation to portrait on an Android phone and
-// still get a correctly rendered VR mode with the two eyes stacked up along the
-// longer phone dimension.
-//
-// @param gvr Pointer to the gvr_context instance.
-// @param display_output_rotation Value encoding the rotation used when
-// performing distortion correction. Supported values are:
-// 0 - Default mode. Eye viewports are positioned side-by-side along the
-// "width" dimension, with left eye in the x < 0.5 half.
-// 1 - Applies a clock-wise rotation of 90 degrees on the display when
-// doing distortion correction. Eye viewports are positioned
-// side-by-side along the "height" dimension, with left eye in the
-// y > 0.5 half.
-// Rotation modes used when performing distortion correction.
-enum {
- GVR_PRIVATE_DISPLAY_OUTPUT_ROTATION_0 = 0,
- GVR_PRIVATE_DISPLAY_OUTPUT_ROTATION_90 = 1,
-};
-void gvr_set_display_output_rotation(gvr_context* gvr,
- int32_t display_output_rotation);
-
-// Gets the size of the border around the display used by the given gvr_context.
-//
-// @param gvr Pointer to the gvr_context instance.
-float gvr_get_border_size_meters(const gvr_context* gvr);
-
-// Returns whether the surface size was changed since the last call to this
-// function (it's changed with gvr_set_surface_size()).
-//
-// @param gvr Pointer to the gvr_context instance.
-// @return Whether the surface size was changed.
-bool gvr_check_surface_size_changed(gvr_context* gvr);
-
-// Returns the current surface size in pixels, or (0, 0) if the surface size
-// matches that of the active display (which is the default).
-//
-// @param gvr Pointer to the gvr_context instance.
-// @return The current surface size in pixels.
-gvr_sizei gvr_get_surface_size(const gvr_context* gvr);
-
-// Sets a handler that is called back when the back gesture is detected,
-// which is when the phone changes from landscape to portrait orientation
-// within a few seconds.
-//
-// @param gvr Pointer to the gvr_context instance.
-// @param handler The event_handler callback. May be null to clear the
-// registered event_handler.
-// @param user_data An opaque pointer to user_data which will be supplied
-// as the callback argument. The caller is responsible for ensuring the
-// validity of this data for the duration of the handler registration.
-typedef void (*event_handler)(void* user_data);
-void gvr_set_back_gesture_event_handler(gvr_context* gvr, event_handler handler,
- void* user_data);
-
-// Internal method to pause head tracking used by GvrLayout. Disables all
-// sensors (to save power) and gets the serialized tracker state.
-//
-// @param gvr Pointer to the gvr instance for which tracking will be paused and
-// sensors disabled.
-//
-// @return Pointer to a tracker_state object containing the serialized tracker
-// state. The caller is responsible for calling destroy on the returned
-// handle.
-gvr_tracker_state* gvr_pause_tracking_get_state(gvr_context* gvr);
-
-// Internal method to resume head tracking used by GvrLayout. Re-enables all
-// sensors and sets the tracker state.
-//
-// @param gvr Pointer to the gvr instance for which tracking will be resumed.
-// serialized tracker state object.
-// @param tracker_state Pointer to a tracker_state object containing the
-// serialized tracker state object.
-void gvr_resume_tracking_set_state(
- gvr_context* gvr, gvr_tracker_state* tracker_state);
-
-// Sets the internal flag that ignores calls to the public API's
-// gvr_pause_tracking and gvr_resume_tracking.
-// When true, the tracker is handled through GvrLayout
-// gvr_pause_tracking_private / gvr_resume_tracking_private direct calls through
-// the GvrApi instance are ignored. This is workaround to temporarily support
-// clients using GvrLayout that manually call pause/ resume tracking.
-// TODO(b/30404822) : clean this up once all existing clients move away from the
-// obsolete behavior.
-//
-// @param gvr Pointer to the gvr instance.
-// @param should_ignore Whether manual pause / resume tracker should be ignored.
-void gvr_set_ignore_manual_tracker_pause_resume(gvr_context* gvr,
- bool should_ignore);
-
-// Creates a new tracker state object from the serialized tracker state buffer.
-//
-// @param tracker_state_buffer Pointer to buffer containing the serialized
-// tracker state.
-// @param buf_size Size of the tracker state buffer.
-//
-// @return Pointer to a tracker_state object containing the serialized tracker
-// state string. The caller is responsible for calling destroy on the returned
-// handle.
-gvr_tracker_state* gvr_tracker_state_create(const char* tracker_state_buffer,
- size_t buf_size);
-
-// Gets the size of the buffer that is required to hold the serialized
-// gvr_tracker_state.
-//
-// @param Pointer to a gvr_tracker_state object containing the serialized
-// tracker state.
-//
-// @return Size of the buffer,
-size_t gvr_tracker_state_get_buffer_size(gvr_tracker_state* tracker_state);
-
-// Gets the buffer that holds the serialized gvr_tracker_state.
-//
-// @param Pointer to a tracker_state object containing the serialized tracker
-// state.
-//
-// @return Pointer to the buffer.
-const char* gvr_tracker_state_get_buffer(gvr_tracker_state* tracker_state);
-
-// Destroys a gvr_tracker_state instance.
-//
-// @param tracker_state Pointer to a pointer of the gvr_tracker_state instance
-// to be destroyed and nulled.
-void gvr_tracker_state_destroy(gvr_tracker_state** tracker_state);
-
-// Creates a new synchronizer instance.
-//
-// @return synchronizer Pointer to the new gvr_display_synchronizer instance.
-gvr_display_synchronizer* gvr_display_synchronizer_create();
-
-// Destroy the synchonronizer instance and null the pointer.
-//
-// @param synchronizer Pointer to a pointer to the gvr_display_synchronizer
-// instance.
-void gvr_display_synchronizer_destroy(gvr_display_synchronizer** synchronizer);
-
-// Resets the synchronizer with updated vsync timing data.
-//
-// @param synchronizer Pointer to the new gvr_display_synchronizer instance.
-// @param expected_interval_nanos The expected average time between
-// synchronization times, in nanoseconds, or 0 if unknown.
-// @param vsync_offset_nanos The duration, in nanos, such that the current sync
-// time minus the display vsync offset is the time when the physical
-// scan-out hardware begins to read data from the frame buffer.
-void gvr_display_synchronizer_reset(gvr_display_synchronizer* synchronizer,
- int64_t expected_interval_nanos,
- int64_t vsync_offset_nanos);
-
-// Updates the synchronizer with dispplay data for a new frame.
-//
-// @param vsync_time The new frame's vsync time.
-// @param rotation_degrees The screen rotation from sensor space to display
-// space in degrees.
-void gvr_display_synchronizer_update(gvr_display_synchronizer* synchronizer,
- gvr_clock_time_point vsync_time,
- int32_t rotation);
-
-// Installs the display synchronizer into a GVR context.
-//
-// @param gvr Pointer to the current gvr_context instance.
-// @param synchronizer Pointer to the gvr_display_synchronizer instance, to be
-// used by the context implementation during rendering.
-void gvr_set_display_synchronizer(gvr_context* gvr,
- gvr_display_synchronizer* synchronizer);
-
-// Sets the current error code. Overwrites any existing error code.
-//
-// @param gvr Pointer to the current gvr_context instance.
-// @param error_code The error code to set.
-void gvr_set_error(gvr_context* gvr, int32_t error_code);
-
-// Called by the platform layer to to indicate the application is paused. (e.g.
-// On Android, this function is called by GvrLayout.OnPause().)
-//
-// @param gvr Pointer to the current gvr_context instance.
-void gvr_pause(gvr_context* gvr);
-
-// Called by the platform layer to to indicate the application has resumed.
-// (e.g. On Android, this function is called by GvrLayout.OnResume().)
-//
-// @param gvr Pointer to the current gvr_context instance.
-void gvr_resume(gvr_context* gvr);
-
-// Dumps additional data to logcat or disk to be included in bug reports.
-//
-// @param gvr Pointer to the current gvr_context instance.
-void gvr_dump_debug_data(gvr_context* gvr);
-
-// Returns true if the libgvr implementation is using the dedicated VR display
-// service, false otherwise.
-//
-// @param gvr Pointer to the current gvr_context instance.
-bool gvr_using_vr_display_service(gvr_context* gvr);
-
-// Creates a new gvr_context using the supplied tracker, only for testing.
-//
-// Note: The pose returned is *in start space*. This is *not* the same space as
-// the pose normally returned by |gvr_get_head_space_from_start_space_rotation|.
-//
-// @param tracker The test pose tracker to use.
-// @param user_data An opaque pointer to user_data which will be supplied
-// as the callback argument. The caller is responsible for ensuring the
-// validity of this data for the duration of the handler registration.
-typedef gvr_mat4f (*gvr_test_pose_tracker)(void*, gvr_clock_time_point);
-gvr_context* gvr_create_with_tracker_for_testing(gvr_test_pose_tracker tracker,
- void* user_data);
-
-// Request resource sharing between the application's OpenGL context and the
-// scanline racing context. This must be called before gvr_initialize_gl.
-// <p>
-// This is a best effort request rather than an explicit toggle; it is a no-op
-// if the client does not enable async reprojection, or if the platform does not
-// support resource sharing.
-// <p>
-// The only OpenGL resource that we need sharing for is the framebuffer texture
-// that the app renders to, and that distortion samples from. If resource
-// sharing is disabled, then we use an EGLImage so that it can be accessed from
-// both contexts.
-// <p>
-// Also sets a callback function that is called at the end of gvr_initialize_gl,
-// while the application's OpenGL context is still active on the current thread.
-// This is used internally to notify the scanline racing renderer that the
-// application's OpenGL context has been created.
-//
-// @param gvr Pointer to the current gvr_context instance.
-// @param handler Callback that gets called when the app context becomes ready.
-// @param user_data An opaque pointer to user data which will be supplied
-// as the callback argument. The caller is responsible for ensuring the
-// validity of this data for the duration of the handler registration.
-typedef void (*gvr_egl_context_listener)(void*);
-void gvr_request_context_sharing(gvr_context* gvr,
- gvr_egl_context_listener handler,
- void* user_data);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#endif // VR_GVR_CAPI_SRC_GVR_PRIVATE_H_
diff --git a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/src/gvr_types_experimental.h b/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/src/gvr_types_experimental.h
deleted file mode 100644
index f7ae6a5..0000000
--- a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/src/gvr_types_experimental.h
+++ /dev/null
@@ -1,66 +0,0 @@
-#ifndef VR_GVR_CAPI_SRC_GVR_TYPES_EXPERIMENTAL_H_
-#define VR_GVR_CAPI_SRC_GVR_TYPES_EXPERIMENTAL_H_
-
-#include <string>
-
-// ************************************************************************** //
-// * DaydreamOS experimental Types * //
-// ************************************************************************** //
-
-// Visibility of a layer.
-typedef enum {
- GVR_INVISIBLE = 0,
- GVR_VISIBLE = 1,
-} gvr_visibility;
-
-// Whether to blur layers behind a layer.
-typedef enum {
- GVR_BLUR_BEHIND_FALSE = 0,
- GVR_BLUR_BEHIND_TRUE = 1,
-} gvr_blur_behind;
-
-// GVR external surface
-typedef struct gvr_external_surface_ gvr_external_surface;
-
-// ************************************************************************** //
-// * Daydream PlexEng experimental Types * //
-// ************************************************************************** //
-
-// Types of events that can have callbacks registered.
-// If documented, type will return a payload value when called, or will
-// otherwise be invoked with -1.f.
-// This enum has to be duplicated because there is no way to include from
-// /vr/gvr/render/performance_registry.h. Duplicate changes made here there.
-typedef enum {
- // Will be invoked with value -1.f.
- GVR_ON_ASYNC_REPROJECTION_FRAME_START = 0,
- // Will be invoked with value -1.f.
- GVR_ON_ASYNC_REPROJECTION_FRAME_STOP = 1,
- // When invoked will be called with how late in microseconds the frame was.
- GVR_ON_ASYNC_REPROJECTION_FRAME_DROP = 2,
- // The number of types of performance events you can have.
- // Also note that this value is considered invalid.
- GVR_NUM_PERF_EVENT_CALLBACK_TYPES = 3,
-} gvr_perf_event_callback_type;
-
-// Experimental VR-specific features which may or may not be supported on the
-// underlying platform. These values should not overlap with current or future
-// gvr_feature values, so we're starting with 1000000 and increasing upward.
-typedef enum {
- // Head tracking with 6 degrees of freedom (position & rotation)
- GVR_FEATURE_HEAD_POSE_6DOF = 1000000,
-} gvr_experimental_feature;
-
-// ************************************************************************** //
-// * GVR Analytics experimental APIs * //
-// ************************************************************************** //
-
-// Opaque struct returned by gvr_analytics_create_sample, used to transmit an
-// AnaylticsSample proto across the native layer.
-typedef struct gvr_analytics_sample_ {
- // Serialized AnalyticsSample proto. Note that this is not a C string, meaning
- // it is not null-terminated and may contain non-terminating nulls.
- std::string serialized_proto;
-} gvr_analytics_sample;
-
-#endif // VR_GVR_CAPI_SRC_GVR_TYPES_EXPERIMENTAL_H_
diff --git a/libs/vr/libgvr/prebuilt/lib/android_arm/libgvr.so b/libs/vr/libgvr/prebuilt/lib/android_arm/libgvr.so
deleted file mode 100644
index bfd5956..0000000
--- a/libs/vr/libgvr/prebuilt/lib/android_arm/libgvr.so
+++ /dev/null
Binary files differ
diff --git a/libs/vr/libgvr/prebuilt/lib/android_arm/libgvr_audio.so b/libs/vr/libgvr/prebuilt/lib/android_arm/libgvr_audio.so
deleted file mode 100644
index c3012b1..0000000
--- a/libs/vr/libgvr/prebuilt/lib/android_arm/libgvr_audio.so
+++ /dev/null
Binary files differ
diff --git a/libs/vr/libgvr/prebuilt/lib/android_arm64/libgvr.so b/libs/vr/libgvr/prebuilt/lib/android_arm64/libgvr.so
deleted file mode 100644
index 6608c25..0000000
--- a/libs/vr/libgvr/prebuilt/lib/android_arm64/libgvr.so
+++ /dev/null
Binary files differ
diff --git a/libs/vr/libgvr/prebuilt/lib/android_arm64/libgvr_audio.so b/libs/vr/libgvr/prebuilt/lib/android_arm64/libgvr_audio.so
deleted file mode 100644
index b1d7690..0000000
--- a/libs/vr/libgvr/prebuilt/lib/android_arm64/libgvr_audio.so
+++ /dev/null
Binary files differ
diff --git a/libs/vr/libgvr/prebuilt/lib/android_x86/libgvr.so b/libs/vr/libgvr/prebuilt/lib/android_x86/libgvr.so
deleted file mode 100644
index f7f7786..0000000
--- a/libs/vr/libgvr/prebuilt/lib/android_x86/libgvr.so
+++ /dev/null
Binary files differ
diff --git a/libs/vr/libgvr/prebuilt/lib/android_x86/libgvr_audio.so b/libs/vr/libgvr/prebuilt/lib/android_x86/libgvr_audio.so
deleted file mode 100644
index 97aec40..0000000
--- a/libs/vr/libgvr/prebuilt/lib/android_x86/libgvr_audio.so
+++ /dev/null
Binary files differ
diff --git a/libs/vr/libgvr/prebuilt/lib/android_x86_64/libgvr.so b/libs/vr/libgvr/prebuilt/lib/android_x86_64/libgvr.so
deleted file mode 100644
index 2e2dbc1..0000000
--- a/libs/vr/libgvr/prebuilt/lib/android_x86_64/libgvr.so
+++ /dev/null
Binary files differ
diff --git a/libs/vr/libgvr/prebuilt/lib/android_x86_64/libgvr_audio.so b/libs/vr/libgvr/prebuilt/lib/android_x86_64/libgvr_audio.so
deleted file mode 100644
index cd8d0e0..0000000
--- a/libs/vr/libgvr/prebuilt/lib/android_x86_64/libgvr_audio.so
+++ /dev/null
Binary files differ
diff --git a/libs/vr/libgvr/prebuilt/lib/common_library.aar b/libs/vr/libgvr/prebuilt/lib/common_library.aar
deleted file mode 100644
index 9c1fbd0..0000000
--- a/libs/vr/libgvr/prebuilt/lib/common_library.aar
+++ /dev/null
Binary files differ
diff --git a/libs/vr/libgvr/shim_gvr.cpp b/libs/vr/libgvr/shim_gvr.cpp
deleted file mode 100644
index 5eb6e3d..0000000
--- a/libs/vr/libgvr/shim_gvr.cpp
+++ /dev/null
@@ -1,1352 +0,0 @@
-#define LOG_TAG "libgvr_shim"
-
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
-#include <GLES3/gl31.h>
-#include <GLES3/gl3ext.h>
-#include <algorithm>
-#include <cmath>
-
-#ifdef __ARM_NEON
-#include <arm_neon.h>
-#else
-#ifndef __FLOAT32X4T_86
-#define __FLOAT32X4T_86
-typedef float float32x4_t __attribute__ ((__vector_size__ (16)));
-typedef struct float32x4x4_t { float32x4_t val[4]; };
-#endif
-#endif
-
-#include <dvr/graphics.h>
-#include <dvr/performance_client_api.h>
-#include <dvr/pose_client.h>
-#include <log/log.h>
-#include <private/dvr/buffer_hub_queue_core.h>
-#include <private/dvr/buffer_hub_queue_producer.h>
-#include <private/dvr/clock_ns.h>
-#include <private/dvr/display_client.h>
-#include <private/dvr/graphics_private.h>
-#include <private/dvr/internal_types.h>
-#include <private/dvr/numeric.h>
-#include <private/dvr/types.h>
-#include <private/dvr/video_mesh_surface_client.h>
-#include <sys/system_properties.h>
-#include <vr/gvr/capi/include/gvr.h>
-#include <vr/gvr/capi/include/gvr_ext.h>
-#include <vr/gvr/capi/include/gvr_util.h>
-#include <vr/gvr/capi/src/gvr_experimental.h>
-#include <vr/gvr/capi/src/gvr_private.h>
-
-#include <android_runtime/android_view_Surface.h>
-#include <gui/Surface.h>
-
-using android::dvr::DisplayClient;
-using android::dvr::EigenToGvrMatrix;
-using android::dvr::FieldOfView;
-using android::dvr::FovRadiansToDegrees;
-using android::dvr::GetSystemClockNs;
-using android::dvr::GvrIdentityMatrix;
-using android::dvr::GvrMatrixToPosef;
-using android::dvr::GvrToDvrFov;
-using android::dvr::GvrToEigenMatrix;
-using android::dvr::GvrToEigenRotation;
-using android::dvr::GvrTranslationMatrix;
-using android::dvr::IsEqual;
-using android::dvr::PosefToGvrMatrix;
-using android::dvr::mat3;
-using android::dvr::mat4;
-using android::dvr::Posef;
-using android::dvr::quat;
-using android::dvr::vec3;
-
-namespace {
-
-constexpr static int32_t GVR_SDK_MAJOR_VERSION = 2;
-constexpr static int32_t GVR_SDK_MINOR_VERSION = 0;
-constexpr static int32_t GVR_SDK_PATCH_VERSION = 0;
-
-// The "DaydreamOS" part has been appended to make easier to see when VrCore
-// dynamic GVR API loading is effectively working.
-static const char* kVersionString = "2.0.0 DaydreamOS";
-static const char* kViewerVendor = "Google";
-static const char* kViewerModel = "Lucid";
-
-// Experimental system property used to provide 6DoF information on 3DoF APIs.
-static const char* kForce6DofProp = "experimental.force_6dof";
-
-static constexpr int kControllerCount = 2;
-
-gvr_frame* GetFrameFromSwapChain(gvr_swap_chain* swap_chain) {
- return reinterpret_cast<gvr_frame*>(swap_chain);
-}
-
-gvr_swap_chain* GetSwapChainForFrame(gvr_frame* frame) {
- return reinterpret_cast<gvr_swap_chain*>(frame);
-}
-
-const gvr_swap_chain* GetSwapChainForFrame(const gvr_frame* frame) {
- return reinterpret_cast<const gvr_swap_chain*>(frame);
-}
-
-// Returns the world to head transform as a Posef.
-Posef ToPosef(const DvrPoseAsync& pose) {
- return Posef(
- quat(pose.orientation[3], pose.orientation[0], pose.orientation[1],
- pose.orientation[2]),
- vec3(pose.translation[0], pose.translation[1], pose.translation[2]));
-}
-
-// Returns the world to head transform, with 0 position, as a gvr matrix
-gvr_mat4f Gvr6dofTo3dof(const gvr_mat4f& pose) {
- gvr_mat4f ret = pose;
- ret.m[0][3] = 0;
- ret.m[1][3] = 0;
- ret.m[2][3] = 0;
- return ret;
-}
-
-void GvrToDvrPose(gvr_mat4f world_to_head_transform,
- /*out*/ float32x4_t* orientation,
- /*out */ float32x4_t* translation) {
- Posef pose = GvrMatrixToPosef(world_to_head_transform);
- (*orientation)[0] = pose.GetRotation().x();
- (*orientation)[1] = pose.GetRotation().y();
- (*orientation)[2] = pose.GetRotation().z();
- (*orientation)[3] = pose.GetRotation().w();
- (*translation)[0] = pose.GetPosition().x();
- (*translation)[1] = pose.GetPosition().y();
- (*translation)[2] = pose.GetPosition().z();
- (*translation)[3] = 0;
-}
-
-bool MatricesAlmostEqual(const gvr_mat4f& m1, const gvr_mat4f& m2,
- float tolerance) {
- for (int row = 0; row < 4; ++row) {
- for (int col = 0; col < 4; ++col) {
- if (!IsEqual(m1.m[row][col], m2.m[row][col], tolerance))
- return false;
- }
- }
- return true;
-}
-
-gvr_mat4f FovToViewportTransform(const gvr_rectf& fov) {
- // Depth range (1 1000) is chosen to match gvr impl in google3, which is
- // chosen to match Unity integration.
- return EigenToGvrMatrix(
- GvrToDvrFov(fov).GetProjectionMatrix(1.f, 1000.f).inverse());
-}
-
-gvr_rectf ViewportTransformToFov(const gvr_mat4f& transform) {
- return DvrToGvrFov(
- FieldOfView::FromProjectionMatrix(GvrToEigenMatrix(transform).inverse()));
-}
-
-bool GetGlColorFormat(int32_t gvr_color_format,
- /*out*/ GLenum* gl_color_format) {
- switch (gvr_color_format) {
- case GVR_COLOR_FORMAT_RGBA_8888:
- *gl_color_format = GL_RGBA8;
- break;
- case GVR_COLOR_FORMAT_RGB_565:
- *gl_color_format = GL_RGB565;
- break;
- default:
- return false;
- }
- return true;
-}
-
-bool GetGlDepthFormat(int32_t gvr_depth_format,
- /*out*/ GLenum* gl_depth_format) {
- switch (gvr_depth_format) {
- case GVR_DEPTH_STENCIL_FORMAT_DEPTH_16:
- *gl_depth_format = GL_DEPTH_COMPONENT16;
- break;
- case GVR_DEPTH_STENCIL_FORMAT_DEPTH_24:
- *gl_depth_format = GL_DEPTH_COMPONENT24;
- break;
- case GVR_DEPTH_STENCIL_FORMAT_DEPTH_24_STENCIL_8:
- *gl_depth_format = GL_DEPTH24_STENCIL8;
- break;
- case GVR_DEPTH_STENCIL_FORMAT_DEPTH_32_F:
- *gl_depth_format = GL_DEPTH_COMPONENT32F;
- break;
- case GVR_DEPTH_STENCIL_FORMAT_DEPTH_32_F_STENCIL_8:
- *gl_depth_format = GL_DEPTH32F_STENCIL8;
- break;
- default:
- return false;
- }
- return true;
-}
-
-// Returns true on success, false on failure. If the swap_chain already has a
-// DvrGraphicsContext and gvr buffer, they'll be freed first. If creation fails,
-// the DvrGraphicsContext in the swap_chain will be set to null and the
-// corresponding gvr buffer will be freed.
-bool CreateDvrGraphicsContextAndGvrBuffer(gvr_swap_chain* swap_chain) {
- if (swap_chain->buffers_.empty()) {
- ALOGE("Can't create a graphics context for an empty swap chain");
- return false;
- }
-
- // We currently only render the first gvr buffer. Create a DvrGraphicsContext
- // for the first buffer only.
- gvr_buffer& buf = swap_chain->buffers_[0];
- buf.FreeGl();
-
- bool visible;
- int z_order;
- if (swap_chain->graphics_context_ != nullptr) {
- visible = dvrGraphicsSurfaceGetVisible(swap_chain->graphics_context_);
- z_order = dvrGraphicsSurfaceGetZOrder(swap_chain->graphics_context_);
- dvrGraphicsContextDestroy(swap_chain->graphics_context_);
- swap_chain->graphics_context_ = nullptr;
- } else {
- visible = buf.spec.initially_visible;
- z_order = buf.spec.z_order;
- }
-
- int width = 0, height = 0;
- GLuint texture_id = 0;
- GLenum texture_target = 0;
- DvrSurfaceParameter surface_params[] = {
- DVR_SURFACE_PARAMETER_IN(DISABLE_DISTORTION, false),
- DVR_SURFACE_PARAMETER_IN(CREATE_GL_CONTEXT, 0),
- DVR_SURFACE_PARAMETER_IN(WIDTH, buf.spec.size.width),
- DVR_SURFACE_PARAMETER_IN(HEIGHT, buf.spec.size.height),
- DVR_SURFACE_PARAMETER_IN(BLUR_BEHIND, buf.spec.blur_behind),
- DVR_SURFACE_PARAMETER_IN(VISIBLE, visible),
- DVR_SURFACE_PARAMETER_IN(Z_ORDER, z_order),
- DVR_SURFACE_PARAMETER_OUT(SURFACE_WIDTH, &width),
- DVR_SURFACE_PARAMETER_OUT(SURFACE_HEIGHT, &height),
- DVR_SURFACE_PARAMETER_OUT(SURFACE_TEXTURE_TARGET_TYPE, &texture_target),
- DVR_SURFACE_PARAMETER_OUT(SURFACE_TEXTURE_TARGET_ID, &texture_id),
- DVR_SURFACE_PARAMETER_LIST_END,
- };
-
- DvrGraphicsContext* graphics_context;
- int ret = dvrGraphicsContextCreate(surface_params, &graphics_context);
- if (ret < 0) {
- ALOGE("dvrGraphicsContextCreate failed: %d (%s)", ret, strerror(-ret));
- gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
- return false;
- }
-
- // Sanity check that the size of the buffer we allocated from the system is
- // what we expect
- if (buf.spec.size != gvr_sizei{width, height}) {
- ALOGE(
- "The created surface is the wrong size."
- " Should be %dx%d, instead got %dx%d.",
- buf.spec.size.width, buf.spec.size.height, width, height);
- gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
- dvrGraphicsContextDestroy(graphics_context);
- return false;
- }
-
- buf = gvr_buffer(swap_chain->context, buf.spec, texture_id, texture_target);
- if (buf.frame_buffer == 0) {
- dvrGraphicsContextDestroy(graphics_context);
- return false;
- }
-
- swap_chain->graphics_context_ = graphics_context;
- return true;
-}
-
-bool SwapChainResizeBuffer(gvr_swap_chain* swap_chain, int buffer_index) {
- gvr_buffer& buf = swap_chain->buffers_[buffer_index];
- buf.FreeGl();
- gvr_sizei orig_size = buf.spec.size;
- buf.spec.size = buf.requested_size;
- bool resize_successful = false;
- if (buffer_index == 0) {
- resize_successful = CreateDvrGraphicsContextAndGvrBuffer(swap_chain);
- } else {
- buf = gvr_buffer(swap_chain->context, buf.spec, 0, GL_TEXTURE_2D);
- resize_successful = buf.frame_buffer != 0;
- }
-
- if (resize_successful) {
- // The resize was successful, so clear the resize request
- buf.requested_size = {-1, -1};
- } else {
- ALOGE("Failed to resize buffer. orig_size=%dx%d requested_size=%dx%d.",
- orig_size.width, orig_size.height, buf.requested_size.width,
- buf.requested_size.height);
- gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
- buf.spec.size = orig_size;
- }
-
- return resize_successful;
-}
-
-void WaitNextFrame(gvr_swap_chain* swap_chain, int64_t start_delay_nanos,
- gvr_frame_schedule* out_next_frame_schedule,
- bool called_by_app) {
- if (called_by_app)
- swap_chain->wait_next_frame_called_by_app_ = true;
-
- DvrFrameSchedule dvr_schedule;
- int ret = dvrGraphicsWaitNextFrame(swap_chain->graphics_context_,
- start_delay_nanos, &dvr_schedule);
- if (ret < 0) {
- gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
- return;
- }
- if (out_next_frame_schedule) {
- out_next_frame_schedule->vsync_count = dvr_schedule.vsync_count;
- out_next_frame_schedule->scheduled_finish.monotonic_system_time_nanos =
- dvr_schedule.scheduled_frame_finish_ns;
- }
-
- DvrPoseAsync pose;
- ret = dvrPoseGet(swap_chain->context->pose_client_, dvr_schedule.vsync_count,
- &pose);
- if (ret < 0) {
- ALOGW("dvrPoseGet failed: %d", ret);
- gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
- return;
- }
-
- swap_chain->context->next_frame_6dof_pose_ = PosefToGvrMatrix(ToPosef(pose));
-
- for (int i = 0; i < kControllerCount; ++i) {
- ret = dvrPoseGetController(swap_chain->context->pose_client_, i,
- dvr_schedule.vsync_count, &pose);
- if (ret == 0) {
- // Silently fail when there are no controllers.
- swap_chain->context->next_frame_controller_pose_[i] =
- PosefToGvrMatrix(ToPosef(pose).Inverse());
- }
- }
-}
-
-bool VerifyBufferIndex(const std::string& function_name,
- const gvr_swap_chain* swap_chain, int index) {
- if (index > static_cast<int32_t>(swap_chain->buffers_.size())) {
- ALOGE("%s out of range buffer index. index=%d num_buffers=%zu.",
- function_name.c_str(), index, swap_chain->buffers_.size());
- gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
- return false;
- }
- return true;
-}
-
-} // anonymous namespace
-
-gvr_context* gvr_create(JNIEnv* env, jobject /* app_context */,
- jobject /* class_loader */) {
- std::unique_ptr<gvr_context> context(new gvr_context);
-
- // Set cpu set to avoid default scheduling randomness.
- dvrSetCpuPartition(0, "/application/performance");
-
- context->jni_env_ = env;
- context->pose_client_ = dvrPoseCreate();
- if (!context->pose_client_) {
- ALOGE("Failed to create pose client");
- return nullptr;
- }
-
- context->display_client_ = DisplayClient::Create();
- if (!context->display_client_) {
- ALOGE("Failed to create display client");
- return nullptr;
- }
-
- int ret =
- context->display_client_->GetDisplayMetrics(&context->display_metrics_);
- if (ret < 0) {
- ALOGE("Failed to get display metrics: %d (%s)", ret, strerror(-ret));
- return nullptr;
- }
-
- const float* left_fov = context->display_metrics_.left_fov_lrbt.data();
- context->left_eye_viewport_transform_ =
- FovToViewportTransform(FovRadiansToDegrees(
- gvr_rectf{left_fov[0], left_fov[1], left_fov[2], left_fov[3]}));
-
- const float* right_fov = context->display_metrics_.right_fov_lrbt.data();
- context->right_eye_viewport_transform_ =
- FovToViewportTransform(FovRadiansToDegrees(
- gvr_rectf{right_fov[0], right_fov[1], right_fov[2], right_fov[3]}));
-
- context->next_frame_6dof_pose_ = GvrIdentityMatrix();
-
- for (int i = 0; i < kControllerCount; ++i) {
- context->next_frame_controller_pose_[i] = GvrIdentityMatrix();
- }
-
- // Check the system property to force 6DoF when requested 3DoF.
- char prop_buffer[PROP_VALUE_MAX];
- if (__system_property_get(kForce6DofProp, prop_buffer) &&
- (!strncasecmp("1", prop_buffer, PROP_VALUE_MAX) ||
- !strncasecmp("true", prop_buffer, PROP_VALUE_MAX))) {
- context->force_6dof_ = true;
- }
-
- return context.release();
-}
-
-gvr_version gvr_get_version() {
- gvr_version version = {};
- version.major = GVR_SDK_MAJOR_VERSION;
- version.minor = GVR_SDK_MINOR_VERSION;
- version.patch = GVR_SDK_PATCH_VERSION;
- return version;
-}
-
-const char* gvr_get_version_string() { return kVersionString; }
-
-int32_t gvr_get_error(gvr_context* gvr) { return gvr->last_error_; }
-
-int32_t gvr_clear_error(gvr_context* gvr) {
- int32_t last_error = gvr->last_error_;
- gvr->last_error_ = GVR_ERROR_NONE;
- return last_error;
-}
-
-const char* gvr_get_error_string(int32_t error_code) {
- switch (error_code) {
- case GVR_ERROR_NONE:
- return "No error";
- case GVR_ERROR_CONTROLLER_CREATE_FAILED:
- return "Creation of GVR controller context failed";
- case GVR_ERROR_NO_FRAME_AVAILABLE:
- return "No frame available in swap chain";
- case GVR_ERROR_INTERNAL:
- return "Internal error";
- default:
- return "(Internal error: unknown error code)";
- }
-}
-
-const gvr_user_prefs* gvr_get_user_prefs(gvr_context* gvr) {
- return &gvr->user_prefs_;
-}
-
-int32_t gvr_user_prefs_get_controller_handedness(
- const gvr_user_prefs* /* user_prefs */) {
- return GVR_CONTROLLER_RIGHT_HANDED;
-}
-
-gvr_context_::~gvr_context_() {
- for (gvr_swap_chain* swap_chain : swap_chains_)
- swap_chain->context = nullptr;
- if (pose_client_)
- dvrPoseDestroy(pose_client_);
-}
-
-void gvr_destroy(gvr_context** gvr) {
- if (!gvr || !(*gvr)) {
- ALOGW("gvr_destroy: Invalid gvr_context pointer.");
- return;
- }
- delete *gvr;
- *gvr = nullptr;
-}
-
-void gvr_initialize_gl(gvr_context* /* gvr */) {}
-
-bool gvr_get_async_reprojection_enabled(const gvr_context* /* gvr */) {
- return true;
-}
-
-void gvr_get_recommended_buffer_viewports(
- const gvr_context* gvr, gvr_buffer_viewport_list* viewport_list) {
- gvr_buffer_viewport left(
- /*buffer_index*/ 0,
- /*uv*/ {0, .5f, 0, 1}, gvr->left_eye_viewport_transform_, GVR_LEFT_EYE,
- GVR_EXTERNAL_SURFACE_ID_NONE, GVR_REPROJECTION_FULL);
-
- gvr_buffer_viewport right(
- /*buffer_index*/ 0,
- /*uv*/ {.5f, 1, 0, 1}, gvr->right_eye_viewport_transform_, GVR_RIGHT_EYE,
- GVR_EXTERNAL_SURFACE_ID_NONE, GVR_REPROJECTION_FULL);
-
- viewport_list->viewports.resize(2);
- viewport_list->viewports[0] = left;
- viewport_list->viewports[1] = right;
-}
-
-void gvr_get_screen_buffer_viewports(const gvr_context* gvr,
- gvr_buffer_viewport_list* viewport_list) {
- gvr_get_recommended_buffer_viewports(gvr, viewport_list);
-}
-
-gvr_sizei gvr_get_maximum_effective_render_target_size(const gvr_context* gvr) {
- return gvr_sizei{
- static_cast<int32_t>(gvr->display_metrics_.distorted_width),
- static_cast<int32_t>(gvr->display_metrics_.distorted_height)};
-}
-
-gvr_sizei gvr_get_screen_target_size(const gvr_context* gvr) {
- // DisplayMetrics returns native_width and native_height for the display in
- // portrait orientation, which our device is never in. Swap the width and
- // height to account for this.
- return gvr_sizei{
- static_cast<int32_t>(gvr->display_metrics_.display_native_height),
- static_cast<int32_t>(gvr->display_metrics_.display_native_width)};
-}
-
-void gvr_set_surface_size(gvr_context* gvr,
- gvr_sizei /* surface_size_pixels */) {
- // TODO(leandrogracia): this needs to be properly implemented.
- ALOGE("gvr_set_surface_size not implemented.");
- gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-}
-
-void gvr_distort_to_screen(
- gvr_context* gvr, int32_t /* texture_id */,
- const gvr_buffer_viewport_list* /* viewport_list */,
- gvr_mat4f /* head_space_from_start_space */,
- gvr_clock_time_point /* target_presentation_time */) {
- // TODO(leandrogracia): this needs to be properly implemented.
- ALOGE("gvr_distort_to_screen not implemented.");
- gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-}
-
-bool gvr_is_feature_supported(const gvr_context* /*gvr*/, int32_t feature) {
- return feature == GVR_FEATURE_ASYNC_REPROJECTION ||
- feature == GVR_FEATURE_HEAD_POSE_6DOF;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Viewports and viewport lists
-/////////////////////////////////////////////////////////////////////////////
-
-bool gvr_buffer_viewport::operator==(const gvr_buffer_viewport_& other) const {
- return buffer_index == other.buffer_index && uv == other.uv &&
- eye == other.eye && external_surface_id == other.external_surface_id &&
- reprojection == other.reprojection &&
- MatricesAlmostEqual(transform, other.transform, 1e-5f);
-}
-
-gvr_buffer_viewport* gvr_buffer_viewport_create(gvr_context* /* gvr */) {
- return new gvr_buffer_viewport;
-}
-
-void gvr_buffer_viewport_destroy(gvr_buffer_viewport** viewport) {
- if (viewport) {
- delete *viewport;
- *viewport = nullptr;
- }
-}
-
-gvr_rectf gvr_buffer_viewport_get_source_uv(
- const gvr_buffer_viewport* viewport) {
- return viewport->uv;
-}
-
-void gvr_buffer_viewport_set_source_uv(gvr_buffer_viewport* viewport,
- gvr_rectf uv) {
- viewport->uv = uv;
-}
-
-gvr_rectf gvr_buffer_viewport_get_source_fov(
- const gvr_buffer_viewport* viewport) {
- return ViewportTransformToFov(viewport->transform);
-}
-
-void gvr_buffer_viewport_set_source_fov(gvr_buffer_viewport* viewport,
- gvr_rectf fov) {
- viewport->transform = FovToViewportTransform(fov);
-}
-
-gvr_mat4f gvr_buffer_viewport_get_transform(
- const gvr_buffer_viewport* viewport) {
- return viewport->transform;
-}
-
-void gvr_buffer_viewport_set_transform(gvr_buffer_viewport* viewport,
- gvr_mat4f transform) {
- viewport->transform = transform;
-}
-
-int32_t gvr_buffer_viewport_get_target_eye(
- const gvr_buffer_viewport* viewport) {
- return viewport->eye;
-}
-
-void gvr_buffer_viewport_set_target_eye(gvr_buffer_viewport* viewport,
- int32_t index) {
- viewport->eye = index;
-}
-
-int32_t gvr_buffer_viewport_get_source_buffer_index(
- const gvr_buffer_viewport* viewport) {
- return viewport->buffer_index;
-}
-
-void gvr_buffer_viewport_set_source_buffer_index(gvr_buffer_viewport* viewport,
- int32_t buffer_index) {
- viewport->buffer_index = buffer_index;
-}
-
-int32_t gvr_buffer_viewport_get_external_surface_id(
- const gvr_buffer_viewport* viewport) {
- return viewport->external_surface_id;
-}
-
-void gvr_buffer_viewport_set_external_surface_id(gvr_buffer_viewport* viewport,
- int32_t external_surface_id) {
- viewport->external_surface_id = external_surface_id;
-}
-
-int32_t gvr_buffer_viewport_get_reprojection(
- const gvr_buffer_viewport* viewport) {
- return viewport->reprojection;
-}
-
-void gvr_buffer_viewport_set_reprojection(gvr_buffer_viewport* viewport,
- int32_t reprojection) {
- viewport->reprojection = static_cast<gvr_reprojection>(reprojection);
-}
-
-bool gvr_buffer_viewport_equal(const gvr_buffer_viewport* a,
- const gvr_buffer_viewport* b) {
- return *a == *b;
-}
-
-gvr_buffer_viewport_list* gvr_buffer_viewport_list_create(
- const gvr_context* /* gvr */) {
- return new gvr_buffer_viewport_list;
-}
-
-void gvr_buffer_viewport_list_destroy(
- gvr_buffer_viewport_list** viewport_list) {
- if (!viewport_list || !(*viewport_list)) {
- ALOGW("gvr_buffer_viewport_list_destroy: Invalid list pointer.");
- return;
- }
- delete *viewport_list;
- *viewport_list = nullptr;
-}
-
-size_t gvr_buffer_viewport_list_get_size(
- const gvr_buffer_viewport_list* viewport_list) {
- return viewport_list->viewports.size();
-}
-
-void gvr_buffer_viewport_list_get_item(
- const gvr_buffer_viewport_list* viewport_list, size_t index,
- gvr_buffer_viewport* viewport) {
- *viewport = viewport_list->viewports[index];
-}
-
-void gvr_buffer_viewport_list_set_item(gvr_buffer_viewport_list* viewport_list,
- size_t index,
- const gvr_buffer_viewport* viewport) {
- if (index < viewport_list->viewports.size())
- viewport_list->viewports[index] = *viewport;
- else
- viewport_list->viewports.push_back(*viewport);
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Swapchains and frames
-/////////////////////////////////////////////////////////////////////////////
-
-gvr_buffer_spec* gvr_buffer_spec_create(gvr_context* /* gvr */) {
- return new gvr_buffer_spec;
-}
-
-void gvr_buffer_spec_destroy(gvr_buffer_spec** spec) {
- if (spec) {
- delete *spec;
- *spec = nullptr;
- }
-}
-
-gvr_sizei gvr_buffer_spec_get_size(const gvr_buffer_spec* spec) {
- return spec->size;
-}
-
-void gvr_buffer_spec_set_size(gvr_buffer_spec* spec, gvr_sizei size) {
- spec->size = size;
-}
-
-int32_t gvr_buffer_spec_get_samples(const gvr_buffer_spec* spec) {
- return spec->msaa_samples;
-}
-
-void gvr_buffer_spec_set_samples(gvr_buffer_spec* spec, int32_t num_samples) {
- spec->msaa_samples = num_samples;
-}
-
-void gvr_buffer_spec_set_color_format(gvr_buffer_spec* spec,
- int32_t color_format) {
- spec->color_format = color_format;
-}
-
-void gvr_buffer_spec_set_depth_stencil_format(gvr_buffer_spec* spec,
- int32_t depth_stencil_format) {
- spec->depth_stencil_format = depth_stencil_format;
-}
-
-void gvr_buffer_spec_set_z_order(gvr_buffer_spec* spec, int z_order) {
- spec->z_order = z_order;
-}
-
-void gvr_buffer_spec_set_visibility(gvr_buffer_spec* spec,
- int32_t visibility) {
- spec->initially_visible = (visibility != GVR_INVISIBLE);
-}
-
-void gvr_buffer_spec_set_blur_behind(gvr_buffer_spec* spec,
- int32_t blur_behind) {
- spec->blur_behind = (blur_behind != GVR_BLUR_BEHIND_FALSE);
-}
-
-void gvr_buffer::SetDefaults() {
- spec = gvr_buffer_spec();
- frame_buffer = 0;
- color_render_buffer = 0;
- depth_stencil_render_buffer = 0;
- requested_size = {-1, -1};
-}
-
-gvr_buffer::gvr_buffer() { SetDefaults(); }
-
-gvr_buffer::gvr_buffer(gvr_context* gvr, const gvr_buffer_spec& spec_in,
- GLuint texture_id, GLenum texture_target) {
- SetDefaults();
- spec = spec_in;
-
- glGetError(); // Clear error state
- glGenFramebuffers(1, &frame_buffer);
- glBindFramebuffer(GL_FRAMEBUFFER, frame_buffer);
-
- if (texture_id == 0) {
- GLenum gl_color_format;
- if (!GetGlColorFormat(spec.color_format, &gl_color_format)) {
- ALOGE("Unknown color format: %d", spec.color_format);
- gvr_set_error(gvr, GVR_ERROR_INTERNAL);
- FreeGl();
- return;
- }
-
- glGenRenderbuffers(1, &color_render_buffer);
- glBindRenderbuffer(GL_RENDERBUFFER, color_render_buffer);
- if (spec.msaa_samples < 2) {
- glRenderbufferStorage(GL_RENDERBUFFER, gl_color_format, spec.size.width,
- spec.size.height);
- } else {
- glRenderbufferStorageMultisample(GL_RENDERBUFFER, spec.msaa_samples,
- gl_color_format, spec.size.width,
- spec.size.height);
- }
- glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
- GL_RENDERBUFFER, color_render_buffer);
- } else {
- if (spec.msaa_samples < 2) {
- glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
- texture_target, texture_id, 0);
- } else {
- glFramebufferTexture2DMultisampleEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
- texture_target, texture_id, 0,
- spec.msaa_samples);
- }
- }
-
- if (spec.depth_stencil_format != GVR_DEPTH_STENCIL_FORMAT_NONE) {
- GLenum gl_depth_format;
- if (!GetGlDepthFormat(spec.depth_stencil_format, &gl_depth_format)) {
- ALOGE("Unknown depth/stencil format: %d", spec.depth_stencil_format);
- gvr_set_error(gvr, GVR_ERROR_INTERNAL);
- FreeGl();
- return;
- }
-
- glGenRenderbuffers(1, &depth_stencil_render_buffer);
- glBindRenderbuffer(GL_RENDERBUFFER, depth_stencil_render_buffer);
- if (spec.msaa_samples < 2) {
- glRenderbufferStorage(GL_RENDERBUFFER, gl_depth_format, spec.size.width,
- spec.size.height);
- } else {
- glRenderbufferStorageMultisample(GL_RENDERBUFFER, spec.msaa_samples,
- gl_depth_format, spec.size.width,
- spec.size.height);
- }
- glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
- GL_RENDERBUFFER, depth_stencil_render_buffer);
- }
-
- GLenum gl_error = glGetError();
- if (gl_error != GL_NO_ERROR) {
- ALOGE("GL error after creating framebuffer: %d", gl_error);
- gvr_set_error(gvr, GVR_ERROR_INTERNAL);
- FreeGl();
- return;
- }
-
- GLenum framebuffer_complete_result = glCheckFramebufferStatus(GL_FRAMEBUFFER);
- if (framebuffer_complete_result != GL_FRAMEBUFFER_COMPLETE) {
- ALOGE("Framebuffer setup failed. glCheckFramebufferStatus returned %d",
- framebuffer_complete_result);
- gvr_set_error(gvr, GVR_ERROR_INTERNAL);
- FreeGl();
- return;
- }
-}
-
-void gvr_buffer::FreeGl() {
- if (frame_buffer != 0) {
- glDeleteFramebuffers(1, &frame_buffer);
- frame_buffer = 0;
- }
- if (color_render_buffer != 0) {
- glDeleteRenderbuffers(1, &color_render_buffer);
- color_render_buffer = 0;
- }
- if (depth_stencil_render_buffer != 0) {
- glDeleteRenderbuffers(1, &depth_stencil_render_buffer);
- depth_stencil_render_buffer = 0;
- }
-}
-
-gvr_buffer::~gvr_buffer() { FreeGl(); }
-
-gvr_buffer::gvr_buffer(gvr_buffer&& other) {
- spec = other.spec;
- frame_buffer = other.frame_buffer;
- color_render_buffer = other.color_render_buffer;
- depth_stencil_render_buffer = other.depth_stencil_render_buffer;
- requested_size = other.requested_size;
- other.SetDefaults();
-}
-
-gvr_buffer& gvr_buffer::operator=(gvr_buffer&& other) {
- if (this == &other)
- return *this;
- spec = other.spec;
- frame_buffer = other.frame_buffer;
- color_render_buffer = other.color_render_buffer;
- depth_stencil_render_buffer = other.depth_stencil_render_buffer;
- requested_size = other.requested_size;
- other.SetDefaults();
- return *this;
-}
-
-gvr_swap_chain* gvr_swap_chain_create(gvr_context* gvr,
- const gvr_buffer_spec** buffers,
- int32_t count) {
- if (count == 0) {
- ALOGE("At least one buffer must be requested");
- gvr_set_error(gvr, GVR_ERROR_INTERNAL);
- return nullptr;
- }
-
- // We only support one buffer, but it's common for gvr apps to use more than
- // one. Print an error to the log if the app requests more than one buffer,
- // but continue on. We'll only render the first buffer in that case.
- if (count > 1) {
- ALOGE(
- "Only one buffer is supported but the app requested %d."
- " Only the first buffer will be rendered.",
- count);
- }
-
- std::unique_ptr<gvr_swap_chain> swap_chain(new gvr_swap_chain(gvr));
-
- // The first buffer gets a DvrGraphicsContext, which contains the surface we
- // pass to displayd for rendering.
- swap_chain->buffers_.push_back(gvr_buffer());
- swap_chain->buffers_.back().spec = *buffers[0];
- if (!CreateDvrGraphicsContextAndGvrBuffer(swap_chain.get()))
- return nullptr;
-
- // The rest of the buffers, which we don't render for now, get color render
- // buffers.
- for (int i = 1; i < count; ++i) {
- swap_chain->buffers_.push_back(
- gvr_buffer(gvr, *buffers[i], 0, GL_TEXTURE_2D));
- if (swap_chain->buffers_.back().frame_buffer == 0)
- return nullptr;
- }
-
- gvr->swap_chains_.push_back(swap_chain.get());
- return swap_chain.release();
-}
-
-gvr_swap_chain_::~gvr_swap_chain_() {
- if (context) {
- auto iter = std::find(std::begin(context->swap_chains_),
- std::end(context->swap_chains_), this);
- if (iter != context->swap_chains_.end())
- context->swap_chains_.erase(iter);
- }
- buffers_.clear();
- if (graphics_context_ != nullptr)
- dvrGraphicsContextDestroy(graphics_context_);
-}
-
-void gvr_swap_chain_destroy(gvr_swap_chain** swap_chain) {
- if (!swap_chain || !(*swap_chain)) {
- ALOGW("gvr_swap_chain_destroy: Invalid swap chain pointer.");
- return;
- }
- delete *swap_chain;
- *swap_chain = nullptr;
-}
-
-int32_t gvr_swap_chain_get_buffer_count(const gvr_swap_chain* swap_chain) {
- return swap_chain ? static_cast<int32_t>(swap_chain->buffers_.size()) : 0;
-}
-
-gvr_sizei gvr_swap_chain_get_buffer_size(gvr_swap_chain* swap_chain,
- int32_t index) {
- if (!VerifyBufferIndex("gvr_swap_chain_get_buffer_size", swap_chain, index))
- return gvr_sizei{0, 0};
-
- gvr_buffer& buf = swap_chain->buffers_[index];
- if (buf.requested_size != gvr_sizei{-1, -1})
- return buf.requested_size;
- else
- return buf.spec.size;
-}
-
-void gvr_swap_chain_resize_buffer(gvr_swap_chain* swap_chain, int32_t index,
- gvr_sizei size) {
- if (!VerifyBufferIndex("gvr_swap_chain_resize_buffer", swap_chain, index))
- return;
-
- gvr_buffer& buf = swap_chain->buffers_[index];
- if (size != buf.spec.size)
- buf.requested_size = size;
- else
- buf.requested_size = {-1, -1};
-}
-
-gvr_frame* gvr_swap_chain_acquire_frame(gvr_swap_chain* swap_chain) {
- if (!swap_chain)
- return nullptr;
-
- if (swap_chain->frame_acquired_) {
- gvr_set_error(swap_chain->context, GVR_ERROR_NO_FRAME_AVAILABLE);
- return nullptr;
- }
-
- // Resize buffers if necessary
- for (int i = 0; i < static_cast<int>(swap_chain->buffers_.size()); ++i) {
- gvr_buffer& buf = swap_chain->buffers_[i];
- if (buf.requested_size != gvr_sizei{-1, -1}) {
- if (!SwapChainResizeBuffer(swap_chain, i))
- return nullptr;
- }
- }
-
- // Only call gvr_wait_next_frame() if the app didn't call it already.
- if (!swap_chain->wait_next_frame_called_by_app_)
- WaitNextFrame(swap_chain, 0, nullptr, /*called_by_app*/ false);
-
- int ret = dvrBeginRenderFrame(swap_chain->graphics_context_);
- if (ret < 0) {
- gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
- return nullptr;
- }
-
- swap_chain->frame_acquired_ = true;
- return GetFrameFromSwapChain(swap_chain);
-}
-
-void gvr_frame_bind_buffer(gvr_frame* frame, int32_t index) {
- gvr_swap_chain* swap_chain = GetSwapChainForFrame(frame);
- if (!VerifyBufferIndex("gvr_frame_bind_buffer", swap_chain, index))
- return;
- glBindFramebuffer(GL_FRAMEBUFFER, swap_chain->buffers_[index].frame_buffer);
-}
-
-void gvr_frame_unbind(gvr_frame* /* frame */) {
- glBindFramebuffer(GL_FRAMEBUFFER, 0);
-}
-
-gvr_sizei gvr_frame_get_buffer_size(const gvr_frame* frame, int32_t index) {
- const gvr_swap_chain* swap_chain = GetSwapChainForFrame(frame);
- if (!VerifyBufferIndex("gvr_frame_get_buffer_size", swap_chain, index))
- return gvr_sizei{0, 0};
- return swap_chain->buffers_[index].spec.size;
-}
-
-int32_t gvr_frame_get_framebuffer_object(const gvr_frame* frame,
- int32_t index) {
- const gvr_swap_chain* swap_chain = GetSwapChainForFrame(frame);
- if (!VerifyBufferIndex("gvr_frame_get_framebuffer_object", swap_chain, index))
- return 0;
- return swap_chain->buffers_[index].frame_buffer;
-}
-
-void gvr_frame_submit(gvr_frame** frame, const gvr_buffer_viewport_list* list,
- gvr_mat4f head_space_from_start_space) {
- if (!frame)
- return;
-
- gvr_swap_chain* swap_chain = GetSwapChainForFrame(*frame);
-
- if (!swap_chain->frame_acquired_) {
- ALOGE("Frame was never acquired before being submitted");
- gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
- return;
- }
-
- *frame = nullptr;
- swap_chain->frame_acquired_ = false;
-
- // Currently, support for arbitrary buffer viewport configs is very limited.
- // We assume that the first two viewports have to be the recommended color
- // buffer viewports, followed by pairs of external external buffer viewports
- // for video rendering.
- gvr_buffer_viewport_list supported_viewports;
- gvr_get_recommended_buffer_viewports(swap_chain->context,
- &supported_viewports);
- for (size_t i = 0; i < supported_viewports.viewports.size(); ++i) {
- if (i >= list->viewports.size() ||
- supported_viewports.viewports[i] != list->viewports[i]) {
- ALOGE("Custom viewport configurations are not fully supported.");
- gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
- return;
- }
- }
-
- for (size_t i = supported_viewports.viewports.size();
- i < list->viewports.size(); ++i) {
- int32_t external_surface_id = list->viewports[i].external_surface_id;
- // Ignore additional custom buffer viewport for now, only those buffer
- // viewports backed by external surfaces are supported.
- // TODO(b/31442094, b/31771861, 28954457) Add full GVR buffer viewport
- // support.
- if (external_surface_id == GVR_EXTERNAL_SURFACE_ID_NONE)
- continue;
-
- auto surface_it = swap_chain->external_surfaces_.find(external_surface_id);
- if (surface_it == swap_chain->external_surfaces_.end()) {
- ALOGE("Cannot find external_surface by id: %d.", external_surface_id);
- gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
- return;
- }
-
- // Pass the transfrom matrix of video mesh to displayd.
- dvrGraphicsVideoMeshSurfacePresent(
- swap_chain->graphics_context_, surface_it->second->video_surface,
- list->viewports[i].eye,
- GvrToEigenMatrix(list->viewports[i].transform).data());
- }
-
- float32x4_t pose_orientation, pose_translation;
- GvrToDvrPose(head_space_from_start_space, &pose_orientation,
- &pose_translation);
- int ret = dvrSetEdsPose(swap_chain->graphics_context_, pose_orientation,
- pose_translation);
- if (ret < 0)
- gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
-
- ret = dvrPresent(swap_chain->graphics_context_);
- if (ret < 0) {
- gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
- return;
- }
-}
-
-void gvr_bind_default_framebuffer(gvr_context* /* gvr */) {
- glBindFramebuffer(GL_FRAMEBUFFER, 0);
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Head tracking
-/////////////////////////////////////////////////////////////////////////////
-
-gvr_clock_time_point gvr_get_time_point_now() {
- return gvr_clock_time_point{GetSystemClockNs()};
-}
-
-gvr_mat4f gvr_get_head_space_from_start_space_rotation(
- const gvr_context* gvr, const gvr_clock_time_point /* time */) {
- // TODO(steventhomas): Implement prediction according to the supplied time
- // value.
- return gvr->force_6dof_ ? gvr->next_frame_6dof_pose_
- : Gvr6dofTo3dof(gvr->next_frame_6dof_pose_);
-}
-
-gvr_mat4f gvr_apply_neck_model(const gvr_context* /* gvr */,
- gvr_mat4f head_space_from_start_space_rotation,
- float /* factor */) {
- // TODO(leandrogracia): this needs to be properly implemented.
- ALOGE("gvr_apply_neck_model not implemented.");
- return head_space_from_start_space_rotation;
-}
-
-// This is used to turn off sensors to save power. Not relevant for our all in
-// one device.
-void gvr_pause_tracking(gvr_context* /* gvr */) {}
-
-// This is used to turn on sensors. Not relevant for our all in one device.
-void gvr_resume_tracking(gvr_context* /* gvr */) {}
-
-void gvr_reset_tracking(gvr_context* gvr) {
- // TODO(leandrogracia): this needs to be properly implemented.
- ALOGE("gvr_reset_tracking not implemented.");
- gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-}
-
-void gvr_recenter_tracking(gvr_context* gvr) {
- // TODO(leandrogracia): this needs to be properly implemented.
- ALOGE("gvr_recenter_tracking not implemented.");
- gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Head mounted display
-/////////////////////////////////////////////////////////////////////////////
-
-bool gvr_set_default_viewer_profile(gvr_context* gvr,
- const char* /* viewer_profile_uri */) {
- // TODO(leandrogracia): this needs to be properly implemented.
- ALOGE("gvr_set_default_viewer_profile not implemented.");
- gvr_set_error(gvr, GVR_ERROR_INTERNAL);
- return false;
-}
-
-void gvr_refresh_viewer_profile(gvr_context* /* gvr */) {}
-
-const char* gvr_get_viewer_vendor(const gvr_context* /* gvr */) {
- return kViewerVendor;
-}
-
-const char* gvr_get_viewer_model(const gvr_context* /* gvr */) {
- return kViewerModel;
-}
-
-int32_t gvr_get_viewer_type(const gvr_context* /* gvr */) {
- // TODO(leandrogracia): this needs to be properly implemented.
- // In this case, we will probably need to define a new viewer type that
- // has 6DoF support.
- return GVR_VIEWER_TYPE_DAYDREAM;
-}
-
-gvr_mat4f gvr_get_eye_from_head_matrix(const gvr_context* gvr,
- const int32_t eye) {
- float eye_mult = eye == GVR_LEFT_EYE ? 1 : -1;
- return GvrTranslationMatrix(
- .5f * eye_mult * gvr->display_metrics_.inter_lens_distance_m, 0, 0);
-}
-
-gvr_recti gvr_get_window_bounds(const gvr_context* gvr) {
- // Our app windows are always full screen
- gvr_sizei screen_size = gvr_get_screen_target_size(gvr);
- return gvr_recti{0, screen_size.width, 0, screen_size.height};
-}
-
-void gvr_compute_distorted_point(const gvr_context* /* gvr */,
- const int32_t /* eye */,
- const gvr_vec2f /* uv_in */,
- gvr_vec2f /* uv_out */[3]) {
- // TODO(leandrogracia): this needs to be properly implemented.
- ALOGE("gvr_compute_distorted_point not implemented.");
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// GVR API extension (from gvr_ext.h)
-/////////////////////////////////////////////////////////////////////////////
-
-gvr_frame_schedule* gvr_frame_schedule_create() {
- return new gvr_frame_schedule;
-}
-
-void gvr_frame_schedule_destroy(gvr_frame_schedule** schedule) {
- if (!schedule || !(*schedule)) {
- ALOGW("gvr_frame_schedule_destroy: Invalid frame schedule pointer.");
- return;
- }
- delete *schedule;
- *schedule = nullptr;
-}
-
-uint32_t gvr_frame_schedule_get_vsync_count(gvr_frame_schedule* schedule) {
- return schedule->vsync_count;
-}
-
-gvr_clock_time_point gvr_frame_schedule_get_scheduled_finish(
- gvr_frame_schedule* schedule) {
- return schedule->scheduled_finish;
-}
-
-void gvr_wait_next_frame(gvr_swap_chain* swap_chain, int64_t start_delay_nanos,
- gvr_frame_schedule* out_next_frame_schedule) {
- WaitNextFrame(swap_chain, start_delay_nanos, out_next_frame_schedule,
- /*called_by_app*/ true);
-}
-
-gvr_mat4f gvr_get_6dof_head_pose_in_start_space(gvr_context* gvr,
- uint32_t vsync_count) {
- DvrPoseAsync pose;
- int ret = dvrPoseGet(gvr->pose_client_, vsync_count, &pose);
- if (ret < 0) {
- ALOGW("dvrPoseGet failed: %d", ret);
- gvr_set_error(gvr, GVR_ERROR_INTERNAL);
- return GvrIdentityMatrix();
- }
-
- return PosefToGvrMatrix(ToPosef(pose));
-}
-
-gvr_mat4f gvr_get_head_space_from_start_space_pose(
- gvr_context* gvr, const gvr_clock_time_point /* time */) {
- // TODO(leandrogracia): implement prediction based on the provided time.
- // We need to do the same for the 3dof version too.
- return gvr->next_frame_6dof_pose_;
-}
-
-void gvr_swap_chain_set_z_order(const gvr_swap_chain* swap_chain, int z_order) {
- dvrGraphicsSurfaceSetZOrder(swap_chain->graphics_context_, z_order);
-}
-
-bool gvr_experimental_register_perf_event_callback(
- gvr_context* gvr, int* /* out_handle */, void* /* user_data */,
- void (* /* event_callback */)(void*, int, float)) {
- ALOGE("gvr_experimental_register_perf_event_callback not implemented.");
- gvr_set_error(gvr, GVR_ERROR_INTERNAL);
- return false;
-}
-
-bool gvr_experimental_unregister_perf_event_callback(gvr_context* gvr,
- int /* handle */) {
- ALOGE("gvr_experimental_unregister_perf_event_callback not implemented.");
- gvr_set_error(gvr, GVR_ERROR_INTERNAL);
- return false;
-}
-
-const gvr_analytics* gvr_get_analytics(gvr_context* gvr) {
- ALOGE("gvr_get_analytics not implemented.");
- gvr_set_error(gvr, GVR_ERROR_INTERNAL);
- return nullptr;
-}
-
-const gvr_analytics_sample* gvr_analytics_create_sample(
- const gvr_analytics* analytics) {
- ALOGE("gvr_analytics_create_sample not implemented.");
- return nullptr;
-}
-
-const char* gvr_analytics_sample_get_buffer(const gvr_analytics_sample* sample) {
- ALOGE("gvr_analytics_sample_get_buffer not implemented.");
- return nullptr;
-}
-
-size_t gvr_analytics_sample_get_buffer_length(
- const gvr_analytics_sample* sample) {
- ALOGE("gvr_analytics_sample_get_buffer_length not implemented.");
- return 0;
-}
-
-void gvr_analytics_destroy_sample(const gvr_analytics_sample** sample) {
- ALOGE("gvr_analytics_destroy_sample not implemented.");
-}
-
-bool gvr_user_prefs_get_performance_monitoring_enabled(
- const gvr_user_prefs* /* user_prefs */) {
- ALOGW("gvr_user_prefs_get_performance_monitoring_enabled not implemented.");
- return false;
-}
-
-void gvr_enable_context_sharing(gvr_context* gvr,
- gvr_egl_context_listener /* handler */,
- void* /* user_data */) {
- ALOGW("gvr_enable_context_sharing not implemented.");
- gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-}
-
-gvr_mat4f gvr_get_start_space_from_controller_space_pose(
- gvr_context* gvr, int controller_id,
- const gvr_clock_time_point /* time */) {
- if (controller_id < 0 || controller_id >= kControllerCount) {
- return GvrIdentityMatrix();
- }
-
- // TODO(leandrogracia): implement prediction based on the provided time.
- // We need to do the same for the 3dof version too.
- return gvr->next_frame_controller_pose_[controller_id];
-}
-
-gvr_external_surface* gvr_external_surface_create(gvr_context* context) {
- // A |gvr_external_surface| is bound to a DVR Graphics context at the
- // moment, which means we need an |gvr_swap_chain| created prior to the call
- // of |gvr_external_surface_create|. Check whether the current GVR context
- // has |gvr_swap_chain| created. Fail if there is no swap chain created
- // already.
- if (context->swap_chains_.empty()) {
- ALOGE("gvr_external_surface_create: No swapchain has been created yet.");
- return nullptr;
- }
-
- // In case there are multiple swap chains in the context, the first is
- // implicitly chosen. Actually, this should not happen as current scanline
- // racing based GVR implementation only supports single swap chain per GVR
- // context.
- if (context->swap_chains_.size() > 1) {
- ALOGW("gvr_external_surface_create: Multiple swap chains detected. "
- "Choosing the first one but this may yield unexpected results.");
- }
- gvr_swap_chain* swap_chain = context->swap_chains_[0];
- DvrVideoMeshSurface* video_surface = dvrGraphicsVideoMeshSurfaceCreate(
- swap_chain->graphics_context_);
-
- if (video_surface == nullptr) {
- ALOGE("gvr_external_surface_create: Failed to create video mesh surface.");
- return nullptr;
- }
-
- gvr_external_surface* surface = new gvr_external_surface;
- surface->id = swap_chain->next_external_surface_id_++;
- surface->swap_chain = swap_chain;
- surface->video_surface = video_surface;
-
- // Insert the surface into a lookup table in swap_chain. This will be
- // needed to by the external_surface_id in |gvr_buffer_viewport|.
- swap_chain->external_surfaces_.insert({surface->id, surface});
- return surface;
-}
-
-void gvr_external_surface_destroy(gvr_external_surface** surface) {
- if (!surface || !(*surface)) {
- ALOGW("gvr_external_surface_destroy: Invalid external surface pointer.");
- return;
- }
-
- (*surface)->swap_chain->external_surfaces_.erase((*surface)->id);
- if ((*surface)->video_surface != nullptr) {
- dvrGraphicsVideoMeshSurfaceDestroy((*surface)->video_surface);
- }
-
- delete *surface;
- *surface = nullptr;
-}
-
-void* gvr_external_surface_get_surface(const gvr_external_surface* surface) {
- LOG_ALWAYS_FATAL_IF(surface->swap_chain == nullptr ||
- surface->swap_chain->context == nullptr ||
- surface->swap_chain->context->jni_env_ == nullptr,
- "gvr_external_surface_get_surface: Surface must be "
- "constructed within a JNIEnv. Check |gvr_create| call.");
-
- LOG_ALWAYS_FATAL_IF(surface->video_surface == nullptr,
- "gvr_external_surface_get_surface: Invalid surface.");
-
- std::shared_ptr<android::dvr::ProducerQueue> producer_queue =
- surface->video_surface->client->GetProducerQueue();
- std::shared_ptr<android::dvr::BufferHubQueueCore> core =
- android::dvr::BufferHubQueueCore::Create(producer_queue);
-
- return android_view_Surface_createFromIGraphicBufferProducer(
- surface->swap_chain->context->jni_env_,
- new android::dvr::BufferHubQueueProducer(core));
-}
-
-int32_t gvr_external_surface_get_surface_id(
- const gvr_external_surface* surface) {
- return surface->id;
-}
diff --git a/libs/vr/libgvr/shim_gvr_controller.cpp b/libs/vr/libgvr/shim_gvr_controller.cpp
deleted file mode 100644
index 0f55903..0000000
--- a/libs/vr/libgvr/shim_gvr_controller.cpp
+++ /dev/null
@@ -1,168 +0,0 @@
-#define LOG_TAG "libgvr_controller_shim"
-
-#include <log/log.h>
-#include <vr/gvr/capi/include/gvr_controller.h>
-#include <vr/gvr/capi/include/gvr_types.h>
-
-gvr_controller_context* gvr_controller_create_and_init(int32_t options,
- gvr_context* context) {
- ALOGE("gvr_controller_create_and_init not implemented.");
- return nullptr;
-}
-
-gvr_controller_context* gvr_controller_create_and_init_android(
- JNIEnv* env, jobject android_context, jobject class_loader, int32_t options,
- gvr_context* context) {
- ALOGE("gvr_controller_create_and_init_android not implemented.");
- return nullptr;
-}
-
-void gvr_controller_destroy(gvr_controller_context** api) {
- ALOGE("gvr_controller_destroy not implemented.");
-}
-
-gvr_controller_state* gvr_controller_state_create() {
- ALOGE("gvr_controller_state_create not implemented.");
- return nullptr;
-}
-
-void gvr_controller_state_destroy(gvr_controller_state** state) {
- ALOGE("gvr_controller_state_destroy not implemented.");
-}
-
-void gvr_controller_state_update(gvr_controller_context* api, int32_t flags,
- gvr_controller_state* out_state) {
- ALOGE("gvr_controller_state_update not implemented.");
-}
-
-int64_t gvr_controller_state_get_last_button_timestamp(
- const gvr_controller_state* state) {
- ALOGE("gvr_controller_state_get_last_button_timestamp not implemented.");
- return 0;
-}
-
-bool gvr_controller_state_get_button_state(const gvr_controller_state* state,
- int32_t button) {
- ALOGE("gvr_controller_state_get_button_state not implemented.");
- return false;
-}
-
-bool gvr_controller_state_get_button_down(const gvr_controller_state* state,
- int32_t button) {
- ALOGE("gvr_controller_state_get_button_down not implemented.");
- return false;
-}
-
-bool gvr_controller_state_get_button_up(const gvr_controller_state* state,
- int32_t button) {
- ALOGE("gvr_controller_state_get_button_up not implemented.");
- return false;
-}
-
-bool gvr_controller_state_is_touching(const gvr_controller_state* state) {
- ALOGE("gvr_controller_state_is_touching not implemented.");
- return false;
-}
-
-gvr_vec2f gvr_controller_state_get_touch_pos(
- const gvr_controller_state* state) {
- ALOGE("gvr_controller_state_get_touch_pos not implemented.");
- return {0.0f, 0.0f};
-}
-
-bool gvr_controller_state_get_touch_down(const gvr_controller_state* state) {
- ALOGE("gvr_controller_state_get_touch_down not implemented.");
- return false;
-}
-
-bool gvr_controller_state_get_touch_up(const gvr_controller_state* state) {
- ALOGE("gvr_controller_state_get_touch_up not implemented.");
- return false;
-}
-
-int64_t gvr_controller_state_get_last_touch_timestamp(
- const gvr_controller_state* state) {
- ALOGE("gvr_controller_state_get_last_touch_timestamp not implemented.");
- return 0;
-}
-
-gvr_quatf gvr_controller_state_get_orientation(
- const gvr_controller_state* state) {
- ALOGE("gvr_controller_state_get_orientation not implemented.");
- return {0.0f, 0.0f, 0.0f, 0.0f};
-}
-
-int64_t gvr_controller_state_get_last_orientation_timestamp(
- const gvr_controller_state* state) {
- ALOGE("gvr_controller_state_get_last_orientation_timestamp not implemented.");
- return 0;
-}
-
-const char* gvr_controller_api_status_to_string(int32_t status) {
- ALOGE("gvr_controller_api_status_to_string not implemented.");
- return nullptr;
-}
-
-const char* gvr_controller_connection_state_to_string(int32_t state) {
- ALOGE("gvr_controller_connection_state_to_string not implemented.");
- return nullptr;
-}
-
-const char* gvr_controller_button_to_string(int32_t button) {
- ALOGE("gvr_controller_button_to_string not implemented.");
- return nullptr;
-}
-
-int32_t gvr_controller_get_default_options() {
- ALOGE("gvr_controller_get_default_options not implemented.");
- return 0;
-}
-
-void gvr_controller_pause(gvr_controller_context* api) {
- ALOGE("gvr_controller_pause not implemented.");
-}
-
-void gvr_controller_resume(gvr_controller_context* api) {
- ALOGE("gvr_controller_resume not implemented.");
-}
-
-int32_t gvr_controller_state_get_api_status(const gvr_controller_state* state) {
- return GVR_CONTROLLER_API_OK;
-}
-
-int32_t gvr_controller_state_get_connection_state(
- const gvr_controller_state* state) {
- return GVR_CONTROLLER_CONNECTED;
-}
-
-gvr_vec3f gvr_controller_state_get_gyro(const gvr_controller_state* state) {
- ALOGE("gvr_controller_state_get_gyro not implemented.");
- return {0.0, 0.0, 0.0};
-}
-
-gvr_vec3f gvr_controller_state_get_accel(const gvr_controller_state* state) {
- ALOGE("gvr_controller_state_get_accel not implemented.");
- return {0.0, 0.0, 0.0};
-}
-
-int64_t gvr_controller_state_get_last_gyro_timestamp(
- const gvr_controller_state* state) {
- ALOGE("gvr_controller_state_get_last_gyro_timestamp not implemented.");
- return 0;
-}
-
-int64_t gvr_controller_state_get_last_accel_timestamp(
- const gvr_controller_state* state) {
- ALOGE("gvr_controller_state_get_last_accel_timestamp not implemented.");
- return 0;
-}
-
-bool gvr_controller_state_get_recentered(const gvr_controller_state* state) {
- ALOGE("gvr_controller_state_get_recentered not implemented.");
- return false;
-}
-
-bool gvr_controller_state_get_recentering(const gvr_controller_state* state) {
- ALOGE("gvr_controller_state_get_recentering not implemented.");
- return false;
-}
diff --git a/libs/vr/libgvr/shim_gvr_private.cpp b/libs/vr/libgvr/shim_gvr_private.cpp
deleted file mode 100644
index 25a5110..0000000
--- a/libs/vr/libgvr/shim_gvr_private.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-#define LOG_TAG "libgvr_shim_private"
-
-#include <log/log.h>
-#include <private/dvr/display_rpc.h>
-#include <private/dvr/internal_types.h>
-#include <vr/gvr/capi/include/gvr.h>
-#include <vr/gvr/capi/src/gvr_private.h>
-
-#include <pdx/rpc/remote_method.h>
-#include "deviceparams/CardboardDevice.nolite.pb.h"
-
-bool gvr_set_async_reprojection_enabled(gvr_context* /* gvr */,
- bool /* enabled */) {
- return true;
-}
-
-void gvr_on_surface_created_reprojection_thread(gvr_context* /* gvr */) {}
-
-void gvr_render_reprojection_thread(gvr_context* /* gvr */) {}
-
-void gvr_on_pause_reprojection_thread(gvr_context* /* gvr */) {}
-
-void gvr_update_surface_reprojection_thread(
- gvr_context* /* gvr */, int32_t /* surface_id */, int32_t /* texture_id */,
- gvr_clock_time_point /* timestamp */, gvr_mat4f /* surface_transform */) {
- ALOGE("gvr_update_surface_reprojection_thread not implemented");
-}
-
-void gvr_remove_all_surfaces_reprojection_thread(gvr_context* /* gvr */) {
- ALOGE("gvr_remove_all_surfaces_reprojection_thread not implemented");
-}
-
-void gvr_reconnect_sensors(gvr_context* /* gvr */) {
- ALOGE("gvr_reconnect_sensors not implemented");
-}
-
-bool gvr_set_viewer_params(gvr_context* gvr,
- const void* serialized_viewer_params,
- size_t serialized_viewer_params_size_bytes) {
- std::string serialized_device_params_string(
- reinterpret_cast<const char*>(serialized_viewer_params),
- serialized_viewer_params_size_bytes);
- std::unique_ptr<proto::DeviceParams> device_params(new proto::DeviceParams);
- if (!device_params->ParseFromString(serialized_device_params_string)) {
- ALOGE("Invalid serialized Cardboard DeviceParams");
- return false;
- }
-
- android::dvr::ViewerParams viewer_params;
-
- viewer_params.screen_to_lens_distance =
- device_params->screen_to_lens_distance();
- viewer_params.inter_lens_distance = device_params->inter_lens_distance();
- for (int i = 0; i < device_params->left_eye_field_of_view_angles_size();
- ++i) {
- viewer_params.left_eye_field_of_view_angles.push_back(
- device_params->left_eye_field_of_view_angles(i));
- }
-
- viewer_params.vertical_alignment =
- static_cast<android::dvr::ViewerParams::VerticalAlignmentType>(
- device_params->vertical_alignment());
- viewer_params.tray_to_lens_distance = device_params->tray_to_lens_distance();
-
- // TODO(hendrikw) Leave the g and b coefficients empty until we support
- // chromatic aberration correction.
- for (int i = 0; i < device_params->distortion_coefficients_size(); ++i) {
- viewer_params.distortion_coefficients_r.push_back(
- device_params->distortion_coefficients(i));
- }
-
- viewer_params.screen_center_to_lens_distance =
- viewer_params.inter_lens_distance / 2.0;
- if (device_params->has_internal()) {
- for (int i = 0; i < device_params->internal().eye_orientations_size();
- ++i) {
- viewer_params.eye_orientations.push_back(
- static_cast<android::dvr::ViewerParams::EyeOrientation>(
- device_params->internal().eye_orientations(i)));
- }
-
- if (device_params->internal().has_screen_center_to_lens_distance())
- viewer_params.screen_center_to_lens_distance =
- device_params->internal().screen_center_to_lens_distance();
- }
-
- if (device_params->has_daydream_internal()) {
- viewer_params.daydream_internal.version =
- device_params->daydream_internal().version();
- for (int i = 0;
- i < device_params->daydream_internal().alignment_markers_size(); ++i) {
- viewer_params.daydream_internal.alignment_markers.push_back(
- {device_params->daydream_internal().alignment_markers(i).horizontal(),
- device_params->daydream_internal().alignment_markers(i).vertical()});
- }
- }
-
- gvr->display_client_->SetViewerParams(viewer_params);
- return true;
-}
-
-void gvr_set_lens_offset(gvr_context* /* gvr */, gvr_vec2f /* offset */) {
- ALOGE("gvr_set_lens_offset not implemented");
-}
-
-void gvr_set_display_metrics(gvr_context* /* gvr */,
- gvr_sizei /* size_pixels */,
- gvr_vec2f /* meters_per_pixel */,
- float /* border_size_meters */) {
- ALOGE("gvr_set_display_metrics not implemented");
-}
-
-void gvr_set_display_output_rotation(gvr_context* /* gvr */,
- int /* display_output_rotation */) {
- ALOGE("gvr_set_display_output_rotation not implemented");
-}
-
-float gvr_get_border_size_meters(const gvr_context* /* gvr */) {
- ALOGE("gvr_get_border_size_meters not implemented");
- return 0.0f;
-}
-
-bool gvr_check_surface_size_changed(gvr_context* /* gvr */) { return false; }
-
-gvr_sizei gvr_get_surface_size(const gvr_context* /* gvr */) {
- ALOGE("gvr_get_surface_size not implemented");
- return {0, 0};
-}
-
-void gvr_set_back_gesture_event_handler(gvr_context* /* gvr */,
- event_handler /* handler */,
- void* /* user_data */) {
- ALOGE("gvr_set_back_gesture_event_handler not implemented");
-}
-
-gvr_tracker_state* gvr_pause_tracking_get_state(gvr_context* /* gvr */) {
- ALOGE("gvr_pause_tracking_get_state not implemented");
- return nullptr;
-}
-
-void gvr_resume_tracking_set_state(gvr_context* /* gvr */,
- gvr_tracker_state* /* tracker_state */) {
- ALOGE("gvr_resume_tracking_set_state not implemented");
-}
-
-void gvr_set_ignore_manual_tracker_pause_resume(gvr_context* /* gvr */,
- bool /* should_ignore */) {
- ALOGE("gvr_set_ignore_manual_tracker_pause_resume not implemented");
-}
-
-gvr_tracker_state* gvr_tracker_state_create(
- const char* /* tracker_state_buffer */, size_t /* buf_size */) {
- ALOGE("gvr_tracker_state_create not implemented");
- return nullptr;
-}
-
-size_t gvr_tracker_state_get_buffer_size(
- gvr_tracker_state* /* tracker_state */) {
- ALOGE("gvr_tracker_state_get_buffer_size not implemented");
- return 0;
-}
-
-const char* gvr_tracker_state_get_buffer(
- gvr_tracker_state* /* tracker_state */) {
- ALOGE("gvr_tracker_state_get_buffer not implemented");
- return nullptr;
-}
-
-void gvr_tracker_state_destroy(gvr_tracker_state** /* tracker_state */) {
- ALOGE("gvr_tracker_state_destroy not implemented");
-}
-
-gvr_display_synchronizer* gvr_display_synchronizer_create() {
- // We don't actually support (or need) any of the synchronizer functionality,
- // but if we return null here the gvr setup code in the app fails. Instead
- // return a dummy object that does nothing, which allows gvr apps to work.
- return new gvr_display_synchronizer;
-}
-
-void gvr_display_synchronizer_destroy(gvr_display_synchronizer** synchronizer) {
- if (synchronizer) {
- delete *synchronizer;
- *synchronizer = nullptr;
- }
-}
-
-void gvr_display_synchronizer_reset(
- gvr_display_synchronizer* /* synchronizer */,
- int64_t /* expected_interval_nanos */, int64_t /* vsync_offset_nanos */) {}
-
-void gvr_display_synchronizer_update(
- gvr_display_synchronizer* /* synchronizer */,
- gvr_clock_time_point /* vsync_time */, int32_t /* rotation */) {}
-
-void gvr_set_display_synchronizer(
- gvr_context* /* gvr */, gvr_display_synchronizer* /* synchronizer */) {}
-
-void gvr_set_error(gvr_context* gvr, int32_t error_code) {
- if (gvr->last_error_ != GVR_ERROR_NONE) {
- ALOGW("Overwriting existing error code: %d (%s)", gvr->last_error_,
- gvr_get_error_string(gvr->last_error_));
- }
- gvr->last_error_ = error_code;
-}
-
-void gvr_pause(gvr_context* gvr) {
- if (gvr == nullptr) {
- ALOGW("gvr_pause called with a null gvr_context. This is a bug.");
- return;
- }
- for (gvr_swap_chain* swap_chain : gvr->swap_chains_) {
- if (swap_chain->graphics_context_)
- dvrGraphicsSurfaceSetVisible(swap_chain->graphics_context_, 0);
- }
-}
-
-void gvr_resume(gvr_context* gvr) {
- if (gvr == nullptr) {
- ALOGW("gvr_resume called with a null gvr_context. This is a bug.");
- return;
- }
- for (gvr_swap_chain* swap_chain : gvr->swap_chains_) {
- if (swap_chain->graphics_context_)
- dvrGraphicsSurfaceSetVisible(swap_chain->graphics_context_, 1);
- }
-}
-
-void gvr_dump_debug_data(gvr_context* /* gvr */) {}
-
-bool gvr_using_vr_display_service(gvr_context* /* gvr */) { return true; }
-
-void gvr_request_context_sharing(gvr_context* /* gvr */,
- gvr_egl_context_listener /* handler */,
- void* /* user_data */) {}
diff --git a/opengl/include/EGL/eglext.h b/opengl/include/EGL/eglext.h
index 5a81f7c..df84c93 100644
--- a/opengl/include/EGL/eglext.h
+++ b/opengl/include/EGL/eglext.h
@@ -642,24 +642,31 @@
#ifndef EGL_ANDROID_get_frame_timestamps
#define EGL_ANDROID_get_frame_timestamps 1
#define EGL_TIMESTAMPS_ANDROID 0x314D
-#define EGL_REQUESTED_PRESENT_TIME_ANDROID 0x314E
-#define EGL_RENDERING_COMPLETE_TIME_ANDROID 0x314F
-#define EGL_COMPOSITION_LATCH_TIME_ANDROID 0x3150
-#define EGL_FIRST_COMPOSITION_START_TIME_ANDROID 0x3151
-#define EGL_LAST_COMPOSITION_START_TIME_ANDROID 0x3152
-#define EGL_FIRST_COMPOSITION_FINISHED_TIME_ANDROID 0x3153
-#define EGL_DISPLAY_PRESENT_TIME_ANDROID 0x3154
-#define EGL_DISPLAY_RETIRE_TIME_ANDROID 0x3155
-#define EGL_DEQUEUE_READY_TIME_ANDROID 0x3156
-#define EGL_READS_DONE_TIME_ANDROID 0x3157
+#define EGL_COMPOSITE_DEADLINE_ANDROID 0x314E
+#define EGL_COMPOSITE_INTERVAL_ANDROID 0x314F
+#define EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID 0x3150
+#define EGL_REQUESTED_PRESENT_TIME_ANDROID 0x3151
+#define EGL_RENDERING_COMPLETE_TIME_ANDROID 0x3152
+#define EGL_COMPOSITION_LATCH_TIME_ANDROID 0x3153
+#define EGL_FIRST_COMPOSITION_START_TIME_ANDROID 0x3154
+#define EGL_LAST_COMPOSITION_START_TIME_ANDROID 0x3155
+#define EGL_FIRST_COMPOSITION_FINISHED_TIME_ANDROID 0x3156
+#define EGL_DISPLAY_PRESENT_TIME_ANDROID 0x3157
+#define EGL_DISPLAY_RETIRE_TIME_ANDROID 0x3158
+#define EGL_DEQUEUE_READY_TIME_ANDROID 0x3159
+#define EGL_READS_DONE_TIME_ANDROID 0x315A
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLBoolean eglGetNextFrameIdANDROID(EGLDisplay dpy, EGLSurface surface, EGLuint64KHR *frameId);
+EGLAPI EGLBoolean eglGetCompositorTimingANDROID(EGLDisplay dpy, EGLSurface surface, EGLint numTimestamps, const EGLint *names, EGLnsecsANDROID *values);
+EGLAPI EGLBoolean eglGetCompositorTimingSupportedANDROID(EGLDisplay dpy, EGLSurface surface, EGLint name);
EGLAPI EGLBoolean eglGetFrameTimestampsANDROID(EGLDisplay dpy, EGLSurface surface, EGLuint64KHR frameId, EGLint numTimestamps, const EGLint *timestamps, EGLnsecsANDROID *values);
-EGLAPI EGLBoolean eglQueryTimestampSupportedANDROID(EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
+EGLAPI EGLBoolean eglGetFrameTimestampSupportedANDROID(EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
#else
typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETNEXTFRAMEIDANDROID) (EGLDisplay dpy, EGLSurface surface, EGLuint64KHR *frameId);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETCOMPOSITORTIMINGANDROID) (EGLDisplay dpy, EGLSurface surface, EGLint numTimestamps, const EGLint *names, EGLnsecsANDROID *values);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROID) (EGLDisplay dpy, EGLSurface surface, EGLint name);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETFRAMETIMESTAMPSANDROID) (EGLDisplay dpy, EGLSurface surface, EGLuint64KHR frameId, EGLint numTimestamps, const EGLint *timestamps, EGLnsecsANDROID *values);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYTIMESTAMPSUPPORTEDANDROID) (EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROID) (EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
#endif
#endif
diff --git a/opengl/libs/EGL/eglApi.cpp b/opengl/libs/EGL/eglApi.cpp
index 2422177..ef3d7a3 100644
--- a/opengl/libs/EGL/eglApi.cpp
+++ b/opengl/libs/EGL/eglApi.cpp
@@ -57,8 +57,6 @@
using namespace android;
-#define ENABLE_EGL_ANDROID_GET_FRAME_TIMESTAMPS 0
-
// ----------------------------------------------------------------------------
namespace android {
@@ -90,9 +88,7 @@
"EGL_ANDROID_create_native_client_buffer "
"EGL_ANDROID_get_native_client_buffer "
"EGL_ANDROID_front_buffer_auto_refresh "
-#if ENABLE_EGL_ANDROID_GET_FRAME_TIMESTAMPS
"EGL_ANDROID_get_frame_timestamps "
-#endif
;
extern char const * const gExtensionString =
"EGL_KHR_image " // mandatory
@@ -224,10 +220,14 @@
// EGL_ANDROID_get_frame_timestamps
{ "eglGetNextFrameIdANDROID",
(__eglMustCastToProperFunctionPointerType)&eglGetNextFrameIdANDROID },
+ { "eglGetCompositorTimingANDROID",
+ (__eglMustCastToProperFunctionPointerType)&eglGetCompositorTimingANDROID },
+ { "eglGetCompositorTimingSupportedANDROID",
+ (__eglMustCastToProperFunctionPointerType)&eglGetCompositorTimingSupportedANDROID },
{ "eglGetFrameTimestampsANDROID",
(__eglMustCastToProperFunctionPointerType)&eglGetFrameTimestampsANDROID },
- { "eglQueryTimestampSupportedANDROID",
- (__eglMustCastToProperFunctionPointerType)&eglQueryTimestampSupportedANDROID },
+ { "eglGetFrameTimestampSupportedANDROID",
+ (__eglMustCastToProperFunctionPointerType)&eglGetFrameTimestampSupportedANDROID },
};
/*
@@ -1248,7 +1248,6 @@
setError(EGL_BAD_SURFACE, EGL_FALSE);
}
-#if ENABLE_EGL_ANDROID_GET_FRAME_TIMESTAMPS
if (attribute == EGL_TIMESTAMPS_ANDROID) {
if (!s->win.get()) {
return setError(EGL_BAD_SURFACE, EGL_FALSE);
@@ -1258,7 +1257,6 @@
return (err == NO_ERROR) ? EGL_TRUE :
setError(EGL_BAD_SURFACE, EGL_FALSE);
}
-#endif
if (s->cnx->egl.eglSurfaceAttrib) {
return s->cnx->egl.eglSurfaceAttrib(
@@ -2101,6 +2099,95 @@
return EGL_TRUE;
}
+EGLBoolean eglGetCompositorTimingANDROID(EGLDisplay dpy, EGLSurface surface,
+ EGLint numTimestamps, const EGLint *names, EGLnsecsANDROID *values)
+{
+ clearError();
+
+ const egl_display_ptr dp = validate_display(dpy);
+ if (!dp) {
+ return setError(EGL_BAD_DISPLAY, EGL_FALSE);
+ }
+
+ SurfaceRef _s(dp.get(), surface);
+ if (!_s.get()) {
+ return setError(EGL_BAD_SURFACE, EGL_FALSE);
+ }
+
+ egl_surface_t const * const s = get_surface(surface);
+
+ if (!s->win.get()) {
+ return setError(EGL_BAD_SURFACE, EGL_FALSE);
+ }
+
+ nsecs_t* compositeDeadline = nullptr;
+ nsecs_t* compositeInterval = nullptr;
+ nsecs_t* compositeToPresentLatency = nullptr;
+
+ for (int i = 0; i < numTimestamps; i++) {
+ switch (names[i]) {
+ case EGL_COMPOSITE_DEADLINE_ANDROID:
+ compositeDeadline = &values[i];
+ break;
+ case EGL_COMPOSITE_INTERVAL_ANDROID:
+ compositeInterval = &values[i];
+ break;
+ case EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID:
+ compositeToPresentLatency = &values[i];
+ break;
+ default:
+ return setError(EGL_BAD_PARAMETER, EGL_FALSE);
+ }
+ }
+
+ status_t ret = native_window_get_compositor_timing(s->win.get(),
+ compositeDeadline, compositeInterval, compositeToPresentLatency);
+
+ switch (ret) {
+ case NO_ERROR:
+ return EGL_TRUE;
+ case INVALID_OPERATION:
+ return setError(EGL_BAD_SURFACE, 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);
+ }
+}
+
+EGLBoolean eglGetCompositorTimingSupportedANDROID(
+ EGLDisplay dpy, EGLSurface surface, EGLint name)
+{
+ clearError();
+
+ const egl_display_ptr dp = validate_display(dpy);
+ if (!dp) {
+ return setError(EGL_BAD_DISPLAY, EGL_FALSE);
+ }
+
+ SurfaceRef _s(dp.get(), surface);
+ if (!_s.get()) {
+ return setError(EGL_BAD_SURFACE, 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);
+ }
+
+ switch (name) {
+ case EGL_COMPOSITE_DEADLINE_ANDROID:
+ case EGL_COMPOSITE_INTERVAL_ANDROID:
+ case EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID:
+ return EGL_TRUE;
+ default:
+ return EGL_FALSE;
+ }
+}
+
EGLBoolean eglGetFrameTimestampsANDROID(EGLDisplay dpy, EGLSurface surface,
EGLuint64KHR frameId, EGLint numTimestamps, const EGLint *timestamps,
EGLnsecsANDROID *values)
@@ -2193,8 +2280,8 @@
}
}
-EGLBoolean eglQueryTimestampSupportedANDROID(EGLDisplay dpy, EGLSurface surface,
- EGLint timestamp)
+EGLBoolean eglGetFrameTimestampSupportedANDROID(
+ EGLDisplay dpy, EGLSurface surface, EGLint timestamp)
{
clearError();
@@ -2216,7 +2303,9 @@
}
switch (timestamp) {
-#if ENABLE_EGL_ANDROID_GET_FRAME_TIMESTAMPS
+ case EGL_COMPOSITE_DEADLINE_ANDROID:
+ case EGL_COMPOSITE_INTERVAL_ANDROID:
+ case EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID:
case EGL_REQUESTED_PRESENT_TIME_ANDROID:
case EGL_RENDERING_COMPLETE_TIME_ANDROID:
case EGL_COMPOSITION_LATCH_TIME_ANDROID:
@@ -2238,7 +2327,6 @@
NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_RETIRE, &value);
return value == 0 ? EGL_FALSE : EGL_TRUE;
}
-#endif
default:
return EGL_FALSE;
}
diff --git a/opengl/specs/EGL_ANDROID_get_frame_timestamps.txt b/opengl/specs/EGL_ANDROID_get_frame_timestamps.txt
index f24d634..d0ed8e1 100644
--- a/opengl/specs/EGL_ANDROID_get_frame_timestamps.txt
+++ b/opengl/specs/EGL_ANDROID_get_frame_timestamps.txt
@@ -8,11 +8,19 @@
Contributors
+ Brian Anderson
+ Dan Stoza
Pablo Ceballos
+ Jesse Hall
+ Fabien Sanglard
Contact
+ Brian Anderson, Google Inc. (brianderson 'at' google.com)
+ Dan Stoza, Google Inc. (stoza 'at' google.com)
Pablo Ceballos, Google Inc. (pceballos 'at' google.com)
+ Jesse Hall, Google Inc. (jessehall 'at' google.com)
+ Fabien Sanglard, Google Inc. (sanglardf 'at' google.com)
Status
@@ -20,7 +28,7 @@
Version
- Version 1, May 31, 2016
+ Version 1, January 13, 2017
Number
@@ -60,26 +68,33 @@
EGLBoolean eglGetNextFrameIdANDROID(EGLDisplay dpy, EGLSurface surface,
EGLuint64KHR *frameId);
+ EGLBoolean eglGetCompositorTimingANDROID(EGLDisplay dpy,
+ EGLSurface surface, EGLint numTimestamps,
+ const EGLint *names, EGLnsecsANDROID *values);
+
EGLBoolean eglGetFrameTimestampsANDROID(EGLDisplay dpy, EGLSurface surface,
EGLuint64KHR frameId, EGLint numTimestamps,
const EGLint *timestamps, EGLnsecsANDROID *values);
- EGLBoolean eglQueryTimestampSupportedANDROID(EGLDisplay dpy, EGLSurface
- surface, EGLint timestamp);
+ EGLBoolean eglQueryTimestampSupportedANDROID(EGLDisplay dpy,
+ EGLSurface surface, EGLint timestamp);
New Tokens
EGL_TIMESTAMPS_ANDROID 0x314D
- EGL_REQUESTED_PRESENT_TIME_ANDROID 0x314E
- EGL_RENDERING_COMPLETE_TIME_ANDROID 0x314F
- EGL_COMPOSITION_LATCH_TIME_ANDROID 0x3150
- EGL_FIRST_COMPOSITION_START_TIME_ANDROID 0x3151
- EGL_LAST_COMPOSITION_START_TIME_ANDROID 0x3152
- EGL_FIRST_COMPOSITION_FINISHED_TIME_ANDROID 0x3153
- EGL_DISPLAY_PRESENT_TIME_ANDROID 0x3154
- EGL_DISPLAY_RETIRE_TIME_ANDROID 0x3155
- EGL_DEQUEUE_READY_TIME_ANDROID 0x3156
- EGL_READS_DONE_TIME_ANDROID 0x3157
+ EGL_COMPOSITE_DEADLINE_ANDROID 0x314E
+ EGL_COMPOSITE_INTERVAL_ANDROID 0x314F
+ EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID 0x3150
+ EGL_REQUESTED_PRESENT_TIME_ANDROID 0x3151
+ EGL_RENDERING_COMPLETE_TIME_ANDROID 0x3152
+ EGL_COMPOSITION_LATCH_TIME_ANDROID 0x3153
+ EGL_FIRST_COMPOSITION_START_TIME_ANDROID 0x3154
+ EGL_LAST_COMPOSITION_START_TIME_ANDROID 0x3155
+ EGL_FIRST_COMPOSITION_FINISHED_TIME_ANDROID 0x3156
+ EGL_DISPLAY_PRESENT_TIME_ANDROID 0x3157
+ EGL_DISPLAY_RETIRE_TIME_ANDROID 0x3158
+ EGL_DEQUEUE_READY_TIME_ANDROID 0x3159
+ EGL_READS_DONE_TIME_ANDROID 0x315A
Add to the list of supported tokens for eglSurfaceAttrib in section 3.5.6
"Surface Attributes", page 43:
@@ -89,7 +104,6 @@
enables timestamp collection, while a value of EGL_FALSE disables it. The
initial value is false. If surface is not a window surface this has no
effect.
-
Changes to Chapter 3 of the EGL 1.5 Specification (EGL Functions and Errors)
Add a new subsection under Section 3,
@@ -108,6 +122,29 @@
The function
+ EGLBoolean eglGetCompositorTimingANDROID(EGLDisplay dpy,
+ EGLSurface surface, EGLint numTimestamps,
+ const EGLint *names, EGLnsecsANDROID *values);
+
+ allows querying anticipated timestamps and durations related to the
+ composition and display of a window surface. The values are not associated
+ with a particular frame and can be retrieved before the first swap.
+
+ The eglGetCompositorTimingANDROID function takes an array of names to
+ query and returns their values in the corresponding indices of the values
+ array. The possible names that can be queried are:
+ - EGL_COMPOSITE_DEADLINE_ANDROID - The timestamp of the next time the
+ compositor will begin composition. This is effectively the deadline
+ for when the compositor must receive a newly queued frame.
+ - EGL_COMPOSITE_INTERVAL_ANDROID - The time delta between subsequent
+ composition events.
+ - EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID - The time delta between
+ the start of composition and the expected present time of that
+ composition. This can be used to estimate the latency of the
+ actual present time.
+
+ The function
+
EGLBoolean eglGetFrameTimestampsANDROID(EGLDisplay dpy,
EGLSurface surface, EGLuint64KHR frameId, EGLint numTimestamps,
const EGLint *timestamps, EGLnsecsANDROID *values);
@@ -124,6 +161,12 @@
supported will generate an EGL_BAD_PARAMETER error. If any error is
generated the function will return EGL_FALSE.
+ The application can poll for the timestamp of particular events by calling
+ eglGetFrameTimestamps over and over without needing to call any other EGL
+ function between calls. This is true even for the most recently swapped
+ frame. eglGetFrameTimestamps is thread safe and can be called from a
+ different thread than the swapping thread.
+
The eglGetFrameTimestampsANDROID function takes an array of timestamps to
query and returns timestamps in the corresponding indices of the values
array. The possible timestamps that can be queried are:
@@ -162,12 +205,19 @@
purpose of display/composition were completed for this frame.
Not all implementations may support all of the above timestamp queries. The
- function
+ functions
- EGLBoolean eglQueryTimestampSupportedANDROID(EGLDisplay dpy, EGLSurface
- surface, EGLint timestamp);
+ EGLBoolean eglGetCompositorTimingSupportedANDROID(EGLDisplay dpy,
+ EGLSurface surface, EGLint name);
- allows querying which timestamps are supported on the implementation."
+ and
+
+ EGLBoolean eglGetFrameTimestampsSupportedANDROID(EGLDisplay dpy,
+ EGLSurface surface, EGLint timestamp);
+
+ allows querying which values are supported by the implementations of
+ eglGetCompositoTimingANDROID and eglGetFrameTimestampsSupportedANDROID
+ respectively."
Issues
@@ -175,17 +225,21 @@
Revision History
-#1 (Pablo Ceballos, May 31, 2016)
- - Initial draft.
+#5 (Brian Anderson, January 13, 2017)
+ - Add eglGetCompositorTimingANDROID.
-#2 (Brian Anderson, July 22, 2016)
- - Replace EGL_QUEUE_TIME_ANDROID with EGL_REQUESTED_PRESENT_TIME_ANDROID.
- - Add DISPLAY_PRESENT_TIME_ANDROID.
+#4 (Brian Anderson, January 10, 2017)
+ - Use an absolute frameId rather than a relative framesAgo.
#3 (Brian Anderson, November 30, 2016)
- Add EGL_COMPOSITION_LATCH_TIME_ANDROID,
EGL_LAST_COMPOSITION_START_TIME_ANDROID, and
EGL_DEQUEUE_READY_TIME_ANDROID.
-#4 (Brian Anderson, January 10, 2017)
- - Use an absolute frameId rather than a relative framesAgo.
+#2 (Brian Anderson, July 22, 2016)
+ - Replace EGL_QUEUE_TIME_ANDROID with EGL_REQUESTED_PRESENT_TIME_ANDROID.
+ - Add DISPLAY_PRESENT_TIME_ANDROID.
+
+#1 (Pablo Ceballos, May 31, 2016)
+ - Initial draft.
+
diff --git a/opengl/specs/README b/opengl/specs/README
index 1853214..0c49023 100644
--- a/opengl/specs/README
+++ b/opengl/specs/README
@@ -20,14 +20,17 @@
0x314B EGL_IMAGE_CROP_BOTTOM_ANDROID (EGL_ANDROID_image_crop)
0x314C EGL_FRONT_BUFFER_AUTO_REFRESH_ANDROID (EGL_ANDROID_front_buffer_auto_refresh)
0x314D EGL_TIMESTAMPS_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x314E EGL_REQUESTED_PRESENT_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x314F EGL_RENDERING_COMPLETE_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x3150 EGL_COMPOSITION_LATCH_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x3151 EGL_FIRST_COMPOSITION_START_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x3152 EGL_LAST_COMPOSITION_START_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x3153 EGL_FIRST_COMPOSITION_FINISHED_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x3154 EGL_DISPLAY_PRESENT_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x3155 EGL_DISPLAY_RETIRE_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x3156 EGL_DEQUEUE_READY_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x3157 EGL_READS_DONE_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x3158 - 0x315F (unused)
+0x314E EGL_COMPOSITE_DEADLINE_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x314F EGL_COMPOSITE_INTERVAL_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3150 EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3151 EGL_REQUESTED_PRESENT_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3152 EGL_RENDERING_COMPLETE_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3153 EGL_COMPOSITION_LATCH_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3154 EGL_FIRST_COMPOSITION_START_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3155 EGL_LAST_COMPOSITION_START_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3156 EGL_FIRST_COMPOSITION_FINISHED_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3157 EGL_DISPLAY_PRESENT_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3158 EGL_DISPLAY_RETIRE_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3159 EGL_DEQUEUE_READY_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x315A EGL_READS_DONE_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x315B - 0x315F (unused)
diff --git a/services/audiomanager/IPlayer.cpp b/services/audiomanager/IPlayer.cpp
index 47edc4b..e8a9c34 100644
--- a/services/audiomanager/IPlayer.cpp
+++ b/services/audiomanager/IPlayer.cpp
@@ -35,6 +35,7 @@
SET_VOLUME = IBinder::FIRST_CALL_TRANSACTION + 3,
SET_PAN = IBinder::FIRST_CALL_TRANSACTION + 4,
SET_START_DELAY_MS = IBinder::FIRST_CALL_TRANSACTION + 5,
+ APPLY_VOLUME_SHAPER = IBinder::FIRST_CALL_TRANSACTION + 6,
};
class BpPlayer : public BpInterface<IPlayer>
@@ -88,6 +89,36 @@
data.writeInt32(delayMs);
remote()->transact(SET_START_DELAY_MS, data, &reply);
}
+
+ virtual void applyVolumeShaper(
+ const sp<VolumeShaper::Configuration>& configuration,
+ const sp<VolumeShaper::Operation>& operation) {
+ Parcel data, reply;
+ data.writeInterfaceToken(IPlayer::getInterfaceDescriptor());
+
+ status_t status = configuration.get() == nullptr
+ ? data.writeInt32(0)
+ : data.writeInt32(1)
+ ?: configuration->writeToParcel(&data);
+ if (status != NO_ERROR) {
+ ALOGW("applyVolumeShaper failed configuration parceling: %d", status);
+ return; // ignore error
+ }
+
+ status = operation.get() == nullptr
+ ? status = data.writeInt32(0)
+ : data.writeInt32(1)
+ ?: operation->writeToParcel(&data);
+ if (status != NO_ERROR) {
+ ALOGW("applyVolumeShaper failed operation parceling: %d", status);
+ return; // ignore error
+ }
+
+ status = remote()->transact(APPLY_VOLUME_SHAPER, data, &reply);
+
+ ALOGW_IF(status != NO_ERROR, "applyVolumeShaper failed transact: %d", status);
+ return; // one way transaction, ignore error
+ }
};
IMPLEMENT_META_INTERFACE(Player, "android.media.IPlayer");
@@ -128,6 +159,28 @@
setStartDelayMs(data.readInt32());
return NO_ERROR;
} break;
+ case APPLY_VOLUME_SHAPER: {
+ CHECK_INTERFACE(IPlayer, data, reply);
+ sp<VolumeShaper::Configuration> configuration;
+ sp<VolumeShaper::Operation> operation;
+
+ int32_t present;
+ status_t status = data.readInt32(&present);
+ if (status == NO_ERROR && present != 0) {
+ configuration = new VolumeShaper::Configuration();
+ status = configuration->readFromParcel(data);
+ }
+ status = status ?: data.readInt32(&present);
+ if (status == NO_ERROR && present != 0) {
+ operation = new VolumeShaper::Operation();
+ status = operation->readFromParcel(data);
+ }
+ if (status == NO_ERROR) {
+ // one way transaction, no error returned
+ applyVolumeShaper(configuration, operation);
+ }
+ return NO_ERROR;
+ } break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
diff --git a/services/surfaceflinger/Android.mk b/services/surfaceflinger/Android.mk
index aa8f189..9e81a8c 100644
--- a/services/surfaceflinger/Android.mk
+++ b/services/surfaceflinger/Android.mk
@@ -133,6 +133,7 @@
LOCAL_STATIC_LIBRARIES := \
libhwcomposer-command-buffer \
+ android.hardware.configstore-utils \
libtrace_proto \
libvkjson \
libvr_manager \
diff --git a/services/surfaceflinger/DisplayDevice.cpp b/services/surfaceflinger/DisplayDevice.cpp
index 6c18ef7..9af4402 100644
--- a/services/surfaceflinger/DisplayDevice.cpp
+++ b/services/surfaceflinger/DisplayDevice.cpp
@@ -47,6 +47,9 @@
#include "SurfaceFlinger.h"
#include "Layer.h"
+#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
+#include <configstore/Utils.h>
+
// ----------------------------------------------------------------------------
using namespace android;
// ----------------------------------------------------------------------------
@@ -57,6 +60,14 @@
static constexpr bool kEGLAndroidSwapRectangle = false;
#endif
+// retrieve triple buffer setting from configstore
+using namespace android::hardware::configstore;
+using namespace android::hardware::configstore::V1_0;
+
+static bool useTripleFramebuffer = getBool<
+ ISurfaceFlingerConfigs,
+ &ISurfaceFlingerConfigs::useTripleFramebuffer>(false);
+
#if !defined(EGL_EGLEXT_PROTOTYPES) || !defined(EGL_ANDROID_swap_rectangle)
// Dummy implementation in case it is missing.
inline void eglSetSwapRectangleANDROID (EGLDisplay, EGLSurface, EGLint, EGLint, EGLint, EGLint) {
@@ -165,9 +176,9 @@
// initialize the display orientation transform.
setProjection(DisplayState::eOrientationDefault, mViewport, mFrame);
-#ifdef NUM_FRAMEBUFFER_SURFACE_BUFFERS
- surface->allocateBuffers();
-#endif
+ if (useTripleFramebuffer) {
+ surface->allocateBuffers();
+ }
}
DisplayDevice::~DisplayDevice() {
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index 6e0a489..a854aec 100644
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -155,6 +155,10 @@
flinger->getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
#endif
mFrameTracker.setDisplayRefreshPeriod(displayPeriod);
+
+ CompositorTiming compositorTiming;
+ flinger->getCompositorTiming(&compositorTiming);
+ mFrameEventHistory.initializeCompositorTiming(compositorTiming);
}
void Layer::onFirstRef() {
@@ -1882,10 +1886,10 @@
return mQueuedFrames > 0 || mSidebandStreamChanged || mAutoRefresh;
}
-bool Layer::onPostComposition(
- const std::shared_ptr<FenceTime>& glDoneFence,
+bool Layer::onPostComposition(const std::shared_ptr<FenceTime>& glDoneFence,
const std::shared_ptr<FenceTime>& presentFence,
- const std::shared_ptr<FenceTime>& retireFence) {
+ const std::shared_ptr<FenceTime>& retireFence,
+ const CompositorTiming& compositorTiming) {
mAcquireTimeline.updateSignalTimes();
mReleaseTimeline.updateSignalTimes();
@@ -1898,7 +1902,7 @@
{
Mutex::Autolock lock(mFrameEventHistoryMutex);
mFrameEventHistory.addPostComposition(mCurrentFrameNumber,
- glDoneFence, presentFence);
+ glDoneFence, presentFence, compositorTiming);
mFrameEventHistory.addRetire(mPreviousFrameNumber,
retireFence);
}
diff --git a/services/surfaceflinger/Layer.h b/services/surfaceflinger/Layer.h
index 12166a8..8227dae 100644
--- a/services/surfaceflinger/Layer.h
+++ b/services/surfaceflinger/Layer.h
@@ -296,10 +296,10 @@
* called after composition.
* returns true if the layer latched a new buffer this frame.
*/
- bool onPostComposition(
- const std::shared_ptr<FenceTime>& glDoneFence,
+ bool onPostComposition(const std::shared_ptr<FenceTime>& glDoneFence,
const std::shared_ptr<FenceTime>& presentFence,
- const std::shared_ptr<FenceTime>& retireFence);
+ const std::shared_ptr<FenceTime>& retireFence,
+ const CompositorTiming& compositorTiming);
#ifdef USE_HWC2
// If a buffer was replaced this frame, release the former buffer
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index cbc209d..462e5a6 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -87,6 +87,7 @@
#include <cutils/compiler.h>
#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
+#include <configstore/Utils.h>
#define DISPLAY_COUNT 1
@@ -100,22 +101,9 @@
namespace android {
+using namespace android::hardware::configstore;
using namespace android::hardware::configstore::V1_0;
-static sp<ISurfaceFlingerConfigs> getConfigs() {
- static sp<ISurfaceFlingerConfigs> configs
- = ISurfaceFlingerConfigs::getService();
- return configs;
-}
-
-static int64_t getVsyncEventPhaseOffsetNs() {
- int64_t ret = 1000000; // default value
- getConfigs()->vsyncEventPhaseOffsetNs([&](OptionalInt64 value) {
- if (value.specified) ret = value.value;
- });
- return ret;
-}
-
// This is the phase offset in nanoseconds of the software vsync event
// relative to the vsync event reported by HWComposer. The software vsync
// event is when SurfaceFlinger and Choreographer-based applications run each
@@ -136,10 +124,12 @@
// the latency will end up being an additional vsync period, and animations
// will hiccup. Therefore, this latency should be tuned somewhat
// conservatively (or at least with awareness of the trade-off being made).
-static int64_t vsyncPhaseOffsetNs = getVsyncEventPhaseOffsetNs();
+static int64_t vsyncPhaseOffsetNs = getInt64<
+ ISurfaceFlingerConfigs,
+ &ISurfaceFlingerConfigs::vsyncEventPhaseOffsetNs>(1000000);
// This is the phase offset at which SurfaceFlinger's composition runs.
-static const int64_t sfVsyncPhaseOffsetNs = SF_VSYNC_EVENT_PHASE_OFFSET_NS;
+static constexpr int64_t sfVsyncPhaseOffsetNs = SF_VSYNC_EVENT_PHASE_OFFSET_NS;
// ---------------------------------------------------------------------------
@@ -1126,6 +1116,11 @@
}
}
+void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
+ std::lock_guard<std::mutex> lock(mCompositeTimingLock);
+ *compositorTiming = mCompositorTiming;
+}
+
void SurfaceFlinger::onHotplugReceived(int32_t disp, bool connected) {
ALOGV("onHotplugReceived(%d, %s)", disp, connected ? "true" : "false");
if (disp == DisplayDevice::DISPLAY_PRIMARY) {
@@ -1261,11 +1256,13 @@
ATRACE_CALL();
switch (what) {
case MessageQueue::INVALIDATE: {
- updateVrMode();
+ // TODO(eieio): Disabled until SELinux issues are resolved.
+ //updateVrMode();
bool frameMissed = !mHadClientComposition &&
mPreviousPresentFence != Fence::NO_FENCE &&
- mPreviousPresentFence->getSignalTime() == INT64_MAX;
+ (mPreviousPresentFence->getSignalTime() ==
+ Fence::SIGNAL_TIME_PENDING);
ATRACE_INT("FrameMissed", static_cast<int>(frameMissed));
if (mPropagateBackpressure && frameMissed) {
signalLayerUpdate();
@@ -1314,7 +1311,7 @@
setUpHWComposer();
doDebugFlashRegions();
doComposition();
- postComposition();
+ postComposition(refreshStartTime);
mPreviousPresentFence = mHwc->getPresentFence(HWC_DISPLAY_PRIMARY);
@@ -1389,7 +1386,61 @@
}
}
-void SurfaceFlinger::postComposition()
+void SurfaceFlinger::updateCompositorTiming(
+ nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime,
+ std::shared_ptr<FenceTime>& presentFenceTime) {
+ // Update queue of past composite+present times and determine the
+ // most recently known composite to present latency.
+ mCompositePresentTimes.push({compositeTime, presentFenceTime});
+ nsecs_t compositeToPresentLatency = -1;
+ while (!mCompositePresentTimes.empty()) {
+ CompositePresentTime& cpt = mCompositePresentTimes.front();
+ // Cached values should have been updated before calling this method,
+ // which helps avoid duplicate syscalls.
+ nsecs_t displayTime = cpt.display->getCachedSignalTime();
+ if (displayTime == Fence::SIGNAL_TIME_PENDING) {
+ break;
+ }
+ compositeToPresentLatency = displayTime - cpt.composite;
+ mCompositePresentTimes.pop();
+ }
+
+ // Don't let mCompositePresentTimes grow unbounded, just in case.
+ while (mCompositePresentTimes.size() > 16) {
+ mCompositePresentTimes.pop();
+ }
+
+ // Integer division and modulo round toward 0 not -inf, so we need to
+ // treat negative and positive offsets differently.
+ nsecs_t idealLatency = (sfVsyncPhaseOffsetNs >= 0) ?
+ (vsyncInterval - (sfVsyncPhaseOffsetNs % vsyncInterval)) :
+ ((-sfVsyncPhaseOffsetNs) % vsyncInterval);
+
+ // Snap the latency to a value that removes scheduling jitter from the
+ // composition and present times, which often have >1ms of jitter.
+ // Reducing jitter is important if an app attempts to extrapolate
+ // something (such as user input) to an accurate diasplay time.
+ // Snapping also allows an app to precisely calculate sfVsyncPhaseOffsetNs
+ // with (presentLatency % interval).
+ nsecs_t snappedCompositeToPresentLatency = -1;
+ if (compositeToPresentLatency >= 0) {
+ nsecs_t bias = vsyncInterval / 2;
+ int64_t extraVsyncs =
+ (compositeToPresentLatency - idealLatency + bias) /
+ vsyncInterval;
+ nsecs_t extraLatency = extraVsyncs * vsyncInterval;
+ snappedCompositeToPresentLatency = idealLatency + extraLatency;
+ }
+
+ std::lock_guard<std::mutex> lock(mCompositeTimingLock);
+ mCompositorTiming.deadline = vsyncPhase - idealLatency;
+ mCompositorTiming.interval = vsyncInterval;
+ if (snappedCompositeToPresentLatency >= 0) {
+ mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
+ }
+}
+
+void SurfaceFlinger::postComposition(nsecs_t refreshStartTime)
{
ATRACE_CALL();
ALOGV("postComposition");
@@ -1424,9 +1475,19 @@
} else {
retireFenceTime = &displayFenceTime;
}
+
+ nsecs_t vsyncPhase = mPrimaryDispSync.computeNextRefresh(0);
+ nsecs_t vsyncInterval = mPrimaryDispSync.getPeriod();
+
+ // We use the refreshStartTime which might be sampled a little later than
+ // when we started doing work for this frame, but that should be okay
+ // since updateCompositorTiming has snapping logic.
+ updateCompositorTiming(
+ vsyncPhase, vsyncInterval, refreshStartTime, displayFenceTime);
+
mDrawingState.traverseInZOrder([&](Layer* layer) {
bool frameLatched = layer->onPostComposition(glCompositionDoneFenceTime,
- *presentFenceTime, *retireFenceTime);
+ *presentFenceTime, *retireFenceTime, mCompositorTiming);
if (frameLatched) {
recordBufferingStats(layer->getName().string(),
layer->getOccupancyHistory(false));
@@ -1471,9 +1532,8 @@
if (mHasPoweredOff) {
mHasPoweredOff = false;
} else {
- nsecs_t period = mPrimaryDispSync.getPeriod();
nsecs_t elapsedTime = currentTime - mLastSwapTime;
- size_t numPeriods = static_cast<size_t>(elapsedTime / period);
+ size_t numPeriods = static_cast<size_t>(elapsedTime / vsyncInterval);
if (numPeriods < NUM_BUCKETS - 1) {
mFrameBuckets[numPeriods] += elapsedTime;
} else {
@@ -2876,6 +2936,11 @@
const auto& activeConfig = mHwc->getActiveConfig(HWC_DISPLAY_PRIMARY);
const nsecs_t period = activeConfig->getVsyncPeriod();
mAnimFrameTracker.setDisplayRefreshPeriod(period);
+
+ {
+ std::lock_guard<std::mutex> lock(mCompositeTimingLock);
+ mCompositorTiming.interval = period;
+ }
}
void SurfaceFlinger::initializeDisplays() {
diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h
index 02e4a0c..f52bd2d 100644
--- a/services/surfaceflinger/SurfaceFlinger.h
+++ b/services/surfaceflinger/SurfaceFlinger.h
@@ -42,6 +42,7 @@
#include <ui/PixelFormat.h>
#include <ui/mat4.h>
+#include <gui/FrameTimestamps.h>
#include <gui/ISurfaceComposer.h>
#include <gui/ISurfaceComposerClient.h>
#include <gui/OccupancyTracker.h>
@@ -65,7 +66,10 @@
#include "Effects/Daltonizer.h"
#include <map>
+#include <mutex>
+#include <queue>
#include <string>
+#include <utility>
namespace android {
@@ -413,7 +417,10 @@
Region& dirtyRegion, Region& opaqueRegion);
void preComposition(nsecs_t refreshStartTime);
- void postComposition();
+ void postComposition(nsecs_t refreshStartTime);
+ void updateCompositorTiming(
+ nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime,
+ std::shared_ptr<FenceTime>& presentFenceTime);
void rebuildLayerStacks();
void setUpHWComposer();
void doComposition();
@@ -434,12 +441,13 @@
/* ------------------------------------------------------------------------
* VSync
*/
- void enableHardwareVsync();
- void resyncToHardwareVsync(bool makeAvailable);
- void disableHardwareVsync(bool makeUnavailable);
+ void enableHardwareVsync();
+ void resyncToHardwareVsync(bool makeAvailable);
+ void disableHardwareVsync(bool makeUnavailable);
public:
- void resyncWithRateLimit();
+ void resyncWithRateLimit();
+ void getCompositorTiming(CompositorTiming* compositorTiming);
private:
/* ------------------------------------------------------------------------
@@ -581,6 +589,17 @@
bool mPrimaryHWVsyncEnabled;
bool mHWVsyncAvailable;
+ // protected by mCompositorTimingLock;
+ mutable std::mutex mCompositeTimingLock;
+ CompositorTiming mCompositorTiming;
+
+ // Only accessed from the main thread.
+ struct CompositePresentTime {
+ nsecs_t composite { -1 };
+ std::shared_ptr<FenceTime> display { FenceTime::NO_FENCE };
+ };
+ std::queue<CompositePresentTime> mCompositePresentTimes;
+
/* ------------------------------------------------------------------------
* Feature prototyping
*/
diff --git a/services/surfaceflinger/SurfaceFlinger_hwc1.cpp b/services/surfaceflinger/SurfaceFlinger_hwc1.cpp
index 40a27e8..477eb27 100644
--- a/services/surfaceflinger/SurfaceFlinger_hwc1.cpp
+++ b/services/surfaceflinger/SurfaceFlinger_hwc1.cpp
@@ -1036,6 +1036,11 @@
}
}
+void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
+ std::lock_guard<std::mutex> lock(mCompositeTimingLock);
+ *compositorTiming = mCompositorTiming;
+}
+
void SurfaceFlinger::onHotplugReceived(int type, bool connected) {
if (mEventThread == NULL) {
// This is a temporary workaround for b/7145521. A non-null pointer
@@ -1114,7 +1119,7 @@
setUpHWComposer();
doDebugFlashRegions();
doComposition();
- postComposition();
+ postComposition(refreshStartTime);
}
void SurfaceFlinger::doDebugFlashRegions()
@@ -1171,7 +1176,61 @@
}
}
-void SurfaceFlinger::postComposition()
+void SurfaceFlinger::updateCompositorTiming(
+ nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime,
+ std::shared_ptr<FenceTime>& presentFenceTime) {
+ // Update queue of past composite+present times and determine the
+ // most recently known composite to present latency.
+ mCompositePresentTimes.push({compositeTime, presentFenceTime});
+ nsecs_t compositeToPresentLatency = -1;
+ while (!mCompositePresentTimes.empty()) {
+ CompositePresentTime& cpt = mCompositePresentTimes.front();
+ // Cached values should have been updated before calling this method,
+ // which helps avoid duplicate syscalls.
+ nsecs_t displayTime = cpt.display->getCachedSignalTime();
+ if (displayTime == Fence::SIGNAL_TIME_PENDING) {
+ break;
+ }
+ compositeToPresentLatency = displayTime - cpt.composite;
+ mCompositePresentTimes.pop();
+ }
+
+ // Don't let mCompositePresentTimes grow unbounded, just in case.
+ while (mCompositePresentTimes.size() > 16) {
+ mCompositePresentTimes.pop();
+ }
+
+ // Integer division and modulo round toward 0 not -inf, so we need to
+ // treat negative and positive offsets differently.
+ nsecs_t idealLatency = (sfVsyncPhaseOffsetNs >= 0) ?
+ (vsyncInterval - (sfVsyncPhaseOffsetNs % vsyncInterval)) :
+ ((-sfVsyncPhaseOffsetNs) % vsyncInterval);
+
+ // Snap the latency to a value that removes scheduling jitter from the
+ // composition and present times, which often have >1ms of jitter.
+ // Reducing jitter is important if an app attempts to extrapolate
+ // something (such as user input) to an accurate diasplay time.
+ // Snapping also allows an app to precisely calculate sfVsyncPhaseOffsetNs
+ // with (presentLatency % interval).
+ nsecs_t snappedCompositeToPresentLatency = -1;
+ if (compositeToPresentLatency >= 0) {
+ nsecs_t bias = vsyncInterval / 2;
+ int64_t extraVsyncs =
+ (compositeToPresentLatency - idealLatency + bias) /
+ vsyncInterval;
+ nsecs_t extraLatency = extraVsyncs * vsyncInterval;
+ snappedCompositeToPresentLatency = idealLatency + extraLatency;
+ }
+
+ std::lock_guard<std::mutex> lock(mCompositeTimingLock);
+ mCompositorTiming.deadline = vsyncPhase - idealLatency;
+ mCompositorTiming.interval = vsyncInterval;
+ if (snappedCompositeToPresentLatency >= 0) {
+ mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
+ }
+}
+
+void SurfaceFlinger::postComposition(nsecs_t refreshStartTime)
{
const HWComposer& hwc = getHwComposer();
const sp<const DisplayDevice> hw(getDefaultDisplayDevice());
@@ -1192,10 +1251,18 @@
mDisplayTimeline.push(retireFenceTime);
mDisplayTimeline.updateSignalTimes();
+ nsecs_t vsyncPhase = mPrimaryDispSync.computeNextRefresh(0);
+ nsecs_t vsyncInterval = mPrimaryDispSync.getPeriod();
+
+ // We use the refreshStartTime which might be sampled a little later than
+ // when we started doing work for this frame, but that should be okay
+ // since updateCompositorTiming has snapping logic.
+ updateCompositorTiming(
+ vsyncPhase, vsyncInterval, refreshStartTime, retireFenceTime);
+
mDrawingState.traverseInZOrder([&](Layer* layer) {
bool frameLatched = layer->onPostComposition(glCompositionDoneFenceTime,
- presentFenceTime, retireFenceTime);
-
+ presentFenceTime, retireFenceTime, mCompositorTiming);
if (frameLatched) {
recordBufferingStats(layer->getName().string(),
layer->getOccupancyHistory(false));
diff --git a/services/vr/sensord/sensord.rc b/services/vr/sensord/sensord.rc
index 0311474..d868a7e 100644
--- a/services/vr/sensord/sensord.rc
+++ b/services/vr/sensord/sensord.rc
@@ -1,3 +1,7 @@
+on init
+ mkdir /dev/socket/pdx/system/vr/pose 0775 system system
+ mkdir /dev/socket/pdx/system/vr/sensors 0775 system system
+
service sensord /system/bin/sensord
class core
user system
diff --git a/services/vr/vr_window_manager/Android.mk b/services/vr/vr_window_manager/Android.mk
index 85f8e1f..e9552bc 100644
--- a/services/vr/vr_window_manager/Android.mk
+++ b/services/vr/vr_window_manager/Android.mk
@@ -37,33 +37,18 @@
LOCAL_MODULE_TAGS := optional
include $(BUILD_STATIC_LIBRARY)
-
native_src := \
application.cpp \
controller_mesh.cpp \
elbow_model.cpp \
hwc_callback.cpp \
reticle.cpp \
- render_thread.cpp \
shell_view.cpp \
surface_flinger_view.cpp \
texture.cpp \
vr_window_manager.cpp \
../virtual_touchpad/aidl/android/dvr/VirtualTouchpadService.aidl \
-src := \
- vr_window_manager_jni.cpp \
- application.cpp \
- controller_mesh.cpp \
- elbow_model.cpp \
- hwc_callback.cpp \
- reticle.cpp \
- render_thread.cpp \
- shell_view.cpp \
- surface_flinger_view.cpp \
- texture.cpp \
- ../virtual_touchpad/aidl/android/dvr/VirtualTouchpadService.aidl \
-
static_libs := \
libdisplay \
libbufferhub \
@@ -86,6 +71,7 @@
libbinder \
libinput \
libhardware \
+ libhwbinder \
libsync \
libutils \
libgui \
@@ -97,62 +83,19 @@
libhidlbase \
libhidltransport
-
-include $(CLEAR_VARS)
-LOCAL_SRC_FILES := $(src)
-LOCAL_STATIC_LIBRARIES := $(static_libs)
-LOCAL_SHARED_LIBRARIES := $(shared_libs)
-LOCAL_SHARED_LIBRARIES += libgvr
-LOCAL_STATIC_LIBRARIES += libgvr_ext
-LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES
-LOCAL_CFLAGS += -DEGL_EGLEXT_PROTOTYPES
-LOCAL_CFLAGS += -DLOG_TAG=\"VrWindowManager\"
-LOCAL_LDLIBS := -llog
-LOCAL_MODULE := libvr_window_manager_jni
-LOCAL_MODULE_TAGS := optional
-LOCAL_MODULE_TARGET_ARCH := arm arm64 x86 x86_64
-LOCAL_MULTILIB := 64
-LOCAL_CXX_STL := libc++_static
-include $(BUILD_SHARED_LIBRARY)
-
include $(CLEAR_VARS)
LOCAL_SRC_FILES := $(native_src)
LOCAL_STATIC_LIBRARIES := $(static_libs) libvrwm_binder
LOCAL_SHARED_LIBRARIES := $(shared_libs)
-LOCAL_SHARED_LIBRARIES += libgvr
-LOCAL_STATIC_LIBRARIES += libgvr_ext
LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES
LOCAL_CFLAGS += -DEGL_EGLEXT_PROTOTYPES
LOCAL_CFLAGS += -DLOG_TAG=\"VrWindowManager\"
LOCAL_LDLIBS := -llog
LOCAL_MODULE := vr_wm
LOCAL_MODULE_TAGS := optional
-LOCAL_MODULE_TARGET_ARCH := arm arm64 x86 x86_64
LOCAL_INIT_RC := vr_wm.rc
include $(BUILD_EXECUTABLE)
-include $(CLEAR_VARS)
-LOCAL_PACKAGE_NAME := VrWindowManager
-
-# We need to be priveleged to run as the system user, which is necessary for
-# getting hmd input events and doing input injection.
-LOCAL_CERTIFICATE := platform
-LOCAL_PRIVILEGED_MODULE := true
-
-LOCAL_MODULE_TAGS := optional
-LOCAL_SRC_FILES := $(call all-java-files-under, java)
-LOCAL_JNI_SHARED_LIBRARIES := libvr_window_manager_jni
-LOCAL_STATIC_JAVA_AAR_LIBRARIES := gvr_common_library_aar
-# gvr_common_library_aar depends on nano version of libprotobuf
-LOCAL_STATIC_JAVA_LIBRARIES := libprotobuf-java-nano
-# Make sure that libgvr's resources are loaded
-LOCAL_AAPT_FLAGS += --auto-add-overlay
-LOCAL_AAPT_FLAGS += --extra-packages com.google.vr.cardboard
-LOCAL_PROGUARD_FLAG_FILES := proguard.flags
-LOCAL_MODULE_TARGET_ARCH := arm arm64 x86 x86_64
-include $(BUILD_PACKAGE)
-
-
cmd_src := \
vr_wm_ctl.cpp \
aidl/android/service/vr/IVrWindowManager.aidl
diff --git a/services/vr/vr_window_manager/AndroidManifest.xml b/services/vr/vr_window_manager/AndroidManifest.xml
deleted file mode 100644
index d5008a3..0000000
--- a/services/vr/vr_window_manager/AndroidManifest.xml
+++ /dev/null
@@ -1,34 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
- package="com.google.vr.windowmanager"
- coreApp="true"
- android:sharedUserId="android.uid.system"
- android:versionCode="1"
- android:versionName="1.0" >
-
- <!-- The GVR SDK requires API 19+ and OpenGL ES 2+. -->
- <uses-sdk android:minSdkVersion="19" android:targetSdkVersion="24" />
- <uses-feature android:glEsVersion="0x00020000" android:required="true" />
-
- <!-- We need the DIAGNOSTIC permission to read HMD button events. DIAGNOSTIC
- ensures our process runs with the "input" group, so we can access
- /dev/input. See frameworks/base/data/etc/platform.xml for the permission
- to group mappings.
-
- TODO(steventhomas): We shouldn't use this DIAGNOSTIC permission. Figure
- out the correct way to get access to the HMD buttons.
- Bug: b/33253485. -->
- <uses-permission android:name="android.permission.DIAGNOSTIC"/>
- <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
-
- <application
- android:label="vr_window_manager"
- android:theme="@style/AppStyle">
- <service android:name=".VrWindowManagerService" />
- <receiver android:name="com.google.vr.windowmanager.BootCompletedReceiver">
- <intent-filter>
- <!-- action android:name="android.intent.action.BOOT_COMPLETED" / -->
- </intent-filter>
- </receiver>
- </application>
-</manifest>
diff --git a/services/vr/vr_window_manager/application.cpp b/services/vr/vr_window_manager/application.cpp
index 895f25f..33cd499 100644
--- a/services/vr/vr_window_manager/application.cpp
+++ b/services/vr/vr_window_manager/application.cpp
@@ -16,25 +16,18 @@
namespace android {
namespace dvr {
-Application::Application()
- : controller_api_status_logged_(false),
- controller_connection_state_logged_(false) {}
+Application::Application() {}
Application::~Application() {
}
-int Application::Initialize(JNIEnv* env, jobject app_context,
- jobject class_loader) {
+int Application::Initialize() {
dvrSetCpuPartition(0, "/application/performance");
bool is_right_handed = true; // TODO: retrieve setting from system
elbow_model_.Enable(ElbowModel::kDefaultNeckPosition, is_right_handed);
last_frame_time_ = std::chrono::system_clock::now();
- java_env_ = env;
- app_context_ = app_context;
- class_loader_ = class_loader;
-
return 0;
}
@@ -100,42 +93,10 @@
fov_[1] = FieldOfView(lens_info.right_fov[0], lens_info.right_fov[1],
lens_info.right_fov[2], lens_info.right_fov[3]);
- if (java_env_) {
- int ret = InitializeController();
- if (ret)
- return ret;
- }
-
- return 0;
-}
-
-int Application::InitializeController() {
- gvr_context_ = gvr::GvrApi::Create(java_env_, app_context_, class_loader_);
- if (gvr_context_ == nullptr) {
- ALOGE("Gvr context creation failed");
- return 1;
- }
-
- int32_t options = gvr_controller_get_default_options();
- options |= GVR_CONTROLLER_ENABLE_GYRO | GVR_CONTROLLER_ENABLE_ACCEL;
-
- controller_.reset(new gvr::ControllerApi);
- if (!controller_->Init(java_env_, app_context_, class_loader_, options,
- gvr_context_->cobj())) {
- ALOGE("Gvr controller init failed");
- return 1;
- }
-
- controller_state_.reset(new gvr::ControllerState);
-
return 0;
}
void Application::DeallocateResources() {
- gvr_context_.reset();
- controller_.reset();
- controller_state_.reset();
-
if (graphics_context_)
dvrGraphicsContextDestroy(graphics_context_);
@@ -162,8 +123,8 @@
break;
case MainThreadTask::EnteringVrMode:
if (!initialized_) {
- if (AllocateResources())
- ALOGE("Failed to allocate resources");
+ LOG_ALWAYS_FATAL_IF(AllocateResources(),
+ "Failed to allocate resources");
}
break;
case MainThreadTask::ExitingVrMode:
@@ -309,47 +270,6 @@
return;
}
}
-
- if (!controller_)
- return;
-
- controller_state_->Update(*controller_);
- gvr::ControllerApiStatus new_api_status = controller_state_->GetApiStatus();
- gvr::ControllerConnectionState new_connection_state =
- controller_state_->GetConnectionState();
-
- if (!controller_api_status_logged_) {
- controller_api_status_logged_ = true;
- ALOGI("Controller api status: %s",
- gvr::ControllerApi::ToString(new_api_status));
- } else if (new_api_status != controller_api_status_) {
- ALOGI("Controller api status changed: %s --> %s",
- gvr::ControllerApi::ToString(controller_api_status_),
- gvr::ControllerApi::ToString(new_api_status));
- }
-
- if (new_api_status == gvr::kControllerApiOk) {
- if (!controller_connection_state_logged_) {
- controller_connection_state_logged_ = true;
- ALOGI("Controller connection state: %s",
- gvr::ControllerApi::ToString(new_connection_state));
- } else if (new_connection_state != controller_connection_state_) {
- ALOGI("Controller connection state changed: %s --> %s",
- gvr::ControllerApi::ToString(controller_connection_state_),
- gvr::ControllerApi::ToString(new_connection_state));
- }
- } else {
- controller_connection_state_logged_ = false;
- }
-
- if (new_api_status == gvr::kControllerApiOk) {
- gvr_quatf orientation = controller_state_->GetOrientation();
- controller_orientation_ =
- quat(orientation.qw, orientation.qx, orientation.qy, orientation.qz);
- }
-
- controller_api_status_ = new_api_status;
- controller_connection_state_ = new_connection_state;
}
void Application::SetVisibility(bool visible) {
@@ -357,12 +277,6 @@
if (changed) {
is_visible_ = visible;
dvrGraphicsSurfaceSetVisible(graphics_context_, is_visible_);
- if (controller_) {
- if (is_visible_)
- controller_->Resume();
- else
- controller_->Pause();
- }
OnVisibilityChanged(is_visible_);
}
}
diff --git a/services/vr/vr_window_manager/application.h b/services/vr/vr_window_manager/application.h
index 0c6385f..c7aa4dd 100644
--- a/services/vr/vr_window_manager/application.h
+++ b/services/vr/vr_window_manager/application.h
@@ -1,15 +1,13 @@
#ifndef VR_WINDOW_MANAGER_APPLICATION_H_
#define VR_WINDOW_MANAGER_APPLICATION_H_
-#include <jni.h>
#include <memory>
#include <private/dvr/types.h>
#include <stdint.h>
-#include <vr/gvr/capi/include/gvr.h>
-#include <vr/gvr/capi/include/gvr_controller.h>
#include <chrono>
#include <mutex>
+#include <vector>
#include "controller_data_provider.h"
#include "elbow_model.h"
@@ -25,8 +23,7 @@
Application();
virtual ~Application();
- virtual int Initialize(JNIEnv* env, jobject app_context,
- jobject class_loader);
+ virtual int Initialize();
virtual int AllocateResources();
virtual void DeallocateResources();
@@ -59,8 +56,6 @@
void QueueTask(MainThreadTask task);
- int InitializeController();
-
DvrGraphicsContext* graphics_context_ = nullptr;
DvrPose* pose_client_ = nullptr;
@@ -69,15 +64,8 @@
FieldOfView fov_[2];
Posef last_pose_;
- std::unique_ptr<gvr::GvrApi> gvr_context_;
- std::unique_ptr<gvr::ControllerApi> controller_;
- std::unique_ptr<gvr::ControllerState> controller_state_;
- gvr::ControllerApiStatus controller_api_status_;
- gvr::ControllerConnectionState controller_connection_state_;
quat controller_orientation_;
bool shmem_controller_active_ = false;
- bool controller_api_status_logged_;
- bool controller_connection_state_logged_;
uint64_t shmem_controller_buttons_;
bool is_visible_ = false;
@@ -95,11 +83,6 @@
bool initialized_ = false;
std::vector<MainThreadTask> main_thread_tasks_;
- // Java Resources.
- JNIEnv* java_env_;
- jobject app_context_;
- jobject class_loader_;
-
// Controller data provider from shared memory buffer.
ControllerDataProvider* controller_data_provider_ = nullptr;
diff --git a/services/vr/vr_window_manager/composer/impl/vr_composer_view.cpp b/services/vr/vr_window_manager/composer/impl/vr_composer_view.cpp
index 5f8168d..1096a37 100644
--- a/services/vr/vr_window_manager/composer/impl/vr_composer_view.cpp
+++ b/services/vr/vr_window_manager/composer/impl/vr_composer_view.cpp
@@ -3,7 +3,9 @@
namespace android {
namespace dvr {
-VrComposerView::VrComposerView() : composer_view_(nullptr) {}
+VrComposerView::VrComposerView(
+ std::unique_ptr<VrComposerView::Callback> callback)
+ : composer_view_(nullptr), callback_(std::move(callback)) {}
VrComposerView::~VrComposerView() {
composer_view_->UnregisterObserver(this);
@@ -14,66 +16,19 @@
composer_view_->RegisterObserver(this);
}
-Return<void> VrComposerView::registerCallback(
- const sp<IVrComposerCallback>& callback) {
- callback_ = callback;
- return Void();
-}
-
-Return<void> VrComposerView::releaseFrame() {
+void VrComposerView::ReleaseFrame() {
+ LOG_ALWAYS_FATAL_IF(!composer_view_, "VrComposerView not initialized");
composer_view_->ReleaseFrame();
- return Void();
}
void VrComposerView::OnNewFrame(const ComposerView::Frame& frame) {
+ std::lock_guard<std::mutex> guard(mutex_);
if (!callback_.get()) {
- releaseFrame();
+ ReleaseFrame();
return;
}
- std::vector<IVrComposerCallback::Layer> layers;
- std::vector<native_handle_t*> fences;
- for (size_t i = 0; i < frame.size(); ++i) {
- native_handle_t* fence;
- if (frame[i].fence->isValid()) {
- fence = native_handle_create(1, 0);
- fence->data[0] = frame[i].fence->dup();
- } else {
- fence = native_handle_create(0, 0);
- }
- fences.push_back(fence);
-
- layers.push_back(IVrComposerCallback::Layer{
- .buffer = hidl_handle(frame[i].buffer->getNativeBuffer()->handle),
- .fence = hidl_handle(fence),
- .display_frame = frame[i].display_frame,
- .crop = frame[i].crop,
- .blend_mode= frame[i].blend_mode,
- .alpha = frame[i].alpha,
- .type = frame[i].type,
- .app_id = frame[i].app_id,
- });
- }
-
- auto status =
- callback_->onNewFrame(hidl_vec<IVrComposerCallback::Layer>(layers));
- if (!status.isOk()) {
- ALOGE("Failed to send onNewFrame: %s", status.description().c_str());
- releaseFrame();
- }
-
- for (size_t i = 0; i < fences.size(); ++i) {
- native_handle_close(fences[i]);
- native_handle_delete(fences[i]);
- }
-}
-
-VrComposerView* GetVrComposerViewFromIVrComposerView(IVrComposerView* view) {
- return static_cast<VrComposerView*>(view);
-}
-
-IVrComposerView* HIDL_FETCH_IVrComposerView(const char* name) {
- return new VrComposerView();
+ callback_->OnNewFrame(frame);
}
} // namespace dvr
diff --git a/services/vr/vr_window_manager/composer/impl/vr_composer_view.h b/services/vr/vr_window_manager/composer/impl/vr_composer_view.h
index 133bbc8..5a938e9 100644
--- a/services/vr/vr_window_manager/composer/impl/vr_composer_view.h
+++ b/services/vr/vr_window_manager/composer/impl/vr_composer_view.h
@@ -1,41 +1,37 @@
#ifndef VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_VIEW_H_
#define VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_VIEW_H_
-#include <android/dvr/composer/1.0/IVrComposerCallback.h>
-#include <android/dvr/composer/1.0/IVrComposerView.h>
+#include <memory>
#include "vr_hwc.h"
namespace android {
namespace dvr {
-using composer::V1_0::IVrComposerView;
-using composer::V1_0::IVrComposerCallback;
-
-class VrComposerView : public IVrComposerView, public ComposerView::Observer {
+class VrComposerView : public ComposerView::Observer {
public:
- VrComposerView();
+ class Callback {
+ public:
+ virtual ~Callback() = default;
+ virtual void OnNewFrame(const ComposerView::Frame& frame) = 0;
+ };
+
+ VrComposerView(std::unique_ptr<Callback> callback);
~VrComposerView() override;
void Initialize(ComposerView* composer_view);
- // IVrComposerView
- Return<void> registerCallback(const sp<IVrComposerCallback>& callback)
- override;
- Return<void> releaseFrame() override;
+ void ReleaseFrame();
// ComposerView::Observer
void OnNewFrame(const ComposerView::Frame& frame) override;
private:
ComposerView* composer_view_;
- sp<IVrComposerCallback> callback_;
+ std::unique_ptr<Callback> callback_;
+ std::mutex mutex_;
};
-VrComposerView* GetVrComposerViewFromIVrComposerView(IVrComposerView* view);
-
-IVrComposerView* HIDL_FETCH_IVrComposerView(const char* name);
-
} // namespace dvr
} // namespace android
diff --git a/services/vr/vr_window_manager/hwc_callback.cpp b/services/vr/vr_window_manager/hwc_callback.cpp
index 12a76d8..b29d175 100644
--- a/services/vr/vr_window_manager/hwc_callback.cpp
+++ b/services/vr/vr_window_manager/hwc_callback.cpp
@@ -12,11 +12,16 @@
namespace {
sp<GraphicBuffer> GetBufferFromHandle(const native_handle_t* handle) {
+ GraphicBufferMapper& mapper = GraphicBufferMapper::get();
+ if (mapper.registerBuffer(handle) != OK) {
+ ALOGE("Failed to register buffer");
+ return nullptr;
+ }
+
uint32_t width = 0, height = 0, stride = 0, layer_count = 1;
uint64_t producer_usage = 0, consumer_usage = 0;
int32_t format = 0;
- GraphicBufferMapper& mapper = GraphicBufferMapper::get();
if (mapper.getDimensions(handle, &width, &height) ||
mapper.getStride(handle, &stride) ||
mapper.getFormat(handle, &format) ||
@@ -33,10 +38,6 @@
sp<GraphicBuffer> buffer = new GraphicBuffer(
width, height, format, layer_count, producer_usage, consumer_usage,
stride, native_handle_clone(handle), true);
- if (mapper.registerBuffer(buffer.get()) != OK) {
- ALOGE("Failed to register buffer");
- return nullptr;
- }
return buffer;
}
@@ -62,27 +63,18 @@
} // namespace
-HwcCallback::HwcCallback(IVrComposerView* composer_view, Client* client)
- : composer_view_(composer_view),
- client_(client) {
- composer_view_->registerCallback(this);
+HwcCallback::HwcCallback(Client* client) : client_(client) {
}
HwcCallback::~HwcCallback() {
- composer_view_->registerCallback(nullptr);
}
-Return<void> HwcCallback::onNewFrame(
- const hidl_vec<IVrComposerCallback::Layer>& frame) {
-
+void HwcCallback::OnNewFrame(const ComposerView::Frame& frame) {
std::vector<HwcLayer> hwc_frame(frame.size());
for (size_t i = 0; i < frame.size(); ++i) {
- int fence = frame[i].fence.getNativeHandle()->numFds ?
- dup(frame[i].fence.getNativeHandle()->data[0]) : -1;
-
hwc_frame[i] = HwcLayer{
- .fence = new Fence(fence),
- .buffer = GetBufferFromHandle(frame[i].buffer.getNativeHandle()),
+ .fence = frame[i].fence,
+ .buffer = frame[i].buffer,
.crop = frame[i].crop,
.display_frame = frame[i].display_frame,
.blending = static_cast<int32_t>(frame[i].blend_mode),
@@ -92,10 +84,7 @@
};
}
- std::lock_guard<std::mutex> guard(mutex_);
client_->OnFrame(std::make_unique<Frame>(std::move(hwc_frame)));
-
- return Void();
}
HwcCallback::Frame::Frame(std::vector<HwcLayer>&& layers)
diff --git a/services/vr/vr_window_manager/hwc_callback.h b/services/vr/vr_window_manager/hwc_callback.h
index 05a889b..d4d6e66 100644
--- a/services/vr/vr_window_manager/hwc_callback.h
+++ b/services/vr/vr_window_manager/hwc_callback.h
@@ -6,8 +6,7 @@
#include <mutex>
#include <vector>
-#include <android/dvr/composer/1.0/IVrComposerCallback.h>
-#include <android/dvr/composer/1.0/IVrComposerView.h>
+#include <impl/vr_composer_view.h>
#include <impl/vr_hwc.h>
namespace android {
@@ -20,10 +19,7 @@
using Recti = ComposerView::ComposerLayer::Recti;
using Rectf = ComposerView::ComposerLayer::Rectf;
-using composer::V1_0::IVrComposerCallback;
-using composer::V1_0::IVrComposerView;
-
-class HwcCallback : public IVrComposerCallback {
+class HwcCallback : public VrComposerView::Callback {
public:
struct HwcLayer {
enum LayerType : uint32_t {
@@ -86,19 +82,12 @@
virtual void OnFrame(std::unique_ptr<Frame>) = 0;
};
- explicit HwcCallback(IVrComposerView* composer_view, Client* client);
+ explicit HwcCallback(Client* client);
~HwcCallback() override;
private:
- // This is the only method called on the binder thread. Everything else is
- // called on the render thread.
- Return<void> onNewFrame(const hidl_vec<IVrComposerCallback::Layer>& frame)
- override;
-
- IVrComposerView* composer_view_;
+ void OnNewFrame(const ComposerView::Frame& frame) override;
Client *client_;
- std::mutex mutex_;
-
HwcCallback(const HwcCallback&) = delete;
void operator=(const HwcCallback&) = delete;
diff --git a/services/vr/vr_window_manager/java/com/google/vr/windowmanager/BootCompletedReceiver.java b/services/vr/vr_window_manager/java/com/google/vr/windowmanager/BootCompletedReceiver.java
deleted file mode 100644
index 01d1bdb..0000000
--- a/services/vr/vr_window_manager/java/com/google/vr/windowmanager/BootCompletedReceiver.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package com.google.vr.windowmanager;
-
-import android.content.BroadcastReceiver;
-import android.content.Context;
-import android.content.Intent;
-import android.util.Log;
-
-public class BootCompletedReceiver extends BroadcastReceiver {
- private static final String TAG = BootCompletedReceiver.class.getSimpleName();
-
- @Override
- public void onReceive(Context context, Intent intent) {
- Log.i(TAG, "Starting VRWindowManager");
- Intent vrWindowManagerIntent = new Intent(context, VrWindowManagerService.class);
- context.startService(vrWindowManagerIntent);
- }
-}
diff --git a/services/vr/vr_window_manager/java/com/google/vr/windowmanager/VrWindowManagerService.java b/services/vr/vr_window_manager/java/com/google/vr/windowmanager/VrWindowManagerService.java
deleted file mode 100644
index 1d815ca..0000000
--- a/services/vr/vr_window_manager/java/com/google/vr/windowmanager/VrWindowManagerService.java
+++ /dev/null
@@ -1,87 +0,0 @@
-package com.google.vr.windowmanager;
-
-import android.app.Service;
-import android.content.BroadcastReceiver;
-import android.content.Context;
-import android.content.Intent;
-import android.content.IntentFilter;
-import android.os.Handler;
-import android.os.IBinder;
-import android.util.Log;
-
-public class VrWindowManagerService extends Service {
- private static final String TAG = VrWindowManagerService.class.getSimpleName();
- private long nativeVrWindowManager;
-
- // This is a temporary debugging tool for development only.
- // It allows us to show VrWindowManager in debug mode via command line.
- private final BroadcastReceiver debugReceiver = new BroadcastReceiver() {
- @Override
- public void onReceive(Context context, Intent intent) {
- String action = intent.getAction();
- if (action.equals("com.google.vr.windowmanager.intent.SHOW")) {
- nativeEnableDebug(nativeVrWindowManager);
- } else if (action.equals("com.google.vr.windowmanager.intent.HIDE")) {
- nativeDisableDebug(nativeVrWindowManager);
- } else if (action.equals("com.google.vr.windowmanager.intent.ENTER_VR")) {
- nativeEnterVrMode(nativeVrWindowManager);
- } else if (action.equals("com.google.vr.windowmanager.intent.EXIT_VR")) {
- nativeExitVrMode(nativeVrWindowManager);
- }
- }
- };
-
- static {
- System.loadLibrary("vr_window_manager_jni");
- }
-
- @Override
- public void onCreate() {
- super.onCreate();
- destroyRenderer();
- nativeVrWindowManager = nativeCreate(getClass().getClassLoader(), getApplicationContext());
- if (nativeVrWindowManager == 0) {
- Log.e(TAG, "Failed to create native renderer");
- }
-
- // For development, testing and debugging.
- IntentFilter filter = new IntentFilter();
- filter.addAction("com.google.vr.windowmanager.intent.SHOW");
- filter.addAction("com.google.vr.windowmanager.intent.HIDE");
- filter.addAction("com.google.vr.windowmanager.intent.ENTER_VR");
- filter.addAction("com.google.vr.windowmanager.intent.EXIT_VR");
- registerReceiver(debugReceiver, filter);
- }
-
- @Override
- public int onStartCommand(Intent intent, int flags, int startId) {
- return START_STICKY;
- }
-
- @Override
- public IBinder onBind(Intent intent) {
- Log.i(TAG, "Ignoring bind request");
- return null;
- }
-
- @Override
- public void onDestroy() {
- super.onDestroy();
- unregisterReceiver(debugReceiver);
- destroyRenderer();
- }
-
- private void destroyRenderer() {
- if (nativeVrWindowManager != 0) {
- nativeDestroy(nativeVrWindowManager);
- nativeVrWindowManager = 0;
- }
- }
-
- private native long nativeCreate(ClassLoader appClassLoader, Context context);
- private native void nativeDestroy(long nativeVrWindowManager);
- private native void nativeEnableDebug(long nativeVrWindowManager);
- private native void nativeDisableDebug(long nativeVrWindowManager);
- private native void nativeEnterVrMode(long nativeVrWindowManager);
- private native void nativeExitVrMode(long nativeVrWindowManager);
-}
diff --git a/services/vr/vr_window_manager/render_thread.cpp b/services/vr/vr_window_manager/render_thread.cpp
deleted file mode 100644
index b67a051..0000000
--- a/services/vr/vr_window_manager/render_thread.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-#include <jni.h>
-#include <log/log.h>
-#include <future>
-
-#include "render_thread.h"
-#include "shell_view.h"
-
-namespace android {
-namespace dvr {
-
-RenderThread::RenderThread(JNIEnv* env, jobject class_loader,
- jobject android_context)
- : jvm_(nullptr),
- class_loader_global_ref_(0),
- android_context_global_ref_(0),
- quit_(false) {
- env->GetJavaVM(&jvm_);
-
- // Create global references so we can access these objects on the render
- // thread
- class_loader_global_ref_ = env->NewGlobalRef(class_loader);
- android_context_global_ref_ = env->NewGlobalRef(android_context);
-
- std::promise<int> render_thread_init_result_promise;
- thread_ = std::thread([this, &render_thread_init_result_promise] {
- JNIEnv* render_thread_jni_env = nullptr;
- jvm_->AttachCurrentThread(&render_thread_jni_env, nullptr);
- RunRenderLoop(&render_thread_init_result_promise);
- jvm_->DetachCurrentThread();
- });
-
- // Wait to see if the render thread started successfully. If not bail.
- int render_thread_init_result =
- render_thread_init_result_promise.get_future().get();
- LOG_ALWAYS_FATAL_IF(render_thread_init_result != 0,
- "Failed initializing render thread. result=%d",
- render_thread_init_result);
-}
-
-RenderThread::~RenderThread() { Quit(); }
-
-void RenderThread::Quit() {
- if (thread_.joinable()) {
- quit_ = true;
- thread_.join();
- }
-
- JNIEnv* env = GetJniEnv();
- if (class_loader_global_ref_ != 0) {
- env->DeleteGlobalRef(class_loader_global_ref_);
- class_loader_global_ref_ = 0;
- }
- if (android_context_global_ref_ != 0) {
- env->DeleteGlobalRef(android_context_global_ref_);
- android_context_global_ref_ = 0;
- }
-}
-
-void RenderThread::EnableDebug(bool debug) { shell_view_.EnableDebug(debug); }
-
-void RenderThread::VrMode(bool mode) { shell_view_.VrMode(mode); }
-
-JNIEnv* RenderThread::GetJniEnv() {
- JNIEnv* env;
- jvm_->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6);
- return env;
-}
-
-void RenderThread::RunRenderLoop(
- std::promise<int>* init_result_promise) {
- // TODO(steventhomas): Create local refs to work around b/33251144. Remove
- // once that bug is fixed.
- JNIEnv* env = GetJniEnv();
- jobject class_loader = env->NewLocalRef(class_loader_global_ref_);
- jobject android_context = env->NewLocalRef(android_context_global_ref_);
-
- int init_result = shell_view_.Initialize(env, android_context, class_loader);
- init_result_promise->set_value(init_result);
- if (init_result == 0) {
- while (!quit_)
- shell_view_.DrawFrame();
- } else {
- ALOGE("Failed to initialize ShellView");
- }
-
- env->DeleteLocalRef(class_loader);
- env->DeleteLocalRef(android_context);
-}
-
-} // namespace dvr
-} // namespace android
diff --git a/services/vr/vr_window_manager/render_thread.h b/services/vr/vr_window_manager/render_thread.h
deleted file mode 100644
index e193643..0000000
--- a/services/vr/vr_window_manager/render_thread.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#ifndef VR_WINDOW_MANAGER_RENDER_THREAD_H_
-#define VR_WINDOW_MANAGER_RENDER_THREAD_H_
-
-#include <atomic>
-#include <future>
-#include <jni.h>
-#include <thread>
-
-#include "shell_view.h"
-
-namespace android {
-namespace dvr {
-
-class RenderThread {
- public:
- RenderThread(JNIEnv* env, jobject class_loader, jobject android_context);
- ~RenderThread();
- void Quit();
- void EnableDebug(bool debug);
- void VrMode(bool mode);
-
- RenderThread(const RenderThread&) = delete;
- void operator=(const RenderThread&) = delete;
-
- private:
- // Called by both the main thread and render thread. Will return the correct
- // JNIEnv for the current thread.
- JNIEnv* GetJniEnv();
-
- void RunRenderLoop(std::promise<int>* init_result_promise);
-
- // Accessed only by the main thread.
- std::thread thread_;
-
- // The vars below are accessed by both the main thread and the render thread.
- JavaVM* jvm_;
- jobject class_loader_global_ref_;
- jobject android_context_global_ref_;
- std::atomic_bool quit_;
-
- ShellView shell_view_;
-};
-
-} // namespace dvr
-} // namespace android
-
-#endif // VR_WINDOW_MANAGER_RENDER_THREAD_H_
diff --git a/services/vr/vr_window_manager/res/drawable-nodpi/vr_icon.png b/services/vr/vr_window_manager/res/drawable-nodpi/vr_icon.png
deleted file mode 100644
index 06f896d..0000000
--- a/services/vr/vr_window_manager/res/drawable-nodpi/vr_icon.png
+++ /dev/null
Binary files differ
diff --git a/services/vr/vr_window_manager/res/drawable-nodpi/vr_icon_background.png b/services/vr/vr_window_manager/res/drawable-nodpi/vr_icon_background.png
deleted file mode 100644
index d336da3..0000000
--- a/services/vr/vr_window_manager/res/drawable-nodpi/vr_icon_background.png
+++ /dev/null
Binary files differ
diff --git a/services/vr/vr_window_manager/res/values/styles.xml b/services/vr/vr_window_manager/res/values/styles.xml
deleted file mode 100644
index 8a1a74b..0000000
--- a/services/vr/vr_window_manager/res/values/styles.xml
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-<add-resource type="style" name="AppStyle"></add-resource>
-<style name="AppStyle"
- parent="@android:style/Theme.Holo.NoActionBar.Fullscreen">
- <item name="android:windowDisablePreview">true</item>
-</style>
-</resources>
diff --git a/services/vr/vr_window_manager/shell_view.cpp b/services/vr/vr_window_manager/shell_view.cpp
index 29ade64..84b8467 100644
--- a/services/vr/vr_window_manager/shell_view.cpp
+++ b/services/vr/vr_window_manager/shell_view.cpp
@@ -238,9 +238,8 @@
ShellView::~ShellView() {}
-int ShellView::Initialize(JNIEnv* env, jobject app_context,
- jobject class_loader) {
- int ret = Application::Initialize(env, app_context, class_loader);
+int ShellView::Initialize() {
+ int ret = Application::Initialize();
if (ret)
return ret;
@@ -604,10 +603,7 @@
vec3 pointer_location = last_pose_.GetPosition();
quat view_quaternion = last_pose_.GetRotation();
- bool gvr_api_active =
- controller_ && controller_api_status_ == gvr::kControllerApiOk;
-
- if (gvr_api_active || shmem_controller_active_) {
+ if (shmem_controller_active_) {
view_quaternion = controller_orientation_;
vec4 controller_location = controller_translate_ * vec4(0, 0, 0, 1);
pointer_location = vec3(controller_location.x(), controller_location.y(),
@@ -635,18 +631,6 @@
}
buttons >>= 4;
}
- } else if (controller_) {
- if (controller_state_->GetButtonDown(gvr::kControllerButtonClick))
- OnClick(true);
-
- if (controller_state_->GetButtonUp(gvr::kControllerButtonClick))
- OnClick(false);
-
- if (controller_state_->GetButtonDown(gvr::kControllerButtonApp))
- OnTouchpadButton(true, AMOTION_EVENT_BUTTON_BACK);
-
- if (controller_state_->GetButtonUp(gvr::kControllerButtonApp))
- OnTouchpadButton(false, AMOTION_EVENT_BUTTON_BACK);
}
}
@@ -676,7 +660,7 @@
void ShellView::DrawController(const mat4& perspective, const mat4& eye_matrix,
const mat4& head_matrix) {
- if (!controller_ && !shmem_controller_active_)
+ if (!shmem_controller_active_)
return;
controller_program_->Use();
diff --git a/services/vr/vr_window_manager/shell_view.h b/services/vr/vr_window_manager/shell_view.h
index 14ad0f3..39b5451 100644
--- a/services/vr/vr_window_manager/shell_view.h
+++ b/services/vr/vr_window_manager/shell_view.h
@@ -28,8 +28,7 @@
ShellView();
virtual ~ShellView();
- int Initialize(JNIEnv* env, jobject app_context,
- jobject class_loader) override;
+ int Initialize() override;
int AllocateResources() override;
void DeallocateResources() override;
diff --git a/services/vr/vr_window_manager/surface_flinger_view.cpp b/services/vr/vr_window_manager/surface_flinger_view.cpp
index b15d262..d42d3ff 100644
--- a/services/vr/vr_window_manager/surface_flinger_view.cpp
+++ b/services/vr/vr_window_manager/surface_flinger_view.cpp
@@ -1,6 +1,5 @@
#include "surface_flinger_view.h"
-#include <binder/IServiceManager.h>
#include <impl/vr_composer_view.h>
#include <private/dvr/native_buffer.h>
@@ -15,23 +14,33 @@
SurfaceFlingerView::~SurfaceFlingerView() {}
bool SurfaceFlingerView::Initialize(HwcCallback::Client *client) {
- const char instance[] = "DaydreamDisplay";
- composer_service_ = IVrComposerView::getService(instance);
- if (composer_service_ == nullptr) {
- ALOGE("Failed to initialize composer service");
+ const char vr_hwcomposer_name[] = "vr_hwcomposer";
+ vr_hwcomposer_ = HIDL_FETCH_IComposer(vr_hwcomposer_name);
+ if (!vr_hwcomposer_.get()) {
+ ALOGE("Failed to get vr_hwcomposer");
return false;
}
- if (!composer_service_->isRemote()) {
- ALOGE("Composer service is not remote");
+ if (vr_hwcomposer_->isRemote()) {
+ ALOGE("vr_hwcomposer service is remote");
return false;
}
+ const android::status_t vr_hwcomposer_status =
+ vr_hwcomposer_->registerAsService(vr_hwcomposer_name);
+ if (vr_hwcomposer_status != OK) {
+ ALOGE("Failed to register vr_hwcomposer service");
+ return false;
+ }
+
+ vr_composer_view_ =
+ std::make_unique<VrComposerView>(std::make_unique<HwcCallback>(client));
+ vr_composer_view_->Initialize(GetComposerViewFromIComposer(
+ vr_hwcomposer_.get()));
+
// TODO(dnicoara): Query this from the composer service.
width_ = 1920;
height_ = 1080;
-
- composer_observer_.reset(new HwcCallback(composer_service_.get(), client));
return true;
}
@@ -76,7 +85,7 @@
}
void SurfaceFlingerView::ReleaseFrame() {
- composer_service_->releaseFrame();
+ vr_composer_view_->ReleaseFrame();
}
} // namespace dvr
diff --git a/services/vr/vr_window_manager/surface_flinger_view.h b/services/vr/vr_window_manager/surface_flinger_view.h
index 2e36ec1..9c16192 100644
--- a/services/vr/vr_window_manager/surface_flinger_view.h
+++ b/services/vr/vr_window_manager/surface_flinger_view.h
@@ -1,10 +1,10 @@
#ifndef APPLICATIONS_EXPERIMENTS_SURFACE_FLINGER_DEMO_SURFACE_FLINGER_VIEW_H_
#define APPLICATIONS_EXPERIMENTS_SURFACE_FLINGER_DEMO_SURFACE_FLINGER_VIEW_H_
-#include <utils/StrongPointer.h>
-
#include <memory>
+#include <impl/vr_composer_view.h>
+
#include "hwc_callback.h"
namespace android {
@@ -39,9 +39,8 @@
void ReleaseFrame();
private:
- sp<IVrComposerView> composer_service_;
- std::unique_ptr<HwcCallback> composer_observer_;
-
+ sp<IComposer> vr_hwcomposer_;
+ std::unique_ptr<VrComposerView> vr_composer_view_;
int width_ = 0;
int height_ = 0;
diff --git a/services/vr/vr_window_manager/vr_window_manager.cpp b/services/vr/vr_window_manager/vr_window_manager.cpp
index c51ddee..6636dc5 100644
--- a/services/vr/vr_window_manager/vr_window_manager.cpp
+++ b/services/vr/vr_window_manager/vr_window_manager.cpp
@@ -1,33 +1,48 @@
#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
#include <binder/ProcessState.h>
+#include <hwbinder/IPCThreadState.h>
+#include <impl/vr_composer_view.h>
+#include <impl/vr_hwc.h>
#include "shell_view.h"
#include "vr_window_manager_binder.h"
+using namespace android;
+using namespace android::dvr;
+
int main(int /* argc */, char** /* argv */) {
- android::dvr::ShellView app;
- const int app_status = app.Initialize(nullptr, nullptr, nullptr);
- LOG_ALWAYS_FATAL_IF(app_status != 0, "failed to initialize: %d", app_status);
-
- android::service::vr::VrWindowManagerBinder service(app);
- const int status = service.Initialize();
- LOG_ALWAYS_FATAL_IF(status != 0, "initialization failed: %d", status);
-
android::ProcessState::self()->startThreadPool();
+ // ShellView needs to be created after vr_hwcomposer.
+ android::dvr::ShellView app;
+ const int app_status = app.Initialize();
+ LOG_ALWAYS_FATAL_IF(app_status != 0, "failed to initialize: %d", app_status);
+
+ // Create vr_wm_binder.
+ android::service::vr::VrWindowManagerBinder vr_wm_binder(app);
+ const int status = vr_wm_binder.Initialize();
+ LOG_ALWAYS_FATAL_IF(status != 0, "initialization failed: %d", status);
+
android::sp<android::IServiceManager> sm(android::defaultServiceManager());
- const android::status_t service_status = sm->addService(
- android::service::vr::VrWindowManagerBinder::SERVICE_NAME(), &service,
- false /*allowIsolated*/);
- LOG_ALWAYS_FATAL_IF(service_status != android::OK, "service not added: %d",
- static_cast<int>(service_status));
+ const android::status_t vr_wm_binder_status =
+ sm->addService(
+ android::service::vr::VrWindowManagerBinder::SERVICE_NAME(),
+ &vr_wm_binder, false /*allowIsolated*/);
+ LOG_ALWAYS_FATAL_IF(vr_wm_binder_status != android::OK,
+ "vr_wm_binder service not added: %d",
+ static_cast<int>(vr_wm_binder_status));
- app.SetControllerDataProvider(&service);
+ app.SetControllerDataProvider(&vr_wm_binder);
- while (true)
+ android::hardware::ProcessState::self()->startThreadPool();
+
+ while (true) {
app.DrawFrame();
+ }
+ android::hardware::IPCThreadState::self()->joinThreadPool();
android::IPCThreadState::self()->joinThreadPool();
+
return 0;
}
diff --git a/services/vr/vr_window_manager/vr_window_manager_jni.cpp b/services/vr/vr_window_manager/vr_window_manager_jni.cpp
deleted file mode 100644
index 49eaba1..0000000
--- a/services/vr/vr_window_manager/vr_window_manager_jni.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <jni.h>
-#include <log/log.h>
-
-#include <memory>
-
-#include "render_thread.h"
-
-#define JNI_METHOD(return_type, method_name) \
- JNIEXPORT return_type JNICALL \
- Java_com_google_vr_windowmanager_VrWindowManagerService_##method_name
-
-namespace {
-
-inline jlong jptr(android::dvr::RenderThread* native_vr_window_manager) {
- return reinterpret_cast<intptr_t>(native_vr_window_manager);
-}
-
-inline android::dvr::RenderThread* native(jlong ptr) {
- return reinterpret_cast<android::dvr::RenderThread*>(ptr);
-}
-
-} // namespace
-
-extern "C" {
-
-JNI_METHOD(jlong, nativeCreate)(JNIEnv* env, jclass /*clazz*/,
- jobject class_loader,
- jobject android_context) {
- return jptr(new android::dvr::RenderThread(
- env, class_loader, android_context));
-}
-
-JNI_METHOD(void, nativeDestroy)
-(JNIEnv* /*env*/, jclass /*clazz*/, jlong native_render_thread) {
- delete native(native_render_thread);
-}
-
-JNI_METHOD(void, nativeEnableDebug)
-(JNIEnv* /*env*/, jclass /*clazz*/, jlong native_render_thread) {
- native(native_render_thread)->EnableDebug(true);
-}
-
-JNI_METHOD(void, nativeDisableDebug)
-(JNIEnv* /*env*/, jclass /*clazz*/, jlong native_render_thread) {
- native(native_render_thread)->EnableDebug(false);
-}
-
-JNI_METHOD(void, nativeEnterVrMode)
-(JNIEnv* /*env*/, jclass /*clazz*/, jlong native_render_thread) {
- native(native_render_thread)->VrMode(true);
-}
-
-JNI_METHOD(void, nativeExitVrMode)
-(JNIEnv* /*env*/, jclass /*clazz*/, jlong native_render_thread) {
- native(native_render_thread)->VrMode(false);
-}
-
-} // extern "C"
diff --git a/services/vr/vr_window_manager/vr_wm.rc b/services/vr/vr_window_manager/vr_wm.rc
index 143b916..951515b 100644
--- a/services/vr/vr_window_manager/vr_wm.rc
+++ b/services/vr/vr_window_manager/vr_wm.rc
@@ -3,7 +3,3 @@
user system
group system graphics input
cpuset /system
- disabled
-
-on property:persist.daydream.vr_wm=1
- enable vr_wm
diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp
index a23056c..32f777d 100644
--- a/vulkan/libvulkan/driver.cpp
+++ b/vulkan/libvulkan/driver.cpp
@@ -739,10 +739,8 @@
const InstanceData& data = GetData(physicalDevice);
static const std::array<VkExtensionProperties, 2> loader_extensions = {{
// WSI extensions
-#if 0 // Remove this "#if 0" once the VK_KHR_incremental_present extension is ratified
{VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME,
VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION},
-#endif
{VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME,
VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION},
}};
