Merge changes I73599f62,I8526e671,I8ab696b1,Ib7950386,I0051c41a, ...
* changes:
SF: Introduce mock::NativeWindow
SF: Introduce mock::DisplaySurface
SF: Introduce mock::EventControlThread
SF: Separate EventControlThread into interface and impl
SF: Define mock::SurfaceInterceptor
SF: Separate SurfaceInterceptor into interface and impl
SF: Define mock::MessageQueue
SF: Separate MessageQueue into interface and impl
SF: libsurfaceflinger_unittest should skip SF ctor
SF: Switch to internal display setup
diff --git a/cmds/atrace/atrace.cpp b/cmds/atrace/atrace.cpp
index 898aa90..3d63971 100644
--- a/cmds/atrace/atrace.cpp
+++ b/cmds/atrace/atrace.cpp
@@ -774,22 +774,10 @@
return ok;
}
-// Set all the kernel tracing settings to the desired state for this trace
-// capture.
-static bool setUpTrace()
+static bool setUpUserspaceTracing()
{
bool ok = true;
- // Set up the tracing options.
- ok &= setCategoriesEnableFromFile(g_categoriesFile);
- ok &= setTraceOverwriteEnable(g_traceOverwrite);
- ok &= setTraceBufferSizeKB(g_traceBufferSizeKB);
- // TODO: Re-enable after stabilization
- //ok &= setCmdlineSize();
- ok &= setClock();
- ok &= setPrintTgidEnableIfPresent(true);
- ok &= setKernelTraceFuncs(g_kernelTraceFuncs);
-
// Set up the tags property.
uint64_t tags = 0;
for (size_t i = 0; i < arraysize(k_categories); i++) {
@@ -827,6 +815,37 @@
ok &= ServiceUtility::PokeServices();
}
+ return ok;
+}
+
+static void cleanUpUserspaceTracing()
+{
+ setTagsProperty(0);
+ clearAppProperties();
+ pokeBinderServices();
+
+ if (g_tracePdx) {
+ ServiceUtility::PokeServices();
+ }
+}
+
+
+// Set all the kernel tracing settings to the desired state for this trace
+// capture.
+static bool setUpKernelTracing()
+{
+ bool ok = true;
+
+ // Set up the tracing options.
+ ok &= setCategoriesEnableFromFile(g_categoriesFile);
+ ok &= setTraceOverwriteEnable(g_traceOverwrite);
+ ok &= setTraceBufferSizeKB(g_traceBufferSizeKB);
+ // TODO: Re-enable after stabilization
+ //ok &= setCmdlineSize();
+ ok &= setClock();
+ ok &= setPrintTgidEnableIfPresent(true);
+ ok &= setKernelTraceFuncs(g_kernelTraceFuncs);
+
// Disable all the sysfs enables. This is done as a separate loop from
// the enables to allow the same enable to exist in multiple categories.
ok &= disableKernelTraceEvents();
@@ -854,20 +873,11 @@
}
// Reset all the kernel tracing settings to their default state.
-static void cleanUpTrace()
+static void cleanUpKernelTracing()
{
// Disable all tracing that we're able to.
disableKernelTraceEvents();
- // Reset the system properties.
- setTagsProperty(0);
- clearAppProperties();
- pokeBinderServices();
-
- if (g_tracePdx) {
- ServiceUtility::PokeServices();
- }
-
// Set the options back to their defaults.
setTraceOverwriteEnable(true);
setTraceBufferSizeKB(1);
@@ -875,7 +885,6 @@
setKernelTraceFuncs(NULL);
}
-
// Enable tracing in the kernel.
static bool startTrace()
{
@@ -1107,6 +1116,7 @@
bool traceStop = true;
bool traceDump = true;
bool traceStream = false;
+ bool onlyUserspace = false;
if (argc == 2 && 0 == strcmp(argv[1], "--help")) {
showHelp(argv[0]);
@@ -1122,12 +1132,13 @@
int ret;
int option_index = 0;
static struct option long_options[] = {
- {"async_start", no_argument, 0, 0 },
- {"async_stop", no_argument, 0, 0 },
- {"async_dump", no_argument, 0, 0 },
- {"list_categories", no_argument, 0, 0 },
- {"stream", no_argument, 0, 0 },
- { 0, 0, 0, 0 }
+ {"async_start", no_argument, 0, 0 },
+ {"async_stop", no_argument, 0, 0 },
+ {"async_dump", no_argument, 0, 0 },
+ {"only_userspace", no_argument, 0, 0 },
+ {"list_categories", no_argument, 0, 0 },
+ {"stream", no_argument, 0, 0 },
+ { 0, 0, 0, 0 }
};
ret = getopt_long(argc, argv, "a:b:cf:k:ns:t:zo:",
@@ -1197,6 +1208,8 @@
async = true;
traceStart = false;
traceStop = false;
+ } else if (!strcmp(long_options[option_index].name, "only_userspace")) {
+ onlyUserspace = true;
} else if (!strcmp(long_options[option_index].name, "stream")) {
traceStream = true;
traceDump = false;
@@ -1214,6 +1227,14 @@
}
}
+ if (onlyUserspace) {
+ if (!async || !(traceStart || traceStop)) {
+ fprintf(stderr, "--only_userspace can only be used with "
+ "--async_start or --async_stop\n");
+ exit(1);
+ }
+ }
+
registerSigHandler();
if (g_initialSleepSecs > 0) {
@@ -1221,11 +1242,19 @@
}
bool ok = true;
- ok &= setUpTrace();
- ok &= startTrace();
+
+ if (traceStart) {
+ ok &= setUpUserspaceTracing();
+ }
+
+ if (ok && traceStart && !onlyUserspace) {
+ ok &= setUpKernelTracing();
+ ok &= startTrace();
+ }
if (ok && traceStart) {
- if (!traceStream) {
+
+ if (!traceStream && !onlyUserspace) {
printf("capturing trace...");
fflush(stdout);
}
@@ -1235,7 +1264,8 @@
// contain entries from only one CPU can cause "begin" entries without a
// matching "end" entry to show up if a task gets migrated from one CPU to
// another.
- ok = clearTrace();
+ if (!onlyUserspace)
+ ok = clearTrace();
writeClockSyncMarker();
if (ok && !async && !traceStream) {
@@ -1256,10 +1286,10 @@
}
// Stop the trace and restore the default settings.
- if (traceStop)
+ if (traceStop && !onlyUserspace)
stopTrace();
- if (ok && traceDump) {
+ if (ok && traceDump && !onlyUserspace) {
if (!g_traceAborted) {
printf(" done\n");
fflush(stdout);
@@ -1286,8 +1316,11 @@
}
// Reset the trace buffer size to 1.
- if (traceStop)
- cleanUpTrace();
+ if (traceStop) {
+ cleanUpUserspaceTracing();
+ if (!onlyUserspace)
+ cleanUpKernelTracing();
+ }
return g_traceAborted ? 1 : 0;
}
diff --git a/cmds/dumpstate/Android.bp b/cmds/dumpstate/Android.bp
index 562898d..b04543b 100644
--- a/cmds/dumpstate/Android.bp
+++ b/cmds/dumpstate/Android.bp
@@ -76,6 +76,7 @@
"libdebuggerd_client",
"libdumpstateaidl",
"libdumpstateutil",
+ "libdumputils",
"libhidlbase",
"libhidltransport",
"liblog",
@@ -119,4 +120,4 @@
"tests/dumpstate_smoke_test.cpp",
],
static_libs: ["libgmock"],
-}
\ No newline at end of file
+}
diff --git a/cmds/dumpstate/DumpstateInternal.cpp b/cmds/dumpstate/DumpstateInternal.cpp
index 83e30a2..33e35f7 100644
--- a/cmds/dumpstate/DumpstateInternal.cpp
+++ b/cmds/dumpstate/DumpstateInternal.cpp
@@ -20,6 +20,7 @@
#include <errno.h>
#include <grp.h>
+#include <poll.h>
#include <pwd.h>
#include <stdint.h>
#include <stdio.h>
@@ -35,6 +36,7 @@
#include <vector>
#include <android-base/file.h>
+#include <android-base/macros.h>
#include <log/log.h>
uint64_t Nanotime() {
@@ -98,13 +100,25 @@
capheader.version = _LINUX_CAPABILITY_VERSION_3;
capheader.pid = 0;
- capdata[CAP_TO_INDEX(CAP_SYSLOG)].permitted = CAP_TO_MASK(CAP_SYSLOG);
- capdata[CAP_TO_INDEX(CAP_SYSLOG)].effective = CAP_TO_MASK(CAP_SYSLOG);
- capdata[0].inheritable = 0;
- capdata[1].inheritable = 0;
+ if (capget(&capheader, &capdata[0]) != 0) {
+ MYLOGE("capget failed: %s\n", strerror(errno));
+ return false;
+ }
- if (capset(&capheader, &capdata[0]) < 0) {
- MYLOGE("capset failed: %s\n", strerror(errno));
+ const uint32_t cap_syslog_mask = CAP_TO_MASK(CAP_SYSLOG);
+ const uint32_t cap_syslog_index = CAP_TO_INDEX(CAP_SYSLOG);
+ bool has_cap_syslog = (capdata[cap_syslog_index].effective & cap_syslog_mask) != 0;
+
+ memset(&capdata, 0, sizeof(capdata));
+ if (has_cap_syslog) {
+ // Only attempt to keep CAP_SYSLOG if it was present to begin with.
+ capdata[cap_syslog_index].permitted |= cap_syslog_mask;
+ capdata[cap_syslog_index].effective |= cap_syslog_mask;
+ }
+
+ if (capset(&capheader, &capdata[0]) != 0) {
+ MYLOGE("capset({%#x, %#x}) failed: %s\n", capdata[0].effective,
+ capdata[1].effective, strerror(errno));
return false;
}
@@ -142,22 +156,16 @@
return 0;
}
bool newline = false;
- fd_set read_set;
- timeval tm;
while (true) {
- FD_ZERO(&read_set);
- FD_SET(fd, &read_set);
- /* Timeout if no data is read for 30 seconds. */
- tm.tv_sec = 30;
- tm.tv_usec = 0;
- uint64_t elapsed = Nanotime();
- int ret = TEMP_FAILURE_RETRY(select(fd + 1, &read_set, nullptr, nullptr, &tm));
+ uint64_t start_time = Nanotime();
+ pollfd fds[] = { { .fd = fd, .events = POLLIN } };
+ int ret = TEMP_FAILURE_RETRY(poll(fds, arraysize(fds), 30 * 1000));
if (ret == -1) {
- dprintf(out_fd, "*** %s: select failed: %s\n", path, strerror(errno));
+ dprintf(out_fd, "*** %s: poll failed: %s\n", path, strerror(errno));
newline = true;
break;
} else if (ret == 0) {
- elapsed = Nanotime() - elapsed;
+ uint64_t elapsed = Nanotime() - start_time;
dprintf(out_fd, "*** %s: Timed out after %.3fs\n", path, (float)elapsed / NANOS_PER_SEC);
newline = true;
break;
diff --git a/cmds/dumpstate/dumpstate.cpp b/cmds/dumpstate/dumpstate.cpp
index d8bbdbb..fd2fccb 100644
--- a/cmds/dumpstate/dumpstate.cpp
+++ b/cmds/dumpstate/dumpstate.cpp
@@ -112,19 +112,6 @@
static const std::string ANR_DIR = "/data/anr/";
static const std::string ANR_FILE_PREFIX = "anr_";
-struct DumpData {
- std::string name;
- int fd;
- time_t mtime;
-};
-
-static bool operator<(const DumpData& d1, const DumpData& d2) {
- return d1.mtime > d2.mtime;
-}
-
-static std::unique_ptr<std::vector<DumpData>> tombstone_data;
-static std::unique_ptr<std::vector<DumpData>> anr_data;
-
// TODO: temporary variables and functions used during C++ refactoring
static Dumpstate& ds = Dumpstate::GetInstance();
static int RunCommand(const std::string& title, const std::vector<std::string>& fullCommand,
@@ -167,15 +154,20 @@
* is set, the vector only contains files that were written in the last 30 minutes.
* If |limit_by_count| is set, the vector only contains the ten latest files.
*/
-static std::vector<DumpData>* GetDumpFds(const std::string& dir_path,
- const std::string& file_prefix,
- bool limit_by_mtime,
- bool limit_by_count = true) {
+static std::vector<DumpData> GetDumpFds(const std::string& dir_path,
+ const std::string& file_prefix,
+ bool limit_by_mtime,
+ bool limit_by_count = true) {
const time_t thirty_minutes_ago = ds.now_ - 60 * 30;
- std::unique_ptr<std::vector<DumpData>> dump_data(new std::vector<DumpData>());
std::unique_ptr<DIR, decltype(&closedir)> dump_dir(opendir(dir_path.c_str()), closedir);
+ if (dump_dir == nullptr) {
+ MYLOGW("Unable to open directory %s: %s\n", dir_path.c_str(), strerror(errno));
+ return std::vector<DumpData>();
+ }
+
+ std::vector<DumpData> dump_data;
struct dirent* entry = nullptr;
while ((entry = readdir(dump_dir.get()))) {
if (entry->d_type != DT_REG) {
@@ -191,13 +183,13 @@
android::base::unique_fd fd(
TEMP_FAILURE_RETRY(open(abs_path.c_str(), O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK)));
if (fd == -1) {
- MYLOGW("Unable to open dump file: %s %s\n", abs_path.c_str(), strerror(errno));
+ MYLOGW("Unable to open dump file %s: %s\n", abs_path.c_str(), strerror(errno));
break;
}
struct stat st = {};
if (fstat(fd, &st) == -1) {
- MYLOGW("Unable to stat dump file: %s %s\n", abs_path.c_str(), strerror(errno));
+ MYLOGW("Unable to stat dump file %s: %s\n", abs_path.c_str(), strerror(errno));
continue;
}
@@ -206,18 +198,19 @@
continue;
}
- DumpData data = {.name = abs_path, .fd = fd.release(), .mtime = st.st_mtime};
-
- dump_data->push_back(data);
+ dump_data.emplace_back(DumpData{abs_path, std::move(fd), st.st_mtime});
}
- std::sort(dump_data->begin(), dump_data->end());
+ // Sort in descending modification time so that we only keep the newest
+ // reports if |limit_by_count| is true.
+ std::sort(dump_data.begin(), dump_data.end(),
+ [](const DumpData& d1, const DumpData& d2) { return d1.mtime > d2.mtime; });
- if (limit_by_count && dump_data->size() > 10) {
- dump_data->erase(dump_data->begin() + 10, dump_data->end());
+ if (limit_by_count && dump_data.size() > 10) {
+ dump_data.erase(dump_data.begin() + 10, dump_data.end());
}
- return dump_data.release();
+ return dump_data;
}
static bool AddDumps(const std::vector<DumpData>::const_iterator start,
@@ -252,12 +245,6 @@
return dumped;
}
-static void CloseDumpFds(const std::vector<DumpData>* dumps) {
- for (auto it = dumps->begin(); it != dumps->end(); ++it) {
- close(it->fd);
- }
-}
-
// for_each_pid() callback to get mount info about a process.
void do_mountinfo(int pid, const char* name __attribute__((unused))) {
char path[PATH_MAX];
@@ -1002,15 +989,15 @@
}
// Add a specific message for the first ANR Dump.
- if (anr_data->size() > 0) {
- AddDumps(anr_data->begin(), anr_data->begin() + 1,
+ if (ds.anr_data_.size() > 0) {
+ AddDumps(ds.anr_data_.begin(), ds.anr_data_.begin() + 1,
"VM TRACES AT LAST ANR", add_to_zip);
// The "last" ANR will always be included as separate entry in the zip file. In addition,
// it will be present in the body of the main entry if |add_to_zip| == false.
//
// Historical ANRs are always included as separate entries in the bugreport zip file.
- AddDumps(anr_data->begin() + ((add_to_zip) ? 1 : 0), anr_data->end(),
+ AddDumps(ds.anr_data_.begin() + ((add_to_zip) ? 1 : 0), ds.anr_data_.end(),
"HISTORICAL ANR", true /* add_to_zip */);
} else {
printf("*** NO ANRs to dump in %s\n\n", ANR_DIR.c_str());
@@ -1357,7 +1344,7 @@
// NOTE: tombstones are always added as separate entries in the zip archive
// and are not interspersed with the main report.
- const bool tombstones_dumped = AddDumps(tombstone_data->begin(), tombstone_data->end(),
+ const bool tombstones_dumped = AddDumps(ds.tombstone_data_.begin(), ds.tombstone_data_.end(),
"TOMBSTONE", true /* add_to_zip */);
if (!tombstones_dumped) {
printf("*** NO TOMBSTONES to dump in %s\n\n", TOMBSTONE_DIR.c_str());
@@ -1506,6 +1493,12 @@
RunDumpsys("TELEPHONY SERVICES", {"activity", "service", "TelephonyDebugService"});
printf("========================================================\n");
+ printf("== Checkins\n");
+ printf("========================================================\n");
+
+ RunDumpsys("CHECKIN BATTERYSTATS", {"batterystats", "-c"});
+
+ printf("========================================================\n");
printf("== dumpstate: done (id %d)\n", ds.id_);
printf("========================================================\n");
}
@@ -2103,8 +2096,8 @@
dump_traces_path = dump_traces();
/* Run some operations that require root. */
- tombstone_data.reset(GetDumpFds(TOMBSTONE_DIR, TOMBSTONE_FILE_PREFIX, !ds.IsZipping()));
- anr_data.reset(GetDumpFds(ANR_DIR, ANR_FILE_PREFIX, !ds.IsZipping()));
+ ds.tombstone_data_ = GetDumpFds(TOMBSTONE_DIR, TOMBSTONE_FILE_PREFIX, !ds.IsZipping());
+ ds.anr_data_ = GetDumpFds(ANR_DIR, ANR_FILE_PREFIX, !ds.IsZipping());
ds.AddDir(RECOVERY_DIR, true);
ds.AddDir(RECOVERY_DATA_DIR, true);
@@ -2277,8 +2270,8 @@
close(ds.control_socket_fd_);
}
- CloseDumpFds(tombstone_data.get());
- CloseDumpFds(anr_data.get());
+ ds.tombstone_data_.clear();
+ ds.anr_data_.clear();
return 0;
}
diff --git a/cmds/dumpstate/dumpstate.h b/cmds/dumpstate/dumpstate.h
index ea4fccd..b220013 100644
--- a/cmds/dumpstate/dumpstate.h
+++ b/cmds/dumpstate/dumpstate.h
@@ -26,6 +26,7 @@
#include <vector>
#include <android-base/macros.h>
+#include <android-base/unique_fd.h>
#include <android/os/IDumpstateListener.h>
#include <utils/StrongPointer.h>
#include <ziparchive/zip_writer.h>
@@ -159,6 +160,20 @@
static std::string VERSION_DEFAULT = "default";
/*
+ * Structure that contains the information of an open dump file.
+ */
+struct DumpData {
+ // Path of the file.
+ std::string name;
+
+ // Open file descriptor for the file.
+ android::base::unique_fd fd;
+
+ // Modification time of the file.
+ time_t mtime;
+};
+
+/*
* Main class driving a bugreport generation.
*
* Currently, it only contains variables that are accessed externally, but gradually the functions
@@ -350,6 +365,12 @@
std::string notification_title;
std::string notification_description;
+ // List of open tombstone dump files.
+ std::vector<DumpData> tombstone_data_;
+
+ // List of open ANR dump files.
+ std::vector<DumpData> anr_data_;
+
private:
// Used by GetInstance() only.
Dumpstate(const std::string& version = VERSION_CURRENT);
diff --git a/cmds/dumpstate/utils.cpp b/cmds/dumpstate/utils.cpp
index a89925f..022f4fc 100644
--- a/cmds/dumpstate/utils.cpp
+++ b/cmds/dumpstate/utils.cpp
@@ -48,10 +48,10 @@
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
#include <android-base/unique_fd.h>
-#include <android/hidl/manager/1.0/IServiceManager.h>
#include <cutils/properties.h>
#include <cutils/sockets.h>
#include <debuggerd/client.h>
+#include <dumputils/dump_utils.h>
#include <log/log.h>
#include <private/android_filesystem_config.h>
@@ -76,36 +76,6 @@
return ds.RunCommand(title, full_command, options);
}
-/* list of native processes to include in the native dumps */
-// This matches the /proc/pid/exe link instead of /proc/pid/cmdline.
-static const char* native_processes_to_dump[] = {
- "/system/bin/audioserver",
- "/system/bin/cameraserver",
- "/system/bin/drmserver",
- "/system/bin/mediadrmserver",
- "/system/bin/mediaextractor", // media.extractor
- "/system/bin/mediametrics", // media.metrics
- "/system/bin/mediaserver",
- "/system/bin/sdcard",
- "/system/bin/statsd",
- "/system/bin/surfaceflinger",
- "/system/bin/vehicle_network_service",
- "/vendor/bin/hw/android.hardware.media.omx@1.0-service", // media.codec
- NULL,
-};
-
-/* list of hal interface to dump containing process during native dumps */
-static const char* hal_interfaces_to_dump[] {
- "android.hardware.audio@2.0::IDevicesFactory",
- "android.hardware.bluetooth@1.0::IBluetoothHci",
- "android.hardware.camera.provider@2.4::ICameraProvider",
- "android.hardware.graphics.composer@2.1::IComposer",
- "android.hardware.media.omx@1.0::IOmx",
- "android.hardware.sensors@1.0::ISensors",
- "android.hardware.vr@1.0::IVr",
- NULL,
-};
-
// Reasonable value for max stats.
static const int STATS_MAX_N_RUNS = 1000;
static const long STATS_MAX_AVERAGE = 100000;
@@ -809,53 +779,6 @@
_redirect_to_file(redirect, path, O_APPEND);
}
-static bool should_dump_hal_interface(const char* interface) {
- for (const char** i = hal_interfaces_to_dump; *i; i++) {
- if (!strcmp(*i, interface)) {
- return true;
- }
- }
- return false;
-}
-
-static bool should_dump_native_traces(const char* path) {
- for (const char** p = native_processes_to_dump; *p; p++) {
- if (!strcmp(*p, path)) {
- return true;
- }
- }
- return false;
-}
-
-std::set<int> get_interesting_hal_pids() {
- using android::hidl::manager::V1_0::IServiceManager;
- using android::sp;
- using android::hardware::Return;
-
- sp<IServiceManager> manager = IServiceManager::getService();
- std::set<int> pids;
-
- Return<void> ret = manager->debugDump([&](auto& hals) {
- for (const auto &info : hals) {
- if (info.pid == static_cast<int>(IServiceManager::PidConstant::NO_PID)) {
- continue;
- }
-
- if (!should_dump_hal_interface(info.interfaceName.c_str())) {
- continue;
- }
-
- pids.insert(info.pid);
- }
- });
-
- if (!ret.isOk()) {
- MYLOGE("Could not get list of HAL PIDs: %s\n", ret.description().c_str());
- }
-
- return pids; // whether it was okay or not
-}
-
const char* DumpTraces(const std::string& traces_path);
const char* DumpTracesTombstoned(const std::string& traces_dir);
@@ -876,18 +799,6 @@
return nullptr;
}
-static bool IsZygote(int pid) {
- static const std::string kZygotePrefix = "zygote";
-
- std::string cmdline;
- if (!android::base::ReadFileToString(android::base::StringPrintf("/proc/%d/cmdline", pid),
- &cmdline)) {
- return true;
- }
-
- return (cmdline.find(kZygotePrefix) == 0);
-}
-
const char* DumpTracesTombstoned(const std::string& traces_dir) {
const std::string temp_file_pattern = traces_dir + "/dumptrace_XXXXXX";
diff --git a/cmds/installd/dexopt.cpp b/cmds/installd/dexopt.cpp
index 230853d..e1e73c7 100644
--- a/cmds/installd/dexopt.cpp
+++ b/cmds/installd/dexopt.cpp
@@ -230,7 +230,7 @@
const char* instruction_set, const char* compiler_filter,
bool debuggable, bool post_bootcomplete, bool background_job_compile, int profile_fd,
const char* class_loader_context, int target_sdk_version, bool enable_hidden_api_checks,
- int dex_metadata_fd, const char* compilation_reason) {
+ bool generate_compact_dex, int dex_metadata_fd, const char* compilation_reason) {
static const unsigned int MAX_INSTRUCTION_SET_LEN = 7;
if (strlen(instruction_set) >= MAX_INSTRUCTION_SET_LEN) {
@@ -438,9 +438,7 @@
// Disable cdex if update input vdex is true since this combination of options is not
// supported.
- // Disable cdex for non-background compiles since we don't want to regress app install until
- // there are enough benefits to justify the tradeoff.
- const bool disable_cdex = !background_job_compile || (input_vdex_fd == output_vdex_fd);
+ const bool disable_cdex = !generate_compact_dex || (input_vdex_fd == output_vdex_fd);
const char* argv[9 // program name, mandatory arguments and the final NULL
+ (have_dex2oat_isa_variant ? 1 : 0)
@@ -1960,6 +1958,7 @@
bool is_secondary_dex = (dexopt_flags & DEXOPT_SECONDARY_DEX) != 0;
bool background_job_compile = (dexopt_flags & DEXOPT_IDLE_BACKGROUND_JOB) != 0;
bool enable_hidden_api_checks = (dexopt_flags & DEXOPT_ENABLE_HIDDEN_API_CHECKS) != 0;
+ bool generate_compact_dex = (dexopt_flags & DEXOPT_GENERATE_COMPACT_DEX) != 0;
// Check if we're dealing with a secondary dex file and if we need to compile it.
std::string oat_dir_str;
@@ -2073,6 +2072,7 @@
class_loader_context,
target_sdk_version,
enable_hidden_api_checks,
+ generate_compact_dex,
dex_metadata_fd.get(),
compilation_reason);
} else {
diff --git a/cmds/installd/installd_constants.h b/cmds/installd/installd_constants.h
index 6282ba2..26aa443 100644
--- a/cmds/installd/installd_constants.h
+++ b/cmds/installd/installd_constants.h
@@ -53,6 +53,7 @@
// controls whether extra debugging flags can be used (taking more compile time.)
constexpr int DEXOPT_IDLE_BACKGROUND_JOB = 1 << 9;
constexpr int DEXOPT_ENABLE_HIDDEN_API_CHECKS = 1 << 10;
+constexpr int DEXOPT_GENERATE_COMPACT_DEX = 1 << 11;
/* all known values for dexopt flags */
constexpr int DEXOPT_MASK =
@@ -65,7 +66,8 @@
| DEXOPT_STORAGE_CE
| DEXOPT_STORAGE_DE
| DEXOPT_IDLE_BACKGROUND_JOB
- | DEXOPT_ENABLE_HIDDEN_API_CHECKS;
+ | DEXOPT_ENABLE_HIDDEN_API_CHECKS
+ | DEXOPT_GENERATE_COMPACT_DEX;
// NOTE: keep in sync with StorageManager
constexpr int FLAG_STORAGE_DE = 1 << 0;
diff --git a/cmds/installd/otapreopt.cpp b/cmds/installd/otapreopt.cpp
index c1a1202..58355f9 100644
--- a/cmds/installd/otapreopt.cpp
+++ b/cmds/installd/otapreopt.cpp
@@ -81,8 +81,9 @@
static_assert(DEXOPT_STORAGE_DE == 1 << 8, "DEXOPT_STORAGE_DE unexpected.");
static_assert(DEXOPT_ENABLE_HIDDEN_API_CHECKS == 1 << 10,
"DEXOPT_ENABLE_HIDDEN_API_CHECKS unexpected");
+static_assert(DEXOPT_GENERATE_COMPACT_DEX == 1 << 11, "DEXOPT_GENERATE_COMPACT_DEX unexpected");
-static_assert(DEXOPT_MASK == (0x5fe | DEXOPT_IDLE_BACKGROUND_JOB),
+static_assert(DEXOPT_MASK == (0xdfe | DEXOPT_IDLE_BACKGROUND_JOB),
"DEXOPT_MASK unexpected.");
diff --git a/cmds/installd/otapreopt_parameters.cpp b/cmds/installd/otapreopt_parameters.cpp
index 802d5d7..d56aec9 100644
--- a/cmds/installd/otapreopt_parameters.cpp
+++ b/cmds/installd/otapreopt_parameters.cpp
@@ -133,6 +133,9 @@
// The compilation reason is ab-ota (match the system property pm.dexopt.ab-ota)
compilation_reason = "ab-ota";
+
+ // Flag is enabled by default for A/B otas.
+ dexopt_flags = DEXOPT_GENERATE_COMPACT_DEX;
}
bool OTAPreoptParameters::ReadArgumentsV1(const char** argv) {
@@ -146,6 +149,8 @@
return false;
}
+ SetDefaultsForPostV1Arguments();
+
size_t param_index = 0;
for (;; ++param_index) {
const char* param = argv[3 + param_index];
@@ -193,8 +198,9 @@
constexpr int OLD_DEXOPT_BOOTCOMPLETE = 1 << 4;
constexpr int OLD_DEXOPT_PROFILE_GUIDED = 1 << 5;
constexpr int OLD_DEXOPT_OTA = 1 << 6;
+ static_assert(DEXOPT_GENERATE_COMPACT_DEX > OLD_DEXOPT_OTA, "must not overlap");
int input = atoi(param);
- dexopt_flags =
+ dexopt_flags |=
ReplaceMask(input, OLD_DEXOPT_PUBLIC, DEXOPT_PUBLIC) |
ReplaceMask(input, OLD_DEXOPT_DEBUGGABLE, DEXOPT_DEBUGGABLE) |
ReplaceMask(input, OLD_DEXOPT_BOOTCOMPLETE, DEXOPT_BOOTCOMPLETE) |
@@ -226,8 +232,6 @@
return false;
}
- SetDefaultsForPostV1Arguments();
-
return true;
}
@@ -239,7 +243,9 @@
case 4: num_args_expected = 13; break;
case 5: num_args_expected = 14; break;
case 6: num_args_expected = 15; break;
- case 7: num_args_expected = 16; break;
+ case 7:
+ // Version 8 adds a new dexopt flag: DEXOPT_GENERATE_COMPACT_DEX
+ case 8: num_args_expected = 16; break;
default:
LOG(ERROR) << "Don't know how to read arguments for version " << version;
return false;
@@ -302,6 +308,10 @@
case 6:
dexopt_flags = atoi(param);
+ // Add CompactDex generation flag for versions less than 8 since it wasn't passed
+ // from the package manager. Only conditionally set the flag here so that it can
+ // be fully controlled by the package manager.
+ dexopt_flags |= (version < 8) ? DEXOPT_GENERATE_COMPACT_DEX : 0u;
break;
case 7:
diff --git a/cmds/installd/tests/Android.bp b/cmds/installd/tests/Android.bp
index 7438d3d..739f33f 100644
--- a/cmds/installd/tests/Android.bp
+++ b/cmds/installd/tests/Android.bp
@@ -1,6 +1,7 @@
// Build the unit tests for installd
cc_test {
name: "installd_utils_test",
+ test_suites: ["device-tests"],
clang: true,
srcs: ["installd_utils_test.cpp"],
cflags: ["-Wall", "-Werror"],
@@ -18,6 +19,7 @@
cc_test {
name: "installd_cache_test",
+ test_suites: ["device-tests"],
clang: true,
srcs: ["installd_cache_test.cpp"],
cflags: ["-Wall", "-Werror"],
@@ -39,6 +41,7 @@
cc_test {
name: "installd_service_test",
+ test_suites: ["device-tests"],
clang: true,
srcs: ["installd_service_test.cpp"],
cflags: ["-Wall", "-Werror"],
@@ -60,6 +63,7 @@
cc_test {
name: "installd_dexopt_test",
+ test_suites: ["device-tests"],
clang: true,
srcs: ["installd_dexopt_test.cpp"],
cflags: ["-Wall", "-Werror"],
@@ -81,6 +85,7 @@
cc_test {
name: "installd_otapreopt_test",
+ test_suites: ["device-tests"],
clang: true,
srcs: ["installd_otapreopt_test.cpp"],
cflags: ["-Wall", "-Werror"],
diff --git a/cmds/installd/tests/installd_otapreopt_test.cpp b/cmds/installd/tests/installd_otapreopt_test.cpp
index 82bf932..63426cb 100644
--- a/cmds/installd/tests/installd_otapreopt_test.cpp
+++ b/cmds/installd/tests/installd_otapreopt_test.cpp
@@ -20,6 +20,7 @@
#include <android-base/logging.h>
#include <gtest/gtest.h>
+#include "installd_constants.h"
#include "otapreopt_parameters.h"
namespace android {
@@ -61,7 +62,7 @@
ASSERT_STREQ(params.instruction_set, args[i++]);
ASSERT_EQ(params.dexopt_needed, atoi(args[i++]));
ASSERT_STREQ(params.oat_dir, args[i++]);
- ASSERT_EQ(params.dexopt_flags, atoi(args[i++]));
+ const int dexopt_flags = atoi(args[i++]);
ASSERT_STREQ(params.compiler_filter, args[i++]);
ASSERT_STREQ(params.volume_uuid, ParseNull(args[i++]));
ASSERT_STREQ(params.shared_libraries, ParseNull(args[i++]));
@@ -78,7 +79,7 @@
if (version > 3) {
ASSERT_EQ(params.target_sdk_version, atoi(args[i++]));
} else {
- ASSERT_EQ(params.target_sdk_version, 0);
+ ASSERT_EQ(params.target_sdk_version, 0);
}
if (version > 4) {
ASSERT_STREQ(params.profile_name, ParseNull(args[i++]));
@@ -95,6 +96,11 @@
} else {
ASSERT_STREQ(params.compilation_reason, "ab-ota");
}
+ if (version > 7) {
+ ASSERT_EQ(params.dexopt_flags, dexopt_flags);
+ } else {
+ ASSERT_EQ(params.dexopt_flags, dexopt_flags | DEXOPT_GENERATE_COMPACT_DEX);
+ }
}
const char* getVersionCStr(uint32_t version) {
@@ -106,6 +112,7 @@
case 5: return "5";
case 6: return "6";
case 7: return "7";
+ case 8: return "8";
}
return nullptr;
}
diff --git a/cmds/lshal/DebugCommand.cpp b/cmds/lshal/DebugCommand.cpp
index dd8812d..0952db6 100644
--- a/cmds/lshal/DebugCommand.cpp
+++ b/cmds/lshal/DebugCommand.cpp
@@ -59,8 +59,8 @@
auto pair = splitFirst(mInterfaceName, '/');
- FQName fqName(pair.first);
- if (!fqName.isValid() || fqName.isIdentifier() || !fqName.isFullyQualified()) {
+ FQName fqName;
+ if (!FQName::parse(pair.first, &fqName) || fqName.isIdentifier() || !fqName.isFullyQualified()) {
mLshal.err() << "Invalid fully-qualified name '" << pair.first << "'\n\n";
return USAGE;
}
diff --git a/cmds/lshal/ListCommand.cpp b/cmds/lshal/ListCommand.cpp
index b9e0139..3dfb7e0 100644
--- a/cmds/lshal/ListCommand.cpp
+++ b/cmds/lshal/ListCommand.cpp
@@ -252,16 +252,16 @@
// use a double for loop here because lshal doesn't care about efficiency.
for (TableEntry &packageEntry : mImplementationsTable) {
std::string packageName = packageEntry.interfaceName;
- FQName fqPackageName{packageName.substr(0, packageName.find("::"))};
- if (!fqPackageName.isValid()) {
+ FQName fqPackageName;
+ if (!FQName::parse(packageName.substr(0, packageName.find("::")), &fqPackageName)) {
continue;
}
for (TableEntry &interfaceEntry : mPassthroughRefTable) {
if (interfaceEntry.arch != ARCH_UNKNOWN) {
continue;
}
- FQName interfaceName{splitFirst(interfaceEntry.interfaceName, '/').first};
- if (!interfaceName.isValid()) {
+ FQName interfaceName;
+ if (!FQName::parse(splitFirst(interfaceEntry.interfaceName, '/').first, &interfaceName)) {
continue;
}
if (interfaceName.getPackageAndVersion() == fqPackageName) {
@@ -280,7 +280,8 @@
"The Clients / Clients CMD column shows all process that have ever dlopen'ed \n"
"the library and successfully fetched the passthrough implementation.");
mImplementationsTable.setDescription(
- "All available passthrough implementations (all -impl.so files)");
+ "All available passthrough implementations (all -impl.so files).\n"
+ "These may return subclasses through their respective HIDL_FETCH_I* functions.");
}
static inline bool findAndBumpVersion(vintf::ManifestHal* hal, const vintf::Version& version) {
@@ -308,10 +309,10 @@
// Quick hack to work around *'s
replaceAll(&fqInstanceName, '*', 'D');
}
- auto splittedFqInstanceName = splitFirst(fqInstanceName, '/');
- FQName fqName(splittedFqInstanceName.first);
- if (!fqName.isValid()) {
- err() << "Warning: '" << splittedFqInstanceName.first
+ auto splitFqInstanceName = splitFirst(fqInstanceName, '/');
+ FQName fqName;
+ if (!FQName::parse(splitFqInstanceName.first, &fqName)) {
+ err() << "Warning: '" << splitFqInstanceName.first
<< "' is not a valid FQName." << std::endl;
continue;
}
@@ -335,7 +336,7 @@
std::string interfaceName =
&table == &mImplementationsTable ? "" : fqName.name();
std::string instanceName =
- &table == &mImplementationsTable ? "" : splittedFqInstanceName.second;
+ &table == &mImplementationsTable ? "" : splitFqInstanceName.second;
vintf::Version version{fqName.getPackageMajorVersion(),
fqName.getPackageMinorVersion()};
@@ -394,11 +395,11 @@
interfaces[interfaceName].instances.insert(instanceName);
}
if (!manifest.add(vintf::ManifestHal{
- .format = vintf::HalFormat::HIDL,
- .name = fqName.package(),
- .versions = {version},
- .transportArch = {transport, arch},
- .interfaces = interfaces})) {
+ vintf::HalFormat::HIDL,
+ std::string{fqName.package()},
+ {version},
+ {transport, arch},
+ std::move(interfaces)})) {
err() << "Warning: cannot add hal '" << fqInstanceName << "'" << std::endl;
}
}
diff --git a/data/etc/wearable_core_hardware.xml b/data/etc/wearable_core_hardware.xml
index d7c3730..e2ab71a 100644
--- a/data/etc/wearable_core_hardware.xml
+++ b/data/etc/wearable_core_hardware.xml
@@ -36,9 +36,6 @@
<!-- basic system services -->
<feature name="android.software.home_screen" />
- <!-- device administration -->
- <feature name="android.software.device_admin" />
-
<!-- input management and third-party input method editors -->
<feature name="android.software.input_methods" />
diff --git a/headers/media_plugin/media/openmax/OMX_IndexExt.h b/headers/media_plugin/media/openmax/OMX_IndexExt.h
index 5a029d0..c2bf97e 100644
--- a/headers/media_plugin/media/openmax/OMX_IndexExt.h
+++ b/headers/media_plugin/media/openmax/OMX_IndexExt.h
@@ -85,6 +85,7 @@
OMX_IndexParamMaxFrameDurationForBitrateControl,/**< reference: OMX_PARAM_U32TYPE */
OMX_IndexParamVideoVp9, /**< reference: OMX_VIDEO_PARAM_VP9TYPE */
OMX_IndexParamVideoAndroidVp9Encoder, /**< reference: OMX_VIDEO_PARAM_ANDROID_VP9ENCODERTYPE */
+ OMX_IndexParamVideoAndroidImageGrid, /**< reference: OMX_VIDEO_PARAM_ANDROID_IMAGEGRIDTYPE */
OMX_IndexExtVideoEndUnused,
/* Image & Video common configurations */
diff --git a/headers/media_plugin/media/openmax/OMX_Video.h b/headers/media_plugin/media/openmax/OMX_Video.h
index dc5cdab..9fd2fd2 100644
--- a/headers/media_plugin/media/openmax/OMX_Video.h
+++ b/headers/media_plugin/media/openmax/OMX_Video.h
@@ -89,6 +89,7 @@
OMX_VIDEO_CodingVP9, /**< Google VP9 */
OMX_VIDEO_CodingHEVC, /**< ITU H.265/HEVC */
OMX_VIDEO_CodingDolbyVision,/**< Dolby Vision */
+ OMX_VIDEO_CodingImageHEIC, /**< HEIF image encoded with HEVC */
OMX_VIDEO_CodingKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
OMX_VIDEO_CodingVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
OMX_VIDEO_CodingMax = 0x7FFFFFFF
diff --git a/headers/media_plugin/media/openmax/OMX_VideoExt.h b/headers/media_plugin/media/openmax/OMX_VideoExt.h
index c102564..4b90765 100644
--- a/headers/media_plugin/media/openmax/OMX_VideoExt.h
+++ b/headers/media_plugin/media/openmax/OMX_VideoExt.h
@@ -213,6 +213,7 @@
OMX_VIDEO_HEVCProfileUnknown = 0x0,
OMX_VIDEO_HEVCProfileMain = 0x1,
OMX_VIDEO_HEVCProfileMain10 = 0x2,
+ OMX_VIDEO_HEVCProfileMainStill = 0x4,
// Main10 profile with HDR SEI support.
OMX_VIDEO_HEVCProfileMain10HDR10 = 0x1000,
OMX_VIDEO_HEVCProfileMax = 0x7FFFFFFF
@@ -421,6 +422,48 @@
OMX_U32 nBitrateRatios[OMX_VIDEO_ANDROID_MAXTEMPORALLAYERS];
} OMX_VIDEO_CONFIG_ANDROID_TEMPORALLAYERINGTYPE;
+/**
+ * Android specific param for specifying image grid layout information for image encoding
+ * use cases, corresponding to index OMX_IndexParamVideoAndroidImageGrid.
+ *
+ * OMX_VIDEO_CodingImageHEIC encoders must handle this param type. When this param is set
+ * on the component with bEnabled set to true, nGrid* indicates the desired grid config
+ * by the client. The component can use this as a heuristic, but is free to choose any
+ * suitable grid configs, and the client shall always get the actual from the component
+ * after the param is set. Encoder will receive each input image in full, and shall encode
+ * it into tiles in row-major, top-row first, left-to-right order, and send each encoded
+ * tile in a separate output buffer. All output buffers for the same input buffer shall
+ * carry the same timestamp as the input buffer. If the input buffer is marked EOS,
+ * the EOS should only appear on the last output buffer for that input buffer.
+ *
+ * OMX_VIDEO_CodingHEVC encoders might also receive this param when it's used for image
+ * encoding, although in this case the param only serves as a hint. The encoder will
+ * receive the input image tiles in row-major, top-row first, left-to-right order.
+ * The grid config can be used for quality control, or optimizations.
+ *
+ * If this param is not set, the component shall assume that grid option is disabled.
+ *
+ * nSize : Size of the structure in bytes
+ * nVersion : OMX specification version information
+ * nPortIndex : Port that this structure applies to (output port for encoders)
+ * bEnabled : Whether grid is enabled. If true, nGrid* specifies the grid
+ * config; otherwise nGrid* shall be ignored.
+ * nGridWidth : Width of each tile.
+ * nGridHeight : Height of each tile.
+ * nGridRows : Number of rows in the grid.
+ * nGridCols : Number of cols in the grid.
+ */
+typedef struct OMX_VIDEO_PARAM_ANDROID_IMAGEGRIDTYPE {
+ OMX_U32 nSize;
+ OMX_VERSIONTYPE nVersion;
+ OMX_U32 nPortIndex;
+ OMX_BOOL bEnabled;
+ OMX_U32 nGridWidth;
+ OMX_U32 nGridHeight;
+ OMX_U32 nGridRows;
+ OMX_U32 nGridCols;
+} OMX_VIDEO_PARAM_ANDROID_IMAGEGRIDTYPE;
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
diff --git a/include/input/Input.h b/include/input/Input.h
index cfcafab..15c86eb 100644
--- a/include/input/Input.h
+++ b/include/input/Input.h
@@ -339,7 +339,7 @@
static const char* getLabel(int32_t keyCode);
static int32_t getKeyCodeFromLabel(const char* label);
-
+
void initialize(
int32_t deviceId,
int32_t source,
@@ -373,6 +373,10 @@
virtual int32_t getType() const { return AINPUT_EVENT_TYPE_MOTION; }
+ inline int32_t getDisplayId() const { return mDisplayId; }
+
+ inline void setDisplayId(int32_t displayId) { mDisplayId = displayId; }
+
inline int32_t getAction() const { return mAction; }
inline int32_t getActionMasked() const { return mAction & AMOTION_EVENT_ACTION_MASK; }
@@ -556,6 +560,7 @@
void initialize(
int32_t deviceId,
int32_t source,
+ int32_t displayId,
int32_t action,
int32_t actionButton,
int32_t flags,
@@ -609,6 +614,7 @@
static int32_t getAxisFromLabel(const char* label);
protected:
+ int32_t mDisplayId;
int32_t mAction;
int32_t mActionButton;
int32_t mFlags;
diff --git a/include/input/InputTransport.h b/include/input/InputTransport.h
index 1ea2c2c..ee52661 100644
--- a/include/input/InputTransport.h
+++ b/include/input/InputTransport.h
@@ -64,7 +64,6 @@
nsecs_t eventTime __attribute__((aligned(8)));
int32_t deviceId;
int32_t source;
- int32_t displayId;
int32_t action;
int32_t flags;
int32_t keyCode;
@@ -305,7 +304,7 @@
* Other errors probably indicate that the channel is broken.
*/
status_t consume(InputEventFactoryInterface* factory, bool consumeBatches,
- nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent, int32_t* displayId);
+ nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent);
/* Sends a finished signal to the publisher to inform it that the message
* with the specified sequence number has finished being process and whether
@@ -460,10 +459,9 @@
Vector<SeqChain> mSeqChains;
status_t consumeBatch(InputEventFactoryInterface* factory,
- nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent, int32_t* displayId);
+ nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent);
status_t consumeSamples(InputEventFactoryInterface* factory,
- Batch& batch, size_t count, uint32_t* outSeq, InputEvent** outEvent,
- int32_t* displayId);
+ Batch& batch, size_t count, uint32_t* outSeq, InputEvent** outEvent);
void updateTouchState(InputMessage& msg);
void resampleTouchState(nsecs_t frameTime, MotionEvent* event,
diff --git a/libs/dumputils/Android.bp b/libs/dumputils/Android.bp
new file mode 100644
index 0000000..3412e14
--- /dev/null
+++ b/libs/dumputils/Android.bp
@@ -0,0 +1,34 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+cc_library {
+ name: "libdumputils",
+
+ shared_libs: [
+ "libbase",
+ "libbinder",
+ "libhidlbase",
+ "libhidltransport",
+ "liblog",
+ "libutils",
+ ],
+
+ srcs: ["dump_utils.cpp"],
+
+ cflags: ["-Wall", "-Werror"],
+
+ export_include_dirs: [
+ "include",
+ ],
+}
diff --git a/libs/dumputils/dump_utils.cpp b/libs/dumputils/dump_utils.cpp
new file mode 100644
index 0000000..0fd2b81
--- /dev/null
+++ b/libs/dumputils/dump_utils.cpp
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <set>
+
+#include <android-base/file.h>
+#include <android-base/stringprintf.h>
+#include <android/hidl/manager/1.0/IServiceManager.h>
+#include <dumputils/dump_utils.h>
+#include <log/log.h>
+
+/* list of native processes to include in the native dumps */
+// This matches the /proc/pid/exe link instead of /proc/pid/cmdline.
+static const char* native_processes_to_dump[] = {
+ "/system/bin/audioserver",
+ "/system/bin/cameraserver",
+ "/system/bin/drmserver",
+ "/system/bin/mediadrmserver",
+ "/system/bin/mediaextractor", // media.extractor
+ "/system/bin/mediametrics", // media.metrics
+ "/system/bin/mediaserver",
+ "/system/bin/sdcard",
+ "/system/bin/statsd",
+ "/system/bin/surfaceflinger",
+ "/system/bin/vehicle_network_service",
+ "/vendor/bin/hw/android.hardware.media.omx@1.0-service", // media.codec
+ NULL,
+};
+
+/* list of hal interface to dump containing process during native dumps */
+static const char* hal_interfaces_to_dump[] {
+ "android.hardware.audio@2.0::IDevicesFactory",
+ "android.hardware.bluetooth@1.0::IBluetoothHci",
+ "android.hardware.camera.provider@2.4::ICameraProvider",
+ "android.hardware.graphics.composer@2.1::IComposer",
+ "android.hardware.media.omx@1.0::IOmx",
+ "android.hardware.sensors@1.0::ISensors",
+ "android.hardware.vr@1.0::IVr",
+ NULL,
+};
+
+bool should_dump_hal_interface(const char* interface) {
+ for (const char** i = hal_interfaces_to_dump; *i; i++) {
+ if (!strcmp(*i, interface)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+bool should_dump_native_traces(const char* path) {
+ for (const char** p = native_processes_to_dump; *p; p++) {
+ if (!strcmp(*p, path)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+std::set<int> get_interesting_hal_pids() {
+ using android::hidl::manager::V1_0::IServiceManager;
+ using android::sp;
+ using android::hardware::Return;
+
+ sp<IServiceManager> manager = IServiceManager::getService();
+ std::set<int> pids;
+
+ Return<void> ret = manager->debugDump([&](auto& hals) {
+ for (const auto &info : hals) {
+ if (info.pid == static_cast<int>(IServiceManager::PidConstant::NO_PID)) {
+ continue;
+ }
+
+ if (!should_dump_hal_interface(info.interfaceName.c_str())) {
+ continue;
+ }
+
+ pids.insert(info.pid);
+ }
+ });
+
+ if (!ret.isOk()) {
+ ALOGE("Could not get list of HAL PIDs: %s\n", ret.description().c_str());
+ }
+
+ return pids; // whether it was okay or not
+}
+
+bool IsZygote(int pid) {
+ static const std::string kZygotePrefix = "zygote";
+
+ std::string cmdline;
+ if (!android::base::ReadFileToString(android::base::StringPrintf("/proc/%d/cmdline", pid),
+ &cmdline)) {
+ return true;
+ }
+
+ return (cmdline.find(kZygotePrefix) == 0);
+}
diff --git a/libs/dumputils/include/dumputils/dump_utils.h b/libs/dumputils/include/dumputils/dump_utils.h
new file mode 100644
index 0000000..25f7127
--- /dev/null
+++ b/libs/dumputils/include/dumputils/dump_utils.h
@@ -0,0 +1,28 @@
+/**
+ * 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 DUMPUTILS_H_
+#define DUMPUTILS_H_
+
+#include <set>
+
+bool should_dump_native_traces(const char* path);
+
+std::set<int> get_interesting_hal_pids();
+
+bool IsZygote(int pid);
+
+#endif // DUMPUTILS_H_
diff --git a/libs/gui/Android.bp b/libs/gui/Android.bp
index a1a0928..5fb778a 100644
--- a/libs/gui/Android.bp
+++ b/libs/gui/Android.bp
@@ -72,9 +72,6 @@
],
product_variables: {
- brillo: {
- cflags: ["-DHAVE_NO_SURFACE_FLINGER"],
- },
eng: {
cppflags: [
"-UDEBUG_ONLY_CODE",
@@ -122,6 +119,7 @@
],
shared_libs: [
+ "android.hardware.graphics.common@1.1",
"libsync",
"libbinder",
"libbufferhubqueue", // TODO(b/70046255): Remove this once BufferHub is integrated into libgui.
@@ -154,6 +152,7 @@
"libui",
"android.hidl.token@1.0-utils",
"android.hardware.graphics.bufferqueue@1.0",
+ "android.hardware.graphics.common@1.1",
],
export_header_lib_headers: [
diff --git a/libs/gui/HdrMetadata.cpp b/libs/gui/HdrMetadata.cpp
index 299bdfa..b715e43 100644
--- a/libs/gui/HdrMetadata.cpp
+++ b/libs/gui/HdrMetadata.cpp
@@ -66,4 +66,32 @@
return NO_ERROR;
}
+bool HdrMetadata::operator==(const HdrMetadata& rhs) const {
+ if (validTypes != rhs.validTypes) return false;
+
+ if ((validTypes & SMPTE2086) == SMPTE2086) {
+ if (smpte2086.displayPrimaryRed.x != rhs.smpte2086.displayPrimaryRed.x ||
+ smpte2086.displayPrimaryRed.y != rhs.smpte2086.displayPrimaryRed.y ||
+ smpte2086.displayPrimaryGreen.x != rhs.smpte2086.displayPrimaryGreen.x ||
+ smpte2086.displayPrimaryGreen.y != rhs.smpte2086.displayPrimaryGreen.y ||
+ smpte2086.displayPrimaryBlue.x != rhs.smpte2086.displayPrimaryBlue.x ||
+ smpte2086.displayPrimaryBlue.y != rhs.smpte2086.displayPrimaryBlue.y ||
+ smpte2086.whitePoint.x != rhs.smpte2086.whitePoint.x ||
+ smpte2086.whitePoint.y != rhs.smpte2086.whitePoint.y ||
+ smpte2086.maxLuminance != rhs.smpte2086.maxLuminance ||
+ smpte2086.minLuminance != rhs.smpte2086.minLuminance) {
+ return false;
+ }
+ }
+
+ if ((validTypes & CTA861_3) == CTA861_3) {
+ if (cta8613.maxFrameAverageLightLevel != rhs.cta8613.maxFrameAverageLightLevel ||
+ cta8613.maxContentLightLevel != rhs.cta8613.maxContentLightLevel) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
} // namespace android
diff --git a/libs/gui/ISurfaceComposer.cpp b/libs/gui/ISurfaceComposer.cpp
index 5de84ec..0244bb5 100644
--- a/libs/gui/ISurfaceComposer.cpp
+++ b/libs/gui/ISurfaceComposer.cpp
@@ -132,12 +132,13 @@
virtual status_t captureLayers(const sp<IBinder>& layerHandleBinder,
sp<GraphicBuffer>* outBuffer, const Rect& sourceCrop,
- float frameScale) {
+ float frameScale, bool childrenOnly) {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
data.writeStrongBinder(layerHandleBinder);
data.write(sourceCrop);
data.writeFloat(frameScale);
+ data.writeBool(childrenOnly);
status_t err = remote()->transact(BnSurfaceComposer::CAPTURE_LAYERS, data, &reply);
if (err != NO_ERROR) {
@@ -349,7 +350,7 @@
}
virtual status_t getDisplayColorModes(const sp<IBinder>& display,
- Vector<android_color_mode_t>* outColorModes) {
+ Vector<ColorMode>* outColorModes) {
Parcel data, reply;
status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (result != NO_ERROR) {
@@ -372,34 +373,34 @@
outColorModes->clear();
outColorModes->resize(numModes);
for (size_t i = 0; i < numModes; ++i) {
- outColorModes->replaceAt(static_cast<android_color_mode_t>(reply.readInt32()), i);
+ outColorModes->replaceAt(static_cast<ColorMode>(reply.readInt32()), i);
}
}
return result;
}
- virtual android_color_mode_t getActiveColorMode(const sp<IBinder>& display) {
+ virtual ColorMode getActiveColorMode(const sp<IBinder>& display) {
Parcel data, reply;
status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (result != NO_ERROR) {
ALOGE("getActiveColorMode failed to writeInterfaceToken: %d", result);
- return static_cast<android_color_mode_t>(result);
+ return static_cast<ColorMode>(result);
}
result = data.writeStrongBinder(display);
if (result != NO_ERROR) {
ALOGE("getActiveColorMode failed to writeStrongBinder: %d", result);
- return static_cast<android_color_mode_t>(result);
+ return static_cast<ColorMode>(result);
}
result = remote()->transact(BnSurfaceComposer::GET_ACTIVE_COLOR_MODE, data, &reply);
if (result != NO_ERROR) {
ALOGE("getActiveColorMode failed to transact: %d", result);
- return static_cast<android_color_mode_t>(result);
+ return static_cast<ColorMode>(result);
}
- return static_cast<android_color_mode_t>(reply.readInt32());
+ return static_cast<ColorMode>(reply.readInt32());
}
virtual status_t setActiveColorMode(const sp<IBinder>& display,
- android_color_mode_t colorMode) {
+ ColorMode colorMode) {
Parcel data, reply;
status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (result != NO_ERROR) {
@@ -411,7 +412,7 @@
ALOGE("setActiveColorMode failed to writeStrongBinder: %d", result);
return result;
}
- result = data.writeInt32(colorMode);
+ result = data.writeInt32(static_cast<int32_t>(colorMode));
if (result != NO_ERROR) {
ALOGE("setActiveColorMode failed to writeInt32: %d", result);
return result;
@@ -629,8 +630,10 @@
Rect sourceCrop(Rect::EMPTY_RECT);
data.read(sourceCrop);
float frameScale = data.readFloat();
+ bool childrenOnly = data.readBool();
- status_t res = captureLayers(layerHandleBinder, &outBuffer, sourceCrop, frameScale);
+ status_t res = captureLayers(layerHandleBinder, &outBuffer, sourceCrop, frameScale,
+ childrenOnly);
reply->writeInt32(res);
if (res == NO_ERROR) {
reply->write(*outBuffer);
@@ -736,7 +739,7 @@
}
case GET_DISPLAY_COLOR_MODES: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);
- Vector<android_color_mode_t> colorModes;
+ Vector<ColorMode> colorModes;
sp<IBinder> display = nullptr;
status_t result = data.readStrongBinder(&display);
if (result != NO_ERROR) {
@@ -748,7 +751,7 @@
if (result == NO_ERROR) {
reply->writeUint32(static_cast<uint32_t>(colorModes.size()));
for (size_t i = 0; i < colorModes.size(); ++i) {
- reply->writeInt32(colorModes[i]);
+ reply->writeInt32(static_cast<int32_t>(colorModes[i]));
}
}
return NO_ERROR;
@@ -761,7 +764,7 @@
ALOGE("getActiveColorMode failed to readStrongBinder: %d", result);
return result;
}
- android_color_mode_t colorMode = getActiveColorMode(display);
+ ColorMode colorMode = getActiveColorMode(display);
result = reply->writeInt32(static_cast<int32_t>(colorMode));
return result;
}
@@ -780,7 +783,7 @@
return result;
}
result = setActiveColorMode(display,
- static_cast<android_color_mode_t>(colorModeInt));
+ static_cast<ColorMode>(colorModeInt));
result = reply->writeInt32(result);
return result;
}
diff --git a/libs/gui/Surface.cpp b/libs/gui/Surface.cpp
index e08d6b0..2e1c24b 100644
--- a/libs/gui/Surface.cpp
+++ b/libs/gui/Surface.cpp
@@ -326,7 +326,7 @@
sp<IBinder> display(
composerService()->getBuiltInDisplay(ISurfaceComposer::eDisplayIdMain));
- Vector<android_color_mode_t> colorModes;
+ Vector<ColorMode> colorModes;
status_t err =
composerService()->getDisplayColorModes(display, &colorModes);
@@ -338,11 +338,11 @@
&ISurfaceFlingerConfigs::hasWideColorDisplay>(false);
*supported = false;
- for (android_color_mode_t colorMode : colorModes) {
+ for (ColorMode colorMode : colorModes) {
switch (colorMode) {
- case HAL_COLOR_MODE_DISPLAY_P3:
- case HAL_COLOR_MODE_ADOBE_RGB:
- case HAL_COLOR_MODE_DCI_P3:
+ case ColorMode::DISPLAY_P3:
+ case ColorMode::ADOBE_RGB:
+ case ColorMode::DCI_P3:
if (wideColorBoardConfig) {
*supported = true;
}
diff --git a/libs/gui/SurfaceComposerClient.cpp b/libs/gui/SurfaceComposerClient.cpp
index 92a24ad..61ed976 100644
--- a/libs/gui/SurfaceComposerClient.cpp
+++ b/libs/gui/SurfaceComposerClient.cpp
@@ -698,16 +698,16 @@
}
status_t SurfaceComposerClient::getDisplayColorModes(const sp<IBinder>& display,
- Vector<android_color_mode_t>* outColorModes) {
+ Vector<ColorMode>* outColorModes) {
return ComposerService::getComposerService()->getDisplayColorModes(display, outColorModes);
}
-android_color_mode_t SurfaceComposerClient::getActiveColorMode(const sp<IBinder>& display) {
+ColorMode SurfaceComposerClient::getActiveColorMode(const sp<IBinder>& display) {
return ComposerService::getComposerService()->getActiveColorMode(display);
}
status_t SurfaceComposerClient::setActiveColorMode(const sp<IBinder>& display,
- android_color_mode_t colorMode) {
+ ColorMode colorMode) {
return ComposerService::getComposerService()->setActiveColorMode(display, colorMode);
}
@@ -751,7 +751,17 @@
float frameScale, sp<GraphicBuffer>* outBuffer) {
sp<ISurfaceComposer> s(ComposerService::getComposerService());
if (s == NULL) return NO_INIT;
- status_t ret = s->captureLayers(layerHandle, outBuffer, sourceCrop, frameScale);
+ status_t ret = s->captureLayers(layerHandle, outBuffer, sourceCrop, frameScale,
+ false /* childrenOnly */);
+ return ret;
+}
+
+status_t ScreenshotClient::captureChildLayers(const sp<IBinder>& layerHandle, Rect sourceCrop,
+ float frameScale, sp<GraphicBuffer>* outBuffer) {
+ sp<ISurfaceComposer> s(ComposerService::getComposerService());
+ if (s == NULL) return NO_INIT;
+ status_t ret = s->captureLayers(layerHandle, outBuffer, sourceCrop, frameScale,
+ true /* childrenOnly */);
return ret;
}
// ----------------------------------------------------------------------------
diff --git a/libs/gui/include/gui/HdrMetadata.h b/libs/gui/include/gui/HdrMetadata.h
index cd01952..9800602 100644
--- a/libs/gui/include/gui/HdrMetadata.h
+++ b/libs/gui/include/gui/HdrMetadata.h
@@ -38,6 +38,8 @@
size_t getFlattenedSize() const;
status_t flatten(void* buffer, size_t size) const;
status_t unflatten(void const* buffer, size_t size);
+
+ bool operator==(const HdrMetadata& rhs) const;
};
} // namespace android
diff --git a/libs/gui/include/gui/ISurfaceComposer.h b/libs/gui/include/gui/ISurfaceComposer.h
index e26e332..afe9358 100644
--- a/libs/gui/include/gui/ISurfaceComposer.h
+++ b/libs/gui/include/gui/ISurfaceComposer.h
@@ -30,6 +30,7 @@
#include <ui/FrameStats.h>
#include <ui/PixelFormat.h>
#include <ui/GraphicBuffer.h>
+#include <ui/GraphicsTypes.h>
#include <vector>
@@ -160,10 +161,10 @@
virtual status_t setActiveConfig(const sp<IBinder>& display, int id) = 0;
virtual status_t getDisplayColorModes(const sp<IBinder>& display,
- Vector<android_color_mode_t>* outColorModes) = 0;
- virtual android_color_mode_t getActiveColorMode(const sp<IBinder>& display) = 0;
+ Vector<ColorMode>* outColorModes) = 0;
+ virtual ColorMode getActiveColorMode(const sp<IBinder>& display) = 0;
virtual status_t setActiveColorMode(const sp<IBinder>& display,
- android_color_mode_t colorMode) = 0;
+ ColorMode colorMode) = 0;
/* Capture the specified screen. requires READ_FRAME_BUFFER permission
* This function will fail if there is a secure window on screen.
@@ -173,9 +174,12 @@
int32_t minLayerZ, int32_t maxLayerZ, bool useIdentityTransform,
Rotation rotation = eRotateNone) = 0;
+ /**
+ * Capture a subtree of the layer hierarchy, potentially ignoring the root node.
+ */
virtual status_t captureLayers(const sp<IBinder>& layerHandleBinder,
sp<GraphicBuffer>* outBuffer, const Rect& sourceCrop,
- float frameScale = 1.0) = 0;
+ float frameScale = 1.0, bool childrenOnly = false) = 0;
/* Clears the frame statistics for animations.
*
diff --git a/libs/gui/include/gui/SurfaceComposerClient.h b/libs/gui/include/gui/SurfaceComposerClient.h
index 3fe6635..162fe6e 100644
--- a/libs/gui/include/gui/SurfaceComposerClient.h
+++ b/libs/gui/include/gui/SurfaceComposerClient.h
@@ -29,6 +29,7 @@
#include <utils/threads.h>
#include <ui/FrameStats.h>
+#include <ui/GraphicsTypes.h>
#include <ui/PixelFormat.h>
#include <gui/CpuConsumer.h>
@@ -88,13 +89,13 @@
// Gets the list of supported color modes for the given display
static status_t getDisplayColorModes(const sp<IBinder>& display,
- Vector<android_color_mode_t>* outColorModes);
+ Vector<ColorMode>* outColorModes);
// Gets the active color mode for the given display
- static android_color_mode_t getActiveColorMode(const sp<IBinder>& display);
+ static ColorMode getActiveColorMode(const sp<IBinder>& display);
// Sets the active color mode for the given display
- static status_t setActiveColorMode(const sp<IBinder>& display, android_color_mode_t colorMode);
+ static status_t setActiveColorMode(const sp<IBinder>& display, ColorMode colorMode);
/* Triggers screen on/off or low power mode and waits for it to complete */
static void setDisplayPowerMode(const sp<IBinder>& display, int mode);
@@ -297,8 +298,10 @@
uint32_t reqHeight, int32_t minLayerZ, int32_t maxLayerZ,
bool useIdentityTransform, uint32_t rotation,
sp<GraphicBuffer>* outBuffer);
- static status_t captureLayers(const sp<IBinder>& layerHandle, Rect sourceCrop, float fameScale,
+ static status_t captureLayers(const sp<IBinder>& layerHandle, Rect sourceCrop, float frameScale,
sp<GraphicBuffer>* outBuffer);
+ static status_t captureChildLayers(const sp<IBinder>& layerHandle, Rect sourceCrop,
+ float frameScale, sp<GraphicBuffer>* outBuffer);
};
// ---------------------------------------------------------------------------
diff --git a/libs/gui/tests/Surface_test.cpp b/libs/gui/tests/Surface_test.cpp
index 8060b6e..66d5595 100644
--- a/libs/gui/tests/Surface_test.cpp
+++ b/libs/gui/tests/Surface_test.cpp
@@ -577,15 +577,15 @@
return NO_ERROR;
}
status_t getDisplayColorModes(const sp<IBinder>& /*display*/,
- Vector<android_color_mode_t>* /*outColorModes*/) override {
+ Vector<ColorMode>* /*outColorModes*/) override {
return NO_ERROR;
}
- android_color_mode_t getActiveColorMode(const sp<IBinder>& /*display*/)
+ ColorMode getActiveColorMode(const sp<IBinder>& /*display*/)
override {
- return HAL_COLOR_MODE_NATIVE;
+ return ColorMode::NATIVE;
}
status_t setActiveColorMode(const sp<IBinder>& /*display*/,
- android_color_mode_t /*colorMode*/) override { return NO_ERROR; }
+ ColorMode /*colorMode*/) override { return NO_ERROR; }
status_t captureScreen(const sp<IBinder>& /*display*/,
sp<GraphicBuffer>* /*outBuffer*/,
Rect /*sourceCrop*/, uint32_t /*reqWidth*/, uint32_t /*reqHeight*/,
@@ -593,8 +593,8 @@
bool /*useIdentityTransform*/,
Rotation /*rotation*/) override { return NO_ERROR; }
virtual status_t captureLayers(const sp<IBinder>& /*parentHandle*/,
- sp<GraphicBuffer>* /*outBuffer*/,
- const Rect& /*sourceCrop*/, float /*frameScale*/) override {
+ sp<GraphicBuffer>* /*outBuffer*/, const Rect& /*sourceCrop*/,
+ float /*frameScale*/, bool /*childrenOnly*/) override {
return NO_ERROR;
}
status_t clearAnimationFrameStats() override { return NO_ERROR; }
diff --git a/libs/input/Input.cpp b/libs/input/Input.cpp
index a624663..db27e11 100644
--- a/libs/input/Input.cpp
+++ b/libs/input/Input.cpp
@@ -215,6 +215,7 @@
void MotionEvent::initialize(
int32_t deviceId,
int32_t source,
+ int32_t displayId,
int32_t action,
int32_t actionButton,
int32_t flags,
@@ -231,6 +232,7 @@
const PointerProperties* pointerProperties,
const PointerCoords* pointerCoords) {
InputEvent::initialize(deviceId, source);
+ mDisplayId = displayId;
mAction = action;
mActionButton = actionButton;
mFlags = flags;
@@ -251,6 +253,7 @@
void MotionEvent::copyFrom(const MotionEvent* other, bool keepHistory) {
InputEvent::initialize(other->mDeviceId, other->mSource);
+ mDisplayId = other->mDisplayId;
mAction = other->mAction;
mActionButton = other->mActionButton;
mFlags = other->mFlags;
@@ -431,6 +434,7 @@
mDeviceId = parcel->readInt32();
mSource = parcel->readInt32();
+ mDisplayId = parcel->readInt32();
mAction = parcel->readInt32();
mActionButton = parcel->readInt32();
mFlags = parcel->readInt32();
@@ -480,6 +484,7 @@
parcel->writeInt32(mDeviceId);
parcel->writeInt32(mSource);
+ parcel->writeInt32(mDisplayId);
parcel->writeInt32(mAction);
parcel->writeInt32(mActionButton);
parcel->writeInt32(mFlags);
diff --git a/libs/input/InputTransport.cpp b/libs/input/InputTransport.cpp
index aa0bf17..f1c3fea 100644
--- a/libs/input/InputTransport.cpp
+++ b/libs/input/InputTransport.cpp
@@ -303,13 +303,15 @@
const PointerCoords* pointerCoords) {
#if DEBUG_TRANSPORT_ACTIONS
ALOGD("channel '%s' publisher ~ publishMotionEvent: seq=%u, deviceId=%d, source=0x%x, "
+ "displayId=%" PRId32 ", "
"action=0x%x, actionButton=0x%08x, flags=0x%x, edgeFlags=0x%x, "
"metaState=0x%x, buttonState=0x%x, xOffset=%f, yOffset=%f, "
"xPrecision=%f, yPrecision=%f, downTime=%" PRId64 ", eventTime=%" PRId64 ", "
"pointerCount=%" PRIu32,
mChannel->getName().c_str(), seq,
- deviceId, source, action, actionButton, flags, edgeFlags, metaState, buttonState,
- xOffset, yOffset, xPrecision, yPrecision, downTime, eventTime, pointerCount);
+ deviceId, source, displayId, action, actionButton, flags, edgeFlags, metaState,
+ buttonState, xOffset, yOffset, xPrecision, yPrecision, downTime, eventTime,
+ pointerCount);
#endif
if (!seq) {
@@ -398,8 +400,7 @@
}
status_t InputConsumer::consume(InputEventFactoryInterface* factory,
- bool consumeBatches, nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent,
- int32_t* displayId) {
+ bool consumeBatches, nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent) {
#if DEBUG_TRANSPORT_ACTIONS
ALOGD("channel '%s' consumer ~ consume: consumeBatches=%s, frameTime=%" PRId64,
mChannel->getName().c_str(), consumeBatches ? "true" : "false", frameTime);
@@ -407,7 +408,6 @@
*outSeq = 0;
*outEvent = NULL;
- *displayId = -1; // Invalid display.
// Fetch the next input message.
// Loop until an event can be returned or no additional events are received.
@@ -422,7 +422,7 @@
if (result) {
// Consume the next batched event unless batches are being held for later.
if (consumeBatches || result != WOULD_BLOCK) {
- result = consumeBatch(factory, frameTime, outSeq, outEvent, displayId);
+ result = consumeBatch(factory, frameTime, outSeq, outEvent);
if (*outEvent) {
#if DEBUG_TRANSPORT_ACTIONS
ALOGD("channel '%s' consumer ~ consumed batch event, seq=%u",
@@ -466,7 +466,7 @@
// the previous batch right now and defer the new message until later.
mMsgDeferred = true;
status_t result = consumeSamples(factory,
- batch, batch.samples.size(), outSeq, outEvent, displayId);
+ batch, batch.samples.size(), outSeq, outEvent);
mBatches.removeAt(batchIndex);
if (result) {
return result;
@@ -500,7 +500,7 @@
initializeMotionEvent(motionEvent, &mMsg);
*outSeq = mMsg.body.motion.seq;
*outEvent = motionEvent;
- *displayId = mMsg.body.motion.displayId;
+
#if DEBUG_TRANSPORT_ACTIONS
ALOGD("channel '%s' consumer ~ consumed motion event, seq=%u",
mChannel->getName().c_str(), *outSeq);
@@ -518,14 +518,13 @@
}
status_t InputConsumer::consumeBatch(InputEventFactoryInterface* factory,
- nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent, int32_t* displayId) {
+ nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent) {
status_t result;
for (size_t i = mBatches.size(); i > 0; ) {
i--;
Batch& batch = mBatches.editItemAt(i);
if (frameTime < 0) {
- result = consumeSamples(factory, batch, batch.samples.size(),
- outSeq, outEvent, displayId);
+ result = consumeSamples(factory, batch, batch.samples.size(), outSeq, outEvent);
mBatches.removeAt(i);
return result;
}
@@ -539,7 +538,7 @@
continue;
}
- result = consumeSamples(factory, batch, split + 1, outSeq, outEvent, displayId);
+ result = consumeSamples(factory, batch, split + 1, outSeq, outEvent);
const InputMessage* next;
if (batch.samples.isEmpty()) {
mBatches.removeAt(i);
@@ -557,7 +556,7 @@
}
status_t InputConsumer::consumeSamples(InputEventFactoryInterface* factory,
- Batch& batch, size_t count, uint32_t* outSeq, InputEvent** outEvent, int32_t* displayId) {
+ Batch& batch, size_t count, uint32_t* outSeq, InputEvent** outEvent) {
MotionEvent* motionEvent = factory->createMotionEvent();
if (! motionEvent) return NO_MEMORY;
@@ -572,7 +571,6 @@
mSeqChains.push(seqChain);
addSample(motionEvent, &msg);
} else {
- *displayId = msg.body.motion.displayId;
initializeMotionEvent(motionEvent, &msg);
}
chain = msg.body.motion.seq;
@@ -950,6 +948,7 @@
event->initialize(
msg->body.motion.deviceId,
msg->body.motion.source,
+ msg->body.motion.displayId,
msg->body.motion.action,
msg->body.motion.actionButton,
msg->body.motion.flags,
diff --git a/libs/input/tests/InputEvent_test.cpp b/libs/input/tests/InputEvent_test.cpp
index fd3b7c8..c4b8fe3 100644
--- a/libs/input/tests/InputEvent_test.cpp
+++ b/libs/input/tests/InputEvent_test.cpp
@@ -22,6 +22,9 @@
namespace android {
+// Default display id.
+static constexpr int32_t DISPLAY_ID = ADISPLAY_ID_DEFAULT;
+
class BaseTest : public testing::Test {
protected:
virtual void SetUp() { }
@@ -248,7 +251,7 @@
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 26);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 27);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 28);
- event->initialize(2, AINPUT_SOURCE_TOUCHSCREEN, AMOTION_EVENT_ACTION_MOVE, 0,
+ event->initialize(2, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID, AMOTION_EVENT_ACTION_MOVE, 0,
AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED,
AMOTION_EVENT_EDGE_FLAG_TOP, AMETA_ALT_ON, AMOTION_EVENT_BUTTON_PRIMARY,
X_OFFSET, Y_OFFSET, 2.0f, 2.1f,
@@ -301,6 +304,7 @@
ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, event->getType());
ASSERT_EQ(2, event->getDeviceId());
ASSERT_EQ(static_cast<int>(AINPUT_SOURCE_TOUCHSCREEN), event->getSource());
+ ASSERT_EQ(DISPLAY_ID, event->getDisplayId());
ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, event->getAction());
ASSERT_EQ(AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED, event->getFlags());
ASSERT_EQ(AMOTION_EVENT_EDGE_FLAG_TOP, event->getEdgeFlags());
@@ -434,6 +438,11 @@
event.setSource(AINPUT_SOURCE_JOYSTICK);
ASSERT_EQ(static_cast<int>(AINPUT_SOURCE_JOYSTICK), event.getSource());
+ // Set displayId.
+ constexpr int32_t newDisplayId = 2;
+ event.setDisplayId(newDisplayId);
+ ASSERT_EQ(newDisplayId, event.getDisplayId());
+
// Set action.
event.setAction(AMOTION_EVENT_ACTION_CANCEL);
ASSERT_EQ(AMOTION_EVENT_ACTION_CANCEL, event.getAction());
@@ -557,7 +566,7 @@
pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, angle);
}
MotionEvent event;
- event.initialize(0, 0, AMOTION_EVENT_ACTION_MOVE, 0, 0, 0, 0, 0,
+ event.initialize(0, 0, DISPLAY_ID, AMOTION_EVENT_ACTION_MOVE, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, pointerCount, pointerProperties, pointerCoords);
float originalRawX = 0 + 3;
float originalRawY = -RADIUS + 2;
diff --git a/libs/input/tests/InputPublisherAndConsumer_test.cpp b/libs/input/tests/InputPublisherAndConsumer_test.cpp
index c532241..6c4faed 100644
--- a/libs/input/tests/InputPublisherAndConsumer_test.cpp
+++ b/libs/input/tests/InputPublisherAndConsumer_test.cpp
@@ -89,9 +89,7 @@
uint32_t consumeSeq;
InputEvent* event;
- int32_t displayId;
- status = mConsumer->consume(&mEventFactory, true /*consumeBatches*/, -1, &consumeSeq, &event,
- &displayId);
+ status = mConsumer->consume(&mEventFactory, true /*consumeBatches*/, -1, &consumeSeq, &event);
ASSERT_EQ(OK, status)
<< "consumer consume should return OK";
@@ -131,23 +129,23 @@
void InputPublisherAndConsumerTest::PublishAndConsumeMotionEvent() {
status_t status;
- const uint32_t seq = 15;
- const int32_t deviceId = 1;
- const int32_t source = AINPUT_SOURCE_TOUCHSCREEN;
- int32_t displayId = 0;
- const int32_t action = AMOTION_EVENT_ACTION_MOVE;
- const int32_t actionButton = 0;
- const int32_t flags = AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED;
- const int32_t edgeFlags = AMOTION_EVENT_EDGE_FLAG_TOP;
- const int32_t metaState = AMETA_ALT_LEFT_ON | AMETA_ALT_ON;
- const int32_t buttonState = AMOTION_EVENT_BUTTON_PRIMARY;
- const float xOffset = -10;
- const float yOffset = -20;
- const float xPrecision = 0.25;
- const float yPrecision = 0.5;
- const nsecs_t downTime = 3;
- const size_t pointerCount = 3;
- const nsecs_t eventTime = 4;
+ constexpr uint32_t seq = 15;
+ constexpr int32_t deviceId = 1;
+ constexpr int32_t source = AINPUT_SOURCE_TOUCHSCREEN;
+ constexpr int32_t displayId = 0;
+ constexpr int32_t action = AMOTION_EVENT_ACTION_MOVE;
+ constexpr int32_t actionButton = 0;
+ constexpr int32_t flags = AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED;
+ constexpr int32_t edgeFlags = AMOTION_EVENT_EDGE_FLAG_TOP;
+ constexpr int32_t metaState = AMETA_ALT_LEFT_ON | AMETA_ALT_ON;
+ constexpr int32_t buttonState = AMOTION_EVENT_BUTTON_PRIMARY;
+ constexpr float xOffset = -10;
+ constexpr float yOffset = -20;
+ constexpr float xPrecision = 0.25;
+ constexpr float yPrecision = 0.5;
+ constexpr nsecs_t downTime = 3;
+ constexpr size_t pointerCount = 3;
+ constexpr nsecs_t eventTime = 4;
PointerProperties pointerProperties[pointerCount];
PointerCoords pointerCoords[pointerCount];
for (size_t i = 0; i < pointerCount; i++) {
@@ -176,8 +174,7 @@
uint32_t consumeSeq;
InputEvent* event;
- status = mConsumer->consume(&mEventFactory, true /*consumeBatches*/, -1, &consumeSeq, &event,
- &displayId);
+ status = mConsumer->consume(&mEventFactory, true /*consumeBatches*/, -1, &consumeSeq, &event);
ASSERT_EQ(OK, status)
<< "consumer consume should return OK";
@@ -190,6 +187,7 @@
EXPECT_EQ(seq, consumeSeq);
EXPECT_EQ(deviceId, motionEvent->getDeviceId());
EXPECT_EQ(source, motionEvent->getSource());
+ EXPECT_EQ(displayId, motionEvent->getDisplayId());
EXPECT_EQ(action, motionEvent->getAction());
EXPECT_EQ(flags, motionEvent->getFlags());
EXPECT_EQ(edgeFlags, motionEvent->getEdgeFlags());
diff --git a/libs/input/tests/StructLayout_test.cpp b/libs/input/tests/StructLayout_test.cpp
index d19f3b8..77cce7a 100644
--- a/libs/input/tests/StructLayout_test.cpp
+++ b/libs/input/tests/StructLayout_test.cpp
@@ -38,14 +38,13 @@
CHECK_OFFSET(InputMessage::Body::Key, eventTime, 8);
CHECK_OFFSET(InputMessage::Body::Key, deviceId, 16);
CHECK_OFFSET(InputMessage::Body::Key, source, 20);
- CHECK_OFFSET(InputMessage::Body::Key, displayId, 24);
- CHECK_OFFSET(InputMessage::Body::Key, action, 28);
- CHECK_OFFSET(InputMessage::Body::Key, flags, 32);
- CHECK_OFFSET(InputMessage::Body::Key, keyCode, 36);
- CHECK_OFFSET(InputMessage::Body::Key, scanCode, 40);
- CHECK_OFFSET(InputMessage::Body::Key, metaState, 44);
- CHECK_OFFSET(InputMessage::Body::Key, repeatCount, 48);
- CHECK_OFFSET(InputMessage::Body::Key, downTime, 56);
+ CHECK_OFFSET(InputMessage::Body::Key, action, 24);
+ CHECK_OFFSET(InputMessage::Body::Key, flags, 28);
+ CHECK_OFFSET(InputMessage::Body::Key, keyCode, 32);
+ CHECK_OFFSET(InputMessage::Body::Key, scanCode, 36);
+ CHECK_OFFSET(InputMessage::Body::Key, metaState, 40);
+ CHECK_OFFSET(InputMessage::Body::Key, repeatCount, 44);
+ CHECK_OFFSET(InputMessage::Body::Key, downTime, 48);
CHECK_OFFSET(InputMessage::Body::Motion, seq, 0);
CHECK_OFFSET(InputMessage::Body::Motion, eventTime, 8);
diff --git a/libs/input/tests/VelocityTracker_test.cpp b/libs/input/tests/VelocityTracker_test.cpp
index 43b6012..5242a18 100644
--- a/libs/input/tests/VelocityTracker_test.cpp
+++ b/libs/input/tests/VelocityTracker_test.cpp
@@ -26,6 +26,8 @@
namespace android {
+constexpr int32_t DISPLAY_ID = ADISPLAY_ID_DEFAULT; // default display id
+
constexpr int32_t DEFAULT_POINTER_ID = 0; // pointer ID used for manually defined tests
// velocity must be in the range (1-tol)*EV <= velocity <= (1+tol)*EV
@@ -89,7 +91,7 @@
// First sample added separately with initialize
coords.setAxisValue(AMOTION_EVENT_AXIS_X, positions[0].x);
coords.setAxisValue(AMOTION_EVENT_AXIS_Y, positions[0].y);
- event->initialize(0, AINPUT_SOURCE_TOUCHSCREEN, AMOTION_EVENT_ACTION_MOVE,
+ event->initialize(0, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID, AMOTION_EVENT_ACTION_MOVE,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, positions[0].time, 1, properties, &coords);
for (size_t i = 1; i < numSamples; i++) {
diff --git a/libs/nativewindow/AHardwareBuffer.cpp b/libs/nativewindow/AHardwareBuffer.cpp
index a2712b4..f37ef28 100644
--- a/libs/nativewindow/AHardwareBuffer.cpp
+++ b/libs/nativewindow/AHardwareBuffer.cpp
@@ -343,14 +343,6 @@
"HAL and AHardwareBuffer pixel format don't match");
static_assert(HAL_PIXEL_FORMAT_YCBCR_420_888 == AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420,
"HAL and AHardwareBuffer pixel format don't match");
- static_assert(HAL_PIXEL_FORMAT_YCBCR_422_888 == AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_422,
- "HAL and AHardwareBuffer pixel format don't match");
- static_assert(HAL_PIXEL_FORMAT_YCBCR_444_888 == AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_444,
- "HAL and AHardwareBuffer pixel format don't match");
- static_assert(HAL_PIXEL_FORMAT_FLEX_RGB_888 == AHARDWAREBUFFER_FORMAT_FLEX_R8G8B8,
- "HAL and AHardwareBuffer pixel format don't match");
- static_assert(HAL_PIXEL_FORMAT_FLEX_RGBA_8888 == AHARDWAREBUFFER_FORMAT_FLEX_R8G8B8A8,
- "HAL and AHardwareBuffer pixel format don't match");
static_assert(HAL_PIXEL_FORMAT_YCBCR_422_SP == AHARDWAREBUFFER_FORMAT_YCbCr_422_SP,
"HAL and AHardwareBuffer pixel format don't match");
static_assert(HAL_PIXEL_FORMAT_YCRCB_420_SP == AHARDWAREBUFFER_FORMAT_YCrCb_420_SP,
@@ -383,10 +375,6 @@
case AHARDWAREBUFFER_FORMAT_RAW_OPAQUE:
case AHARDWAREBUFFER_FORMAT_IMPLEMENTATION_DEFINED:
case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
- case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_422:
- case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_444:
- case AHARDWAREBUFFER_FORMAT_FLEX_R8G8B8:
- case AHARDWAREBUFFER_FORMAT_FLEX_R8G8B8A8:
case AHARDWAREBUFFER_FORMAT_YCbCr_422_SP:
case AHARDWAREBUFFER_FORMAT_YCrCb_420_SP:
case AHARDWAREBUFFER_FORMAT_YCbCr_422_I:
diff --git a/libs/nativewindow/include/vndk/hardware_buffer.h b/libs/nativewindow/include/vndk/hardware_buffer.h
index 802edcc..7a4b31f 100644
--- a/libs/nativewindow/include/vndk/hardware_buffer.h
+++ b/libs/nativewindow/include/vndk/hardware_buffer.h
@@ -53,14 +53,6 @@
AHARDWAREBUFFER_FORMAT_IMPLEMENTATION_DEFINED = 0x22,
/* same as HAL_PIXEL_FORMAT_YCBCR_420_888 */
AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420 = 0x23,
- /* same as HAL_PIXEL_FORMAT_YCBCR_422_888 */
- AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_422 = 0x27,
- /* same as HAL_PIXEL_FORMAT_YCBCR_444_888 */
- AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_444 = 0x28,
- /* same as HAL_PIXEL_FORMAT_FLEX_RGB_888 */
- AHARDWAREBUFFER_FORMAT_FLEX_R8G8B8 = 0x29,
- /* same as HAL_PIXEL_FORMAT_FLEX_RGBA_8888 */
- AHARDWAREBUFFER_FORMAT_FLEX_R8G8B8A8 = 0x2A,
/* same as HAL_PIXEL_FORMAT_YCBCR_422_SP */
AHARDWAREBUFFER_FORMAT_YCbCr_422_SP = 0x10,
/* same as HAL_PIXEL_FORMAT_YCRCB_420_SP */
diff --git a/libs/sensor/OWNERS b/libs/sensor/OWNERS
index 6a38a1f..d4393d6 100644
--- a/libs/sensor/OWNERS
+++ b/libs/sensor/OWNERS
@@ -1,2 +1,2 @@
-ashutoshj@google.com
-pengxu@google.com
+arthuri@google.com
+bduddie@google.com
diff --git a/libs/ui/DebugUtils.cpp b/libs/ui/DebugUtils.cpp
index 17ebf80..d7e191d 100644
--- a/libs/ui/DebugUtils.cpp
+++ b/libs/ui/DebugUtils.cpp
@@ -22,6 +22,7 @@
#include <string>
using android::base::StringPrintf;
+using android::ColorMode;
std::string decodeStandard(android_dataspace dataspace) {
const uint32_t dataspaceSelect = (dataspace & HAL_DATASPACE_STANDARD_MASK);
@@ -197,37 +198,37 @@
decodeRange(dataspace).c_str());
}
-std::string decodeColorMode(android_color_mode colorMode) {
+std::string decodeColorMode(ColorMode colorMode) {
switch (colorMode) {
- case HAL_COLOR_MODE_NATIVE:
- return std::string("HAL_COLOR_MODE_NATIVE");
+ case ColorMode::NATIVE:
+ return std::string("ColorMode::NATIVE");
- case HAL_COLOR_MODE_STANDARD_BT601_625:
- return std::string("HAL_COLOR_MODE_BT601_625");
+ case ColorMode::STANDARD_BT601_625:
+ return std::string("ColorMode::BT601_625");
- case HAL_COLOR_MODE_STANDARD_BT601_625_UNADJUSTED:
- return std::string("HAL_COLOR_MODE_BT601_625_UNADJUSTED");
+ case ColorMode::STANDARD_BT601_625_UNADJUSTED:
+ return std::string("ColorMode::BT601_625_UNADJUSTED");
- case HAL_COLOR_MODE_STANDARD_BT601_525:
- return std::string("HAL_COLOR_MODE_BT601_525");
+ case ColorMode::STANDARD_BT601_525:
+ return std::string("ColorMode::BT601_525");
- case HAL_COLOR_MODE_STANDARD_BT601_525_UNADJUSTED:
- return std::string("HAL_COLOR_MODE_BT601_525_UNADJUSTED");
+ case ColorMode::STANDARD_BT601_525_UNADJUSTED:
+ return std::string("ColorMode::BT601_525_UNADJUSTED");
- case HAL_COLOR_MODE_STANDARD_BT709:
- return std::string("HAL_COLOR_MODE_BT709");
+ case ColorMode::STANDARD_BT709:
+ return std::string("ColorMode::BT709");
- case HAL_COLOR_MODE_DCI_P3:
- return std::string("HAL_COLOR_MODE_DCI_P3");
+ case ColorMode::DCI_P3:
+ return std::string("ColorMode::DCI_P3");
- case HAL_COLOR_MODE_SRGB:
- return std::string("HAL_COLOR_MODE_SRGB");
+ case ColorMode::SRGB:
+ return std::string("ColorMode::SRGB");
- case HAL_COLOR_MODE_ADOBE_RGB:
- return std::string("HAL_COLOR_MODE_ADOBE_RGB");
+ case ColorMode::ADOBE_RGB:
+ return std::string("ColorMode::ADOBE_RGB");
- case HAL_COLOR_MODE_DISPLAY_P3:
- return std::string("HAL_COLOR_MODE_DISPLAY_P3");
+ case ColorMode::DISPLAY_P3:
+ return std::string("ColorMode::DISPLAY_P3");
}
return android::base::StringPrintf("Unknown color mode %d", colorMode);
diff --git a/libs/ui/include/ui/DebugUtils.h b/libs/ui/include/ui/DebugUtils.h
index dad9446..3370107 100644
--- a/libs/ui/include/ui/DebugUtils.h
+++ b/libs/ui/include/ui/DebugUtils.h
@@ -16,7 +16,7 @@
#pragma once
-#include <system/graphics.h>
+#include <ui/GraphicsTypes.h>
#include <ui/PixelFormat.h>
#include <string>
@@ -29,6 +29,6 @@
std::string decodeTransfer(android_dataspace dataspace);
std::string decodeRange(android_dataspace dataspace);
std::string dataspaceDetails(android_dataspace dataspace);
-std::string decodeColorMode(android_color_mode colormode);
+std::string decodeColorMode(android::ColorMode colormode);
std::string decodePixelFormat(android::PixelFormat format);
std::string to_string(const android::Rect& rect);
diff --git a/libs/ui/include/ui/GraphicsTypes.h b/libs/ui/include/ui/GraphicsTypes.h
new file mode 100644
index 0000000..fa9a812
--- /dev/null
+++ b/libs/ui/include/ui/GraphicsTypes.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <android/hardware/graphics/common/1.1/types.h>
+#include <system/graphics.h>
+
+namespace android {
+
+using android::hardware::graphics::common::V1_0::ColorMode;
+
+} // namespace android
diff --git a/libs/vr/libbufferhub/buffer_hub_client.cpp b/libs/vr/libbufferhub/buffer_hub_client.cpp
index 8fe9dfb..6db09a9 100644
--- a/libs/vr/libbufferhub/buffer_hub_client.cpp
+++ b/libs/vr/libbufferhub/buffer_hub_client.cpp
@@ -395,25 +395,16 @@
}
BufferProducer::BufferProducer(uint32_t width, uint32_t height, uint32_t format,
- uint32_t usage, size_t user_metadata_size)
- : BufferProducer(width, height, format, usage, usage, user_metadata_size) {}
-
-BufferProducer::BufferProducer(uint32_t width, uint32_t height, uint32_t format,
- uint64_t producer_usage, uint64_t consumer_usage,
- size_t user_metadata_size)
+ uint64_t usage, size_t user_metadata_size)
: BASE(BufferHubRPC::kClientPath) {
ATRACE_NAME("BufferProducer::BufferProducer");
ALOGD_IF(TRACE,
"BufferProducer::BufferProducer: fd=%d width=%u height=%u format=%u "
- "producer_usage=%" PRIx64 " consumer_usage=%" PRIx64
- " user_metadata_size=%zu",
- event_fd(), width, height, format, producer_usage, consumer_usage,
- user_metadata_size);
+ "usage=%" PRIx64 " user_metadata_size=%zu",
+ event_fd(), width, height, format, usage, user_metadata_size);
- // (b/37881101) Deprecate producer/consumer usage
auto status = InvokeRemoteMethod<BufferHubRPC::CreateBuffer>(
- width, height, format, (producer_usage | consumer_usage),
- user_metadata_size);
+ width, height, format, usage, user_metadata_size);
if (!status) {
ALOGE(
"BufferProducer::BufferProducer: Failed to create producer buffer: %s",
@@ -431,26 +422,18 @@
}
}
-BufferProducer::BufferProducer(uint32_t usage, size_t size)
- : BufferProducer(usage, usage, size) {}
-
-BufferProducer::BufferProducer(uint64_t producer_usage, uint64_t consumer_usage,
- size_t size)
+BufferProducer::BufferProducer(uint64_t usage, size_t size)
: BASE(BufferHubRPC::kClientPath) {
ATRACE_NAME("BufferProducer::BufferProducer");
- ALOGD_IF(TRACE,
- "BufferProducer::BufferProducer: producer_usage=%" PRIx64
- " consumer_usage=%" PRIx64 " size=%zu",
- producer_usage, consumer_usage, size);
+ ALOGD_IF(TRACE, "BufferProducer::BufferProducer: usage=%" PRIx64 " size=%zu",
+ usage, size);
const int width = static_cast<int>(size);
const int height = 1;
const int format = HAL_PIXEL_FORMAT_BLOB;
const size_t user_metadata_size = 0;
- // (b/37881101) Deprecate producer/consumer usage
auto status = InvokeRemoteMethod<BufferHubRPC::CreateBuffer>(
- width, height, format, (producer_usage | consumer_usage),
- user_metadata_size);
+ width, height, format, usage, user_metadata_size);
if (!status) {
ALOGE("BufferProducer::BufferProducer: Failed to create blob: %s",
status.GetErrorMessage().c_str());
diff --git a/libs/vr/libbufferhub/include/private/dvr/buffer_hub_client.h b/libs/vr/libbufferhub/include/private/dvr/buffer_hub_client.h
index 8a4440f..c791250 100644
--- a/libs/vr/libbufferhub/include/private/dvr/buffer_hub_client.h
+++ b/libs/vr/libbufferhub/include/private/dvr/buffer_hub_client.h
@@ -111,10 +111,6 @@
uint32_t usage() const { return buffer_.usage(); }
uint32_t layer_count() const { return buffer_.layer_count(); }
- // TODO(b/37881101) Clean up producer/consumer usage.
- uint64_t producer_usage() const { return buffer_.usage(); }
- uint64_t consumer_usage() const { return buffer_.usage(); }
-
uint64_t GetQueueIndex() const { return metadata_header_->queue_index; }
void SetQueueIndex(uint64_t index) { metadata_header_->queue_index = index; }
@@ -230,14 +226,10 @@
// Constructs a buffer with the given geometry and parameters.
BufferProducer(uint32_t width, uint32_t height, uint32_t format,
- uint32_t usage, size_t metadata_size = 0);
- BufferProducer(uint32_t width, uint32_t height, uint32_t format,
- uint64_t producer_usage, uint64_t consumer_usage,
- size_t metadata_size);
+ uint64_t usage, size_t metadata_size = 0);
// Constructs a blob (flat) buffer with the given usage flags.
- BufferProducer(uint32_t usage, size_t size);
- BufferProducer(uint64_t producer_usage, uint64_t consumer_usage, size_t size);
+ BufferProducer(uint64_t usage, size_t size);
// Imports the given file handle to a producer channel, taking ownership.
explicit BufferProducer(LocalChannelHandle channel);
diff --git a/libs/vr/libbufferhub/include/private/dvr/native_buffer.h b/libs/vr/libbufferhub/include/private/dvr/native_buffer.h
deleted file mode 100644
index 140ffc5..0000000
--- a/libs/vr/libbufferhub/include/private/dvr/native_buffer.h
+++ /dev/null
@@ -1,179 +0,0 @@
-#ifndef ANDROID_DVR_NATIVE_BUFFER_H_
-#define ANDROID_DVR_NATIVE_BUFFER_H_
-
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-#include <log/log.h>
-#include <ui/ANativeObjectBase.h>
-#include <utils/RefBase.h>
-#include <nativebase/nativebase.h>
-
-#include <private/dvr/buffer_hub_client.h>
-
-namespace android {
-namespace dvr {
-
-// ANativeWindowBuffer is the abstraction Android HALs and frameworks use to
-// pass around hardware graphics buffers. The following classes implement this
-// abstraction with different DVR backing buffers, all of which provide
-// different semantics on top of ion/gralloc buffers.
-
-// An implementation of ANativeWindowBuffer backed by an IonBuffer.
-class NativeBuffer
- : public android::ANativeObjectBase<ANativeWindowBuffer, NativeBuffer,
- android::LightRefBase<NativeBuffer>> {
- public:
- static constexpr int kEmptyFence = -1;
-
- explicit NativeBuffer(const std::shared_ptr<IonBuffer>& buffer)
- : BASE(), buffer_(buffer), fence_(kEmptyFence) {
- ANativeWindowBuffer::width = buffer->width();
- ANativeWindowBuffer::height = buffer->height();
- ANativeWindowBuffer::stride = buffer->stride();
- ANativeWindowBuffer::format = buffer->format();
- ANativeWindowBuffer::usage = buffer->usage();
- handle = buffer_->handle();
- }
-
- virtual ~NativeBuffer() {}
-
- std::shared_ptr<IonBuffer> buffer() { return buffer_; }
- int fence() const { return fence_.Get(); }
-
- void SetFence(int fence) { fence_.Reset(fence); }
-
- private:
- friend class android::LightRefBase<NativeBuffer>;
-
- std::shared_ptr<IonBuffer> buffer_;
- pdx::LocalHandle fence_;
-
- NativeBuffer(const NativeBuffer&) = delete;
- void operator=(NativeBuffer&) = delete;
-};
-
-class NativeBufferProducer : public android::ANativeObjectBase<
- ANativeWindowBuffer, NativeBufferProducer,
- android::LightRefBase<NativeBufferProducer>> {
- public:
- static constexpr int kEmptyFence = -1;
-
- NativeBufferProducer(const std::shared_ptr<BufferProducer>& buffer,
- EGLDisplay display, uint32_t surface_buffer_index)
- : BASE(),
- buffer_(buffer),
- surface_buffer_index_(surface_buffer_index),
- display_(display) {
- ANativeWindowBuffer::width = buffer_->width();
- ANativeWindowBuffer::height = buffer_->height();
- ANativeWindowBuffer::stride = buffer_->stride();
- ANativeWindowBuffer::format = buffer_->format();
- ANativeWindowBuffer::usage = buffer_->usage();
- ANativeWindowBuffer::handle = buffer_->native_handle();
- if (display_) {
- image_khr_ =
- eglCreateImageKHR(display_, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
- static_cast<ANativeWindowBuffer*>(this), nullptr);
- } else {
- image_khr_ = EGL_NO_IMAGE_KHR;
- }
- }
-
- explicit NativeBufferProducer(const std::shared_ptr<BufferProducer>& buffer)
- : NativeBufferProducer(buffer, nullptr, 0) {}
-
- virtual ~NativeBufferProducer() {
- if (image_khr_ != EGL_NO_IMAGE_KHR)
- eglDestroyImageKHR(display_, image_khr_);
- }
-
- EGLImageKHR image_khr() const { return image_khr_; }
- std::shared_ptr<BufferProducer> buffer() const { return buffer_; }
- int release_fence() const { return release_fence_.Get(); }
- uint32_t surface_buffer_index() const { return surface_buffer_index_; }
-
- // Return the release fence, passing ownership to the caller.
- pdx::LocalHandle ClaimReleaseFence() { return std::move(release_fence_); }
-
- // Post the buffer consumer, closing the acquire and release fences.
- int Post(int acquire_fence, uint64_t sequence) {
- release_fence_.Close();
- return buffer_->Post(pdx::LocalHandle(acquire_fence), sequence);
- }
-
- // Gain the buffer producer, closing the previous release fence if valid.
- int Gain() { return buffer_->Gain(&release_fence_); }
-
- // Asynchronously gain the buffer, closing the previous release fence.
- int GainAsync() {
- release_fence_.Close();
- return buffer_->GainAsync();
- }
-
- private:
- friend class android::LightRefBase<NativeBufferProducer>;
-
- std::shared_ptr<BufferProducer> buffer_;
- pdx::LocalHandle release_fence_;
- EGLImageKHR image_khr_;
- uint32_t surface_buffer_index_;
- EGLDisplay display_;
-
- NativeBufferProducer(const NativeBufferProducer&) = delete;
- void operator=(NativeBufferProducer&) = delete;
-};
-
-// NativeBufferConsumer is an implementation of ANativeWindowBuffer backed by a
-// BufferConsumer.
-class NativeBufferConsumer : public android::ANativeObjectBase<
- ANativeWindowBuffer, NativeBufferConsumer,
- android::LightRefBase<NativeBufferConsumer>> {
- public:
- static constexpr int kEmptyFence = -1;
-
- explicit NativeBufferConsumer(const std::shared_ptr<BufferConsumer>& buffer)
- : BASE(), buffer_(buffer), acquire_fence_(kEmptyFence), sequence_(0) {
- ANativeWindowBuffer::width = buffer_->width();
- ANativeWindowBuffer::height = buffer_->height();
- ANativeWindowBuffer::stride = buffer_->stride();
- ANativeWindowBuffer::format = buffer_->format();
- ANativeWindowBuffer::usage = buffer_->usage();
- handle = buffer_->native_handle();
- }
-
- virtual ~NativeBufferConsumer() {}
-
- std::shared_ptr<BufferConsumer> buffer() const { return buffer_; }
- int acquire_fence() const { return acquire_fence_.Get(); }
- uint64_t sequence() const { return sequence_; }
-
- // Return the acquire fence, passing ownership to the caller.
- pdx::LocalHandle ClaimAcquireFence() { return std::move(acquire_fence_); }
-
- // Acquire the underlying buffer consumer, closing the previous acquire fence
- // if valid.
- int Acquire() { return buffer_->Acquire(&acquire_fence_, &sequence_); }
-
- // Release the buffer consumer, closing the acquire and release fences if
- // valid.
- int Release(int release_fence) {
- acquire_fence_.Close();
- sequence_ = 0;
- return buffer_->Release(pdx::LocalHandle(release_fence));
- }
-
- private:
- friend class android::LightRefBase<NativeBufferConsumer>;
-
- std::shared_ptr<BufferConsumer> buffer_;
- pdx::LocalHandle acquire_fence_;
- uint64_t sequence_;
-
- NativeBufferConsumer(const NativeBufferConsumer&) = delete;
- void operator=(NativeBufferConsumer&) = delete;
-};
-
-} // namespace dvr
-} // namespace android
-
-#endif // ANDROID_DVR_NATIVE_BUFFER_H_
diff --git a/libs/vr/libdisplay/display_client.cpp b/libs/vr/libdisplay/display_client.cpp
index 442c82d..f67e258 100644
--- a/libs/vr/libdisplay/display_client.cpp
+++ b/libs/vr/libdisplay/display_client.cpp
@@ -9,7 +9,6 @@
#include <mutex>
#include <private/dvr/display_protocol.h>
-#include <private/dvr/native_buffer.h>
using android::pdx::ErrorStatus;
using android::pdx::LocalHandle;
diff --git a/libs/vr/libdvr/tests/dvr_api_test.h b/libs/vr/libdvr/tests/dvr_api_test.h
index 648af75..d8359e7 100644
--- a/libs/vr/libdvr/tests/dvr_api_test.h
+++ b/libs/vr/libdvr/tests/dvr_api_test.h
@@ -3,8 +3,6 @@
#include <gtest/gtest.h>
-#define ASSERT_NOT_NULL(x) ASSERT_TRUE((x) != nullptr)
-
/** DvrTestBase loads the libdvr.so at runtime and get the Dvr API version 1. */
class DvrApiTest : public ::testing::Test {
protected:
@@ -17,11 +15,11 @@
// https://github.com/android-ndk/ndk/issues/360
flags |= RTLD_NODELETE;
platform_handle_ = dlopen("libdvr.so", flags);
- ASSERT_NOT_NULL(platform_handle_) << "Dvr shared library missing.";
+ ASSERT_NE(nullptr, platform_handle_) << "Dvr shared library missing.";
auto dvr_get_api = reinterpret_cast<decltype(&dvrGetApi)>(
dlsym(platform_handle_, "dvrGetApi"));
- ASSERT_NOT_NULL(dvr_get_api) << "Platform library missing dvrGetApi.";
+ ASSERT_NE(nullptr, dvr_get_api) << "Platform library missing dvrGetApi.";
ASSERT_EQ(dvr_get_api(&api_, sizeof(api_), /*version=*/1), 0)
<< "Unable to find compatible Dvr API.";
diff --git a/libs/vr/libdvr/tests/dvr_display-test.cpp b/libs/vr/libdvr/tests/dvr_display-test.cpp
index 1165573..c72f940 100644
--- a/libs/vr/libdvr/tests/dvr_display-test.cpp
+++ b/libs/vr/libdvr/tests/dvr_display-test.cpp
@@ -16,20 +16,58 @@
class DvrDisplayTest : public DvrApiTest {
protected:
+ void SetUp() override {
+ DvrApiTest::SetUp();
+ int ret = api_.GetNativeDisplayMetrics(sizeof(display_metrics_),
+ &display_metrics_);
+ ASSERT_EQ(ret, 0) << "Failed to get display metrics.";
+ ALOGD(
+ "display_width: %d, display_height: %d, display_x_dpi: %d, "
+ "display_y_dpi: %d, vsync_period_ns: %d.",
+ display_metrics_.display_width, display_metrics_.display_height,
+ display_metrics_.display_x_dpi, display_metrics_.display_y_dpi,
+ display_metrics_.vsync_period_ns);
+ }
+
void TearDown() override {
if (write_queue_ != nullptr) {
api_.WriteBufferQueueDestroy(write_queue_);
write_queue_ = nullptr;
}
+ if (direct_surface_ != nullptr) {
+ api_.SurfaceDestroy(direct_surface_);
+ direct_surface_ = nullptr;
+ }
DvrApiTest::TearDown();
}
+ /* Convert a write buffer to an android hardware buffer and fill in
+ * color_textures evenly to the buffer.
+ * AssertionError if the width of the buffer is not equal to the input width,
+ * AssertionError if the height of the buffer is not equal to the input
+ * height.
+ */
+ void FillWriteBuffer(DvrWriteBuffer* write_buffer,
+ const std::vector<uint32_t>& color_textures,
+ uint32_t width, uint32_t height);
+
+ // Write buffer queue properties.
+ static constexpr uint64_t kUsage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE |
+ AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT |
+ AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN;
+ uint32_t kFormat = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
+ static constexpr size_t kMetadataSize = 0;
+ static constexpr int kTimeoutMs = 1000; // Time for getting buffer.
+ uint32_t kLayerCount = 1;
DvrWriteBufferQueue* write_queue_ = nullptr;
+ DvrSurface* direct_surface_ = nullptr;
+
+ // Device display properties.
+ DvrNativeDisplayMetrics display_metrics_;
};
-TEST_F(DvrDisplayTest, DisplaySingleColor) {
- // Create direct surface.
- DvrSurface* direct_surface = nullptr;
+TEST_F(DvrDisplayTest, DisplayWithOneBuffer) {
+ // Create a direct surface.
std::vector<DvrSurfaceAttribute> direct_surface_attributes = {
{.key = DVR_SURFACE_ATTRIBUTE_DIRECT,
.value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
@@ -43,73 +81,32 @@
};
int ret =
api_.SurfaceCreate(direct_surface_attributes.data(),
- direct_surface_attributes.size(), &direct_surface);
+ direct_surface_attributes.size(), &direct_surface_);
ASSERT_EQ(ret, 0) << "Failed to create direct surface.";
- // Get screen dimension.
- DvrNativeDisplayMetrics display_metrics;
- ret = api_.GetNativeDisplayMetrics(sizeof(display_metrics), &display_metrics);
- ASSERT_EQ(ret, 0) << "Failed to get display metrics.";
- ALOGD(
- "display_width: %d, display_height: %d, display_x_dpi: %d, "
- "display_y_dpi: %d, vsync_period_ns: %d.",
- display_metrics.display_width, display_metrics.display_height,
- display_metrics.display_x_dpi, display_metrics.display_y_dpi,
- display_metrics.vsync_period_ns);
-
// Create a buffer queue with the direct surface.
- constexpr uint32_t kLayerCount = 1;
- constexpr uint64_t kUsage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE |
- AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT |
- AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN;
- constexpr uint32_t kFormat = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
constexpr size_t kCapacity = 1;
- constexpr size_t kMetadataSize = 0;
- uint32_t width = display_metrics.display_width;
- uint32_t height = display_metrics.display_height;
+ uint32_t width = display_metrics_.display_width;
+ uint32_t height = display_metrics_.display_height;
ret = api_.SurfaceCreateWriteBufferQueue(
- direct_surface, width, height, kFormat, kLayerCount, kUsage, kCapacity,
+ direct_surface_, width, height, kFormat, kLayerCount, kUsage, kCapacity,
kMetadataSize, &write_queue_);
EXPECT_EQ(0, ret) << "Failed to create buffer queue.";
- ASSERT_NOT_NULL(write_queue_) << "Write buffer queue should not be null.";
+ ASSERT_NE(nullptr, write_queue_) << "Write buffer queue should not be null.";
// Get buffer from WriteBufferQueue.
DvrWriteBuffer* write_buffer = nullptr;
- constexpr int kTimeoutMs = 1000;
DvrNativeBufferMetadata out_meta;
int out_fence_fd = -1;
ret = api_.WriteBufferQueueGainBuffer(write_queue_, kTimeoutMs, &write_buffer,
&out_meta, &out_fence_fd);
EXPECT_EQ(0, ret) << "Failed to get the buffer.";
- ASSERT_NOT_NULL(write_buffer) << "Gained buffer should not be null.";
+ ASSERT_NE(nullptr, write_buffer) << "Gained buffer should not be null.";
- // Convert to an android hardware buffer.
- AHardwareBuffer* ah_buffer{nullptr};
- ret = api_.WriteBufferGetAHardwareBuffer(write_buffer, &ah_buffer);
- EXPECT_EQ(0, ret) << "Failed to get a hardware buffer from the write buffer.";
- ASSERT_NOT_NULL(ah_buffer) << "AHardware buffer should not be null.";
-
- // Change the content of the android hardware buffer.
- void* buffer_data{nullptr};
- int32_t fence = -1;
- ret = AHardwareBuffer_lock(ah_buffer, AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN,
- fence, nullptr, &buffer_data);
- EXPECT_EQ(0, ret) << "Failed to lock the hardware buffer.";
- ASSERT_NOT_NULL(buffer_data) << "Buffer data should not be null.";
-
- uint32_t color_texture = 0xff0000ff; // Red color in RGBA.
- for (uint32_t i = 0; i < width * height; ++i) {
- memcpy(reinterpret_cast<void*>(reinterpret_cast<int64_t>(buffer_data) +
- i * sizeof(color_texture)),
- &color_texture, sizeof(color_texture));
- }
-
- fence = -1;
- ret = AHardwareBuffer_unlock(ah_buffer, &fence);
- EXPECT_EQ(0, ret) << "Failed to unlock the hardware buffer.";
-
- // Release the android hardware buffer.
- AHardwareBuffer_release(ah_buffer);
+ // Color the write buffer.
+ FillWriteBuffer(write_buffer,
+ {0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000},
+ width, height);
// Post buffer.
int ready_fence_fd = -1;
@@ -118,4 +115,237 @@
EXPECT_EQ(0, ret) << "Failed to post the buffer.";
sleep(5); // For visual check on the device under test.
+ // Should observe three primary colors on the screen center.
+}
+
+TEST_F(DvrDisplayTest, DisplayWithDoubleBuffering) {
+ // Create a direct surface.
+ std::vector<DvrSurfaceAttribute> direct_surface_attributes = {
+ {.key = DVR_SURFACE_ATTRIBUTE_DIRECT,
+ .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
+ .value.bool_value = true},
+ {.key = DVR_SURFACE_ATTRIBUTE_Z_ORDER,
+ .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_INT32,
+ .value.int32_value = 10},
+ {.key = DVR_SURFACE_ATTRIBUTE_VISIBLE,
+ .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
+ .value.bool_value = true},
+ };
+ int ret =
+ api_.SurfaceCreate(direct_surface_attributes.data(),
+ direct_surface_attributes.size(), &direct_surface_);
+ ASSERT_EQ(ret, 0) << "Failed to create direct surface.";
+
+ // Create a buffer queue with the direct surface.
+ constexpr size_t kCapacity = 2;
+ uint32_t width = display_metrics_.display_width;
+ uint32_t height = display_metrics_.display_height;
+ ret = api_.SurfaceCreateWriteBufferQueue(
+ direct_surface_, width, height, kFormat, kLayerCount, kUsage, kCapacity,
+ kMetadataSize, &write_queue_);
+ EXPECT_EQ(0, ret) << "Failed to create buffer queue.";
+ ASSERT_NE(nullptr, write_queue_) << "Write buffer queue should not be null.";
+
+ int num_display_cycles_in_5s = 5 / (display_metrics_.vsync_period_ns / 1e9);
+ ALOGD("The number of display cycles: %d", num_display_cycles_in_5s);
+ int bufferhub_id_prev_write_buffer = -1;
+ for (int i = 0; i < num_display_cycles_in_5s; ++i) {
+ // Get a buffer from the WriteBufferQueue.
+ DvrWriteBuffer* write_buffer = nullptr;
+ DvrNativeBufferMetadata out_meta;
+ int out_fence_fd = -1;
+ ret = api_.WriteBufferQueueGainBuffer(
+ write_queue_, kTimeoutMs, &write_buffer, &out_meta, &out_fence_fd);
+ EXPECT_EQ(0, ret) << "Failed to get the a write buffer.";
+ ASSERT_NE(nullptr, write_buffer) << "The gained buffer should not be null.";
+
+ int bufferhub_id = api_.WriteBufferGetId(write_buffer);
+ ALOGD("Display cycle: %d, bufferhub id of the write buffer: %d", i,
+ bufferhub_id);
+ EXPECT_NE(bufferhub_id_prev_write_buffer, bufferhub_id)
+ << "Double buffering should be using the two buffers in turns, not "
+ "reusing the same write buffer.";
+ bufferhub_id_prev_write_buffer = bufferhub_id;
+
+ // Color the write buffer.
+ if (i % 2) {
+ FillWriteBuffer(write_buffer, {0xffff0000, 0xff00ff00, 0xff0000ff}, width,
+ height);
+ } else {
+ FillWriteBuffer(write_buffer, {0xff00ff00, 0xff0000ff, 0xffff0000}, width,
+ height);
+ }
+
+ // Post the write buffer.
+ int ready_fence_fd = -1;
+ ret = api_.WriteBufferQueuePostBuffer(write_queue_, write_buffer, &out_meta,
+ ready_fence_fd);
+ EXPECT_EQ(0, ret) << "Failed to post the buffer.";
+ }
+ // Should observe blinking screen in secondary colors
+ // although it is actually displaying primary colors.
+}
+
+TEST_F(DvrDisplayTest, DisplayWithTwoHardwareLayers) {
+ // Create the direct_surface_0 of z order 10 and direct_surface_1 of z
+ // order 11.
+ DvrSurface* direct_surface_0 = nullptr;
+ std::vector<DvrSurfaceAttribute> direct_surface_0_attributes = {
+ {.key = DVR_SURFACE_ATTRIBUTE_DIRECT,
+ .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
+ .value.bool_value = true},
+ {.key = DVR_SURFACE_ATTRIBUTE_Z_ORDER,
+ .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_INT32,
+ .value.int32_value = 10},
+ {.key = DVR_SURFACE_ATTRIBUTE_VISIBLE,
+ .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
+ .value.bool_value = true},
+ };
+ int ret =
+ api_.SurfaceCreate(direct_surface_0_attributes.data(),
+ direct_surface_0_attributes.size(), &direct_surface_0);
+ EXPECT_EQ(ret, 0) << "Failed to create direct surface.";
+
+ DvrSurface* direct_surface_1 = nullptr;
+ std::vector<DvrSurfaceAttribute> direct_surface_1_attributes = {
+ {.key = DVR_SURFACE_ATTRIBUTE_DIRECT,
+ .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
+ .value.bool_value = true},
+ {.key = DVR_SURFACE_ATTRIBUTE_Z_ORDER,
+ .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_INT32,
+ .value.int32_value = 11},
+ {.key = DVR_SURFACE_ATTRIBUTE_VISIBLE,
+ .value.type = DVR_SURFACE_ATTRIBUTE_TYPE_BOOL,
+ .value.bool_value = true},
+ };
+ ret =
+ api_.SurfaceCreate(direct_surface_1_attributes.data(),
+ direct_surface_1_attributes.size(), &direct_surface_1);
+ EXPECT_EQ(ret, 0) << "Failed to create direct surface.";
+
+ // Create a buffer queue for each of the direct surfaces.
+ constexpr size_t kCapacity = 1;
+ uint32_t width = display_metrics_.display_width;
+ uint32_t height = display_metrics_.display_height;
+
+ DvrWriteBufferQueue* write_queue_0 = nullptr;
+ ret = api_.SurfaceCreateWriteBufferQueue(
+ direct_surface_0, width, height, kFormat, kLayerCount, kUsage, kCapacity,
+ kMetadataSize, &write_queue_0);
+ EXPECT_EQ(0, ret) << "Failed to create buffer queue.";
+ EXPECT_NE(nullptr, write_queue_0) << "Write buffer queue should not be null.";
+
+ DvrWriteBufferQueue* write_queue_1 = nullptr;
+ ret = api_.SurfaceCreateWriteBufferQueue(
+ direct_surface_1, width, height, kFormat, kLayerCount, kUsage, kCapacity,
+ kMetadataSize, &write_queue_1);
+ EXPECT_EQ(0, ret) << "Failed to create buffer queue.";
+ EXPECT_NE(nullptr, write_queue_1) << "Write buffer queue should not be null.";
+
+ // Get a buffer from each of the write buffer queues.
+ DvrWriteBuffer* write_buffer_0 = nullptr;
+ DvrNativeBufferMetadata out_meta_0;
+ int out_fence_fd = -1;
+ ret = api_.WriteBufferQueueGainBuffer(
+ write_queue_0, kTimeoutMs, &write_buffer_0, &out_meta_0, &out_fence_fd);
+ EXPECT_EQ(0, ret) << "Failed to get the buffer.";
+ EXPECT_NE(nullptr, write_buffer_0) << "Gained buffer should not be null.";
+
+ DvrWriteBuffer* write_buffer_1 = nullptr;
+ DvrNativeBufferMetadata out_meta_1;
+ out_fence_fd = -1;
+ ret = api_.WriteBufferQueueGainBuffer(
+ write_queue_1, kTimeoutMs, &write_buffer_1, &out_meta_1, &out_fence_fd);
+ EXPECT_EQ(0, ret) << "Failed to get the buffer.";
+ EXPECT_NE(nullptr, write_buffer_1) << "Gained buffer should not be null.";
+
+ // Color the write buffers.
+ FillWriteBuffer(write_buffer_0, {0xffff0000, 0xff00ff00, 0xff0000ff}, width,
+ height);
+ FillWriteBuffer(write_buffer_1, {0x7f00ff00, 0x7f0000ff, 0x7fff0000}, width,
+ height);
+
+ // Post buffers.
+ int ready_fence_fd = -1;
+ ret = api_.WriteBufferQueuePostBuffer(write_queue_0, write_buffer_0,
+ &out_meta_0, ready_fence_fd);
+ EXPECT_EQ(0, ret) << "Failed to post the buffer.";
+
+ ready_fence_fd = -1;
+ ret = api_.WriteBufferQueuePostBuffer(write_queue_1, write_buffer_1,
+ &out_meta_1, ready_fence_fd);
+ EXPECT_EQ(0, ret) << "Failed to post the buffer.";
+
+ sleep(5); // For visual check on the device under test.
+ // Should observe three secondary colors.
+
+ // Test finished. Clean up buffers and surfaces.
+ if (write_queue_0 != nullptr) {
+ api_.WriteBufferQueueDestroy(write_queue_0);
+ write_queue_0 = nullptr;
+ }
+ if (write_queue_1 != nullptr) {
+ api_.WriteBufferQueueDestroy(write_queue_1);
+ write_queue_1 = nullptr;
+ }
+ if (direct_surface_0 != nullptr) {
+ api_.SurfaceDestroy(direct_surface_0);
+ }
+ if (direct_surface_1 != nullptr) {
+ api_.SurfaceDestroy(direct_surface_1);
+ }
+}
+
+void DvrDisplayTest::FillWriteBuffer(
+ DvrWriteBuffer* write_buffer, const std::vector<uint32_t>& color_textures,
+ uint32_t width, uint32_t height) {
+ uint32_t num_colors = color_textures.size();
+ // Convert the first write buffer to an android hardware buffer.
+ AHardwareBuffer* ah_buffer = nullptr;
+ int ret = api_.WriteBufferGetAHardwareBuffer(write_buffer, &ah_buffer);
+ ASSERT_EQ(0, ret) << "Failed to get a hardware buffer from the write buffer.";
+ ASSERT_NE(nullptr, ah_buffer) << "AHardware buffer should not be null.";
+ AHardwareBuffer_Desc ah_buffer_describe;
+ AHardwareBuffer_describe(ah_buffer, &ah_buffer_describe);
+ ASSERT_EQ(ah_buffer_describe.format, kFormat)
+ << "The format of the android hardware buffer is wrong.";
+ ASSERT_EQ(ah_buffer_describe.layers, kLayerCount)
+ << "The obtained android hardware buffer should have 2 layers.";
+ ASSERT_EQ(ah_buffer_describe.width, width)
+ << "The obtained android hardware buffer width is wrong.";
+ ASSERT_EQ(ah_buffer_describe.height, height)
+ << "The obtained android hardware buffer height is wrong.";
+ // Change the content of the android hardware buffer.
+ void* buffer_data = nullptr;
+ int32_t fence = -1;
+ ret = AHardwareBuffer_lock(ah_buffer, AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN,
+ fence, nullptr, &buffer_data);
+ ASSERT_EQ(0, ret) << "Failed to lock the hardware buffer.";
+ ASSERT_NE(nullptr, buffer_data) << "Buffer data should not be null.";
+
+ uint32_t num_pixels = width * height / num_colors;
+ for (uint32_t color_index = 0; color_index < num_colors - 1; ++color_index) {
+ uint32_t color_texture = color_textures[color_index];
+ for (uint32_t i = 0; i < num_pixels; ++i) {
+ memcpy(reinterpret_cast<void*>(reinterpret_cast<int64_t>(buffer_data) +
+ (i + num_pixels * color_index) *
+ sizeof(color_texture)),
+ &color_texture, sizeof(color_texture));
+ }
+ }
+ uint32_t color_texture = color_textures[num_colors - 1];
+ uint32_t num_colored_pixels = num_pixels * (num_colors - 1);
+ num_pixels = width * height - num_colored_pixels;
+ for (uint32_t i = 0; i < num_pixels; ++i) {
+ memcpy(reinterpret_cast<void*>(reinterpret_cast<int64_t>(buffer_data) +
+ (i + num_colored_pixels) *
+ sizeof(color_texture)),
+ &color_texture, sizeof(color_texture));
+ }
+ fence = -1;
+ ret = AHardwareBuffer_unlock(ah_buffer, &fence);
+ EXPECT_EQ(0, ret) << "Failed to unlock the hardware buffer.";
+
+ // Release the android hardware buffer.
+ AHardwareBuffer_release(ah_buffer);
}
diff --git a/libs/vr/libpdx_uds/service_endpoint.cpp b/libs/vr/libpdx_uds/service_endpoint.cpp
index 0ee77f4..32d40e8 100644
--- a/libs/vr/libpdx_uds/service_endpoint.cpp
+++ b/libs/vr/libpdx_uds/service_endpoint.cpp
@@ -594,9 +594,10 @@
if (socket_fd_ && event.data.fd == socket_fd_.Get()) {
auto status = AcceptConnection(message);
- if (!status)
- return status;
- return ReenableEpollEvent(socket_fd_.Borrow());
+ auto reenable_status = ReenableEpollEvent(socket_fd_.Borrow());
+ if (!reenable_status)
+ return reenable_status;
+ return status;
}
BorrowedHandle channel_fd{event.data.fd};
diff --git a/libs/vr/libvrflinger/Android.bp b/libs/vr/libvrflinger/Android.bp
index 23a9853..4dc669b 100644
--- a/libs/vr/libvrflinger/Android.bp
+++ b/libs/vr/libvrflinger/Android.bp
@@ -39,6 +39,7 @@
"android.frameworks.vr.composer@1.0",
"android.hardware.graphics.allocator@2.0",
"android.hardware.graphics.composer@2.1",
+ "android.hardware.graphics.composer@2.2",
"libbinder",
"libbase",
"libbufferhubqueue",
@@ -62,6 +63,7 @@
headerLibraries = [
"android.hardware.graphics.composer@2.1-command-buffer",
+ "android.hardware.graphics.composer@2.2-command-buffer",
"libdvr_headers",
"libsurfaceflinger_headers",
]
@@ -70,6 +72,7 @@
srcs: sourceFiles,
export_include_dirs: includeFiles,
+ clang: true,
cflags: [
"-DLOG_TAG=\"vr_flinger\"",
"-DTRACE=0",
@@ -81,6 +84,9 @@
"-Wno-error=sign-compare", // to fix later
"-Wno-unused-variable",
],
+ cppflags: [
+ "-std=c++1z"
+ ],
shared_libs: sharedLibraries,
whole_static_libs: staticLibraries,
header_libs: headerLibraries,
diff --git a/libs/vr/libvrflinger/display_service.cpp b/libs/vr/libvrflinger/display_service.cpp
index a18ff1a..87162c0 100644
--- a/libs/vr/libvrflinger/display_service.cpp
+++ b/libs/vr/libvrflinger/display_service.cpp
@@ -177,12 +177,12 @@
Status<display::Metrics> DisplayService::OnGetMetrics(
pdx::Message& /*message*/) {
- return {{static_cast<uint32_t>(GetDisplayMetrics().width),
- static_cast<uint32_t>(GetDisplayMetrics().height),
- static_cast<uint32_t>(GetDisplayMetrics().dpi.x),
- static_cast<uint32_t>(GetDisplayMetrics().dpi.y),
- static_cast<uint32_t>(
- hardware_composer_.native_display_metrics().vsync_period_ns),
+ const auto& params = hardware_composer_.GetPrimaryDisplayParams();
+ return {{static_cast<uint32_t>(params.width),
+ static_cast<uint32_t>(params.height),
+ static_cast<uint32_t>(params.dpi.x),
+ static_cast<uint32_t>(params.dpi.y),
+ static_cast<uint32_t>(params.vsync_period_ns),
0,
0,
0,
diff --git a/libs/vr/libvrflinger/display_service.h b/libs/vr/libvrflinger/display_service.h
index 316f15a..3090bd1 100644
--- a/libs/vr/libvrflinger/display_service.h
+++ b/libs/vr/libvrflinger/display_service.h
@@ -65,10 +65,6 @@
hardware_composer_.SetVSyncCallback(callback);
}
- HWCDisplayMetrics GetDisplayMetrics() {
- return hardware_composer_.display_metrics();
- }
-
void GrantDisplayOwnership() { hardware_composer_.Enable(); }
void SeizeDisplayOwnership() { hardware_composer_.Disable(); }
void OnBootFinished() { hardware_composer_.OnBootFinished(); }
diff --git a/libs/vr/libvrflinger/hardware_composer.cpp b/libs/vr/libvrflinger/hardware_composer.cpp
index be8a721..44ce78c 100644
--- a/libs/vr/libvrflinger/hardware_composer.cpp
+++ b/libs/vr/libvrflinger/hardware_composer.cpp
@@ -45,17 +45,22 @@
namespace {
-const char kBacklightBrightnessSysFile[] =
- "/sys/class/leds/lcd-backlight/brightness";
-
const char kDvrPerformanceProperty[] = "sys.dvr.performance";
const char kDvrStandaloneProperty[] = "ro.boot.vr";
const char kRightEyeOffsetProperty[] = "dvr.right_eye_offset_ns";
+const char kUseExternalDisplayProperty[] = "persist.vr.use_external_display";
+
// How long to wait after boot finishes before we turn the display off.
constexpr int kBootFinishedDisplayOffTimeoutSec = 10;
+constexpr int kDefaultDisplayWidth = 1920;
+constexpr int kDefaultDisplayHeight = 1080;
+constexpr int64_t kDefaultVsyncPeriodNs = 16666667;
+// Hardware composer reports dpi as dots per thousand inches (dpi * 1000).
+constexpr int kDefaultDpi = 400000;
+
// Get time offset from a vsync to when the pose for that vsync should be
// predicted out to. For example, if scanout gets halfway through the frame
// at the halfway point between vsyncs, then this could be half the period.
@@ -112,6 +117,11 @@
#define TRACE_FORMAT(format, ...) \
TraceArgs PASTE(__tracer, __LINE__) { format, ##__VA_ARGS__ }
+// Returns "primary" or "external". Useful for writing more readable logs.
+const char* GetDisplayName(bool is_primary) {
+ return is_primary ? "primary" : "external";
+}
+
} // anonymous namespace
HardwareComposer::HardwareComposer()
@@ -135,42 +145,7 @@
request_display_callback_ = request_display_callback;
- HWC::Error error = HWC::Error::None;
-
- Hwc2::Config config;
- error = composer->getActiveConfig(primary_display_id, &config);
-
- if (error != HWC::Error::None) {
- ALOGE("HardwareComposer: Failed to get current display config : %d",
- config);
- return false;
- }
-
- error = GetDisplayMetrics(composer, primary_display_id, config,
- &native_display_metrics_);
-
- if (error != HWC::Error::None) {
- ALOGE(
- "HardwareComposer: Failed to get display attributes for current "
- "configuration : %d",
- error.value);
- return false;
- }
-
- ALOGI(
- "HardwareComposer: primary display attributes: width=%d height=%d "
- "vsync_period_ns=%d DPI=%dx%d",
- native_display_metrics_.width, native_display_metrics_.height,
- native_display_metrics_.vsync_period_ns, native_display_metrics_.dpi.x,
- native_display_metrics_.dpi.y);
-
- // Set the display metrics but never use rotation to avoid the long latency of
- // rotation processing in hwc.
- display_transform_ = HWC_TRANSFORM_NONE;
- display_metrics_ = native_display_metrics_;
-
- // Setup the display metrics used by all Layer instances.
- Layer::SetDisplayMetrics(native_display_metrics_);
+ primary_display_ = GetDisplayParams(composer, primary_display_id, true);
post_thread_event_fd_.Reset(eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK));
LOG_ALWAYS_FATAL_IF(
@@ -239,50 +214,38 @@
}
}
+void HardwareComposer::CreateComposer() {
+ if (composer_)
+ return;
+ composer_.reset(new Hwc2::impl::Composer("default"));
+ composer_callback_ = new ComposerCallback;
+ composer_->registerCallback(composer_callback_);
+ LOG_ALWAYS_FATAL_IF(!composer_callback_->GotFirstHotplug(),
+ "Registered composer callback but didn't get hotplug for primary"
+ " display");
+}
+
void HardwareComposer::OnPostThreadResumed() {
- // Phones create a new composer client on resume and destroy it on pause.
- // Standalones only create the composer client once and then use SetPowerMode
- // to control the screen on pause/resume.
- if (!is_standalone_device_ || !composer_) {
- composer_.reset(new Hwc2::impl::Composer("default"));
- composer_callback_ = new ComposerCallback;
- composer_->registerCallback(composer_callback_);
- LOG_ALWAYS_FATAL_IF(!composer_callback_->HasDisplayId(),
- "Registered composer callback but didn't get primary display");
- Layer::SetComposer(composer_.get());
- Layer::SetDisplayId(composer_callback_->GetDisplayId());
- } else {
- SetPowerMode(true);
- }
-
- EnableVsync(true);
-
- // TODO(skiazyk): We need to do something about accessing this directly,
- // supposedly there is a backlight service on the way.
- // TODO(steventhomas): When we change the backlight setting, will surface
- // flinger (or something else) set it back to its original value once we give
- // control of the display back to surface flinger?
- SetBacklightBrightness(255);
+ ALOGI("OnPostThreadResumed");
+ EnableDisplay(*target_display_, true);
// Trigger target-specific performance mode change.
property_set(kDvrPerformanceProperty, "performance");
}
void HardwareComposer::OnPostThreadPaused() {
+ ALOGI("OnPostThreadPaused");
retire_fence_fds_.clear();
layers_.clear();
- if (composer_) {
- EnableVsync(false);
- }
-
+ // Phones create a new composer client on resume and destroy it on pause.
+ // Standalones only create the composer client once and then use SetPowerMode
+ // to control the screen on pause/resume.
if (!is_standalone_device_) {
composer_callback_ = nullptr;
composer_.reset(nullptr);
- Layer::SetComposer(nullptr);
- Layer::SetDisplayId(0);
} else {
- SetPowerMode(false);
+ EnableDisplay(*target_display_, false);
}
// Trigger target-specific performance mode change.
@@ -315,28 +278,55 @@
composer_->validateDisplay(display, &num_types, &num_requests);
if (error == HWC2_ERROR_HAS_CHANGES) {
- // TODO(skiazyk): We might need to inspect the requested changes first, but
- // so far it seems like we shouldn't ever hit a bad state.
- // error = hwc2_funcs_.accept_display_changes_fn_(hardware_composer_device_,
- // display);
+ ALOGE("Hardware composer has requested composition changes, "
+ "which we don't support.");
+ // Accept the changes anyway and see if we can get something on the screen.
error = composer_->acceptDisplayChanges(display);
}
return error;
}
-HWC::Error HardwareComposer::EnableVsync(bool enabled) {
- return composer_->setVsyncEnabled(
- composer_callback_->GetDisplayId(),
+bool HardwareComposer::EnableVsync(const DisplayParams& display, bool enabled) {
+ HWC::Error error = composer_->setVsyncEnabled(display.id,
(Hwc2::IComposerClient::Vsync)(enabled ? HWC2_VSYNC_ENABLE
: HWC2_VSYNC_DISABLE));
+ if (error != HWC::Error::None) {
+ ALOGE("Error attempting to %s vsync on %s display: %s",
+ enabled ? "enable" : "disable", GetDisplayName(display.is_primary),
+ error.to_string().c_str());
+ }
+ return error == HWC::Error::None;
}
-HWC::Error HardwareComposer::SetPowerMode(bool active) {
+bool HardwareComposer::SetPowerMode(const DisplayParams& display, bool active) {
+ ALOGI("Turning %s display %s", GetDisplayName(display.is_primary),
+ active ? "on" : "off");
HWC::PowerMode power_mode = active ? HWC::PowerMode::On : HWC::PowerMode::Off;
- return composer_->setPowerMode(
- composer_callback_->GetDisplayId(),
+ HWC::Error error = composer_->setPowerMode(display.id,
power_mode.cast<Hwc2::IComposerClient::PowerMode>());
+ if (error != HWC::Error::None) {
+ ALOGE("Error attempting to turn %s display %s: %s",
+ GetDisplayName(display.is_primary), active ? "on" : "off",
+ error.to_string().c_str());
+ }
+ return error == HWC::Error::None;
+}
+
+bool HardwareComposer::EnableDisplay(const DisplayParams& display,
+ bool enabled) {
+ bool power_result;
+ bool vsync_result;
+ // When turning a display on, we set the power state then set vsync. When
+ // turning a display off we do it in the opposite order.
+ if (enabled) {
+ power_result = SetPowerMode(display, enabled);
+ vsync_result = EnableVsync(display, enabled);
+ } else {
+ vsync_result = EnableVsync(display, enabled);
+ power_result = SetPowerMode(display, enabled);
+ }
+ return power_result && vsync_result;
}
HWC::Error HardwareComposer::Present(hwc2_display_t display) {
@@ -355,78 +345,105 @@
return error;
}
-HWC::Error HardwareComposer::GetDisplayAttribute(Hwc2::Composer* composer,
- hwc2_display_t display,
- hwc2_config_t config,
- hwc2_attribute_t attribute,
- int32_t* out_value) const {
- return composer->getDisplayAttribute(
- display, config, (Hwc2::IComposerClient::Attribute)attribute, out_value);
-}
+DisplayParams HardwareComposer::GetDisplayParams(
+ Hwc2::Composer* composer, hwc2_display_t display, bool is_primary) {
+ DisplayParams params;
+ params.id = display;
+ params.is_primary = is_primary;
-HWC::Error HardwareComposer::GetDisplayMetrics(
- Hwc2::Composer* composer, hwc2_display_t display, hwc2_config_t config,
- HWCDisplayMetrics* out_metrics) const {
- HWC::Error error;
+ Hwc2::Config config;
+ HWC::Error error = composer->getActiveConfig(display, &config);
- error = GetDisplayAttribute(composer, display, config, HWC2_ATTRIBUTE_WIDTH,
- &out_metrics->width);
- if (error != HWC::Error::None) {
- ALOGE(
- "HardwareComposer::GetDisplayMetrics: Failed to get display width: %s",
- error.to_string().c_str());
- return error;
+ if (error == HWC::Error::None) {
+ auto get_attr = [&](hwc2_attribute_t attr, const char* attr_name)
+ -> std::optional<int32_t> {
+ int32_t val;
+ HWC::Error error = composer->getDisplayAttribute(
+ display, config, (Hwc2::IComposerClient::Attribute)attr, &val);
+ if (error != HWC::Error::None) {
+ ALOGE("Failed to get %s display attr %s: %s",
+ GetDisplayName(is_primary), attr_name,
+ error.to_string().c_str());
+ return std::nullopt;
+ }
+ return val;
+ };
+
+ auto width = get_attr(HWC2_ATTRIBUTE_WIDTH, "width");
+ auto height = get_attr(HWC2_ATTRIBUTE_HEIGHT, "height");
+
+ if (width && height) {
+ params.width = *width;
+ params.height = *height;
+ } else {
+ ALOGI("Failed to get width and/or height for %s display. Using default"
+ " size %dx%d.", GetDisplayName(is_primary), kDefaultDisplayWidth,
+ kDefaultDisplayHeight);
+ params.width = kDefaultDisplayWidth;
+ params.height = kDefaultDisplayHeight;
+ }
+
+ auto vsync_period = get_attr(HWC2_ATTRIBUTE_VSYNC_PERIOD, "vsync period");
+ if (vsync_period) {
+ params.vsync_period_ns = *vsync_period;
+ } else {
+ ALOGI("Failed to get vsync period for %s display. Using default vsync"
+ " period %.2fms", GetDisplayName(is_primary),
+ static_cast<float>(kDefaultVsyncPeriodNs) / 1000000);
+ params.vsync_period_ns = kDefaultVsyncPeriodNs;
+ }
+
+ auto dpi_x = get_attr(HWC2_ATTRIBUTE_DPI_X, "DPI X");
+ auto dpi_y = get_attr(HWC2_ATTRIBUTE_DPI_Y, "DPI Y");
+ if (dpi_x && dpi_y) {
+ params.dpi.x = *dpi_x;
+ params.dpi.y = *dpi_y;
+ } else {
+ ALOGI("Failed to get dpi_x and/or dpi_y for %s display. Using default"
+ " dpi %d.", GetDisplayName(is_primary), kDefaultDpi);
+ params.dpi.x = kDefaultDpi;
+ params.dpi.y = kDefaultDpi;
+ }
+ } else {
+ ALOGE("HardwareComposer: Failed to get current %s display config: %d."
+ " Using default display values.",
+ GetDisplayName(is_primary), error.value);
+ params.width = kDefaultDisplayWidth;
+ params.height = kDefaultDisplayHeight;
+ params.dpi.x = kDefaultDpi;
+ params.dpi.y = kDefaultDpi;
+ params.vsync_period_ns = kDefaultVsyncPeriodNs;
}
- error = GetDisplayAttribute(composer, display, config, HWC2_ATTRIBUTE_HEIGHT,
- &out_metrics->height);
- if (error != HWC::Error::None) {
- ALOGE(
- "HardwareComposer::GetDisplayMetrics: Failed to get display height: %s",
- error.to_string().c_str());
- return error;
- }
+ ALOGI(
+ "HardwareComposer: %s display attributes: width=%d height=%d "
+ "vsync_period_ns=%d DPI=%dx%d",
+ GetDisplayName(is_primary),
+ params.width,
+ params.height,
+ params.vsync_period_ns,
+ params.dpi.x,
+ params.dpi.y);
- error = GetDisplayAttribute(composer, display, config,
- HWC2_ATTRIBUTE_VSYNC_PERIOD,
- &out_metrics->vsync_period_ns);
- if (error != HWC::Error::None) {
- ALOGE(
- "HardwareComposer::GetDisplayMetrics: Failed to get display height: %s",
- error.to_string().c_str());
- return error;
- }
-
- error = GetDisplayAttribute(composer, display, config, HWC2_ATTRIBUTE_DPI_X,
- &out_metrics->dpi.x);
- if (error != HWC::Error::None) {
- ALOGE(
- "HardwareComposer::GetDisplayMetrics: Failed to get display DPI X: %s",
- error.to_string().c_str());
- return error;
- }
-
- error = GetDisplayAttribute(composer, display, config, HWC2_ATTRIBUTE_DPI_Y,
- &out_metrics->dpi.y);
- if (error != HWC::Error::None) {
- ALOGE(
- "HardwareComposer::GetDisplayMetrics: Failed to get display DPI Y: %s",
- error.to_string().c_str());
- return error;
- }
-
- return HWC::Error::None;
+ return params;
}
std::string HardwareComposer::Dump() {
std::unique_lock<std::mutex> lock(post_thread_mutex_);
std::ostringstream stream;
- stream << "Display metrics: " << display_metrics_.width << "x"
- << display_metrics_.height << " " << (display_metrics_.dpi.x / 1000.0)
- << "x" << (display_metrics_.dpi.y / 1000.0) << " dpi @ "
- << (1000000000.0 / display_metrics_.vsync_period_ns) << " Hz"
- << std::endl;
+ auto print_display_metrics = [&](const DisplayParams& params) {
+ stream << GetDisplayName(params.is_primary)
+ << " display metrics: " << params.width << "x"
+ << params.height << " " << (params.dpi.x / 1000.0)
+ << "x" << (params.dpi.y / 1000.0) << " dpi @ "
+ << (1000000000.0 / params.vsync_period_ns) << " Hz"
+ << std::endl;
+ };
+
+ print_display_metrics(primary_display_);
+ if (external_display_)
+ print_display_metrics(*external_display_);
stream << "Post thread resumed: " << post_thread_resumed_ << std::endl;
stream << "Active layers: " << layers_.size() << std::endl;
@@ -449,7 +466,7 @@
return stream.str();
}
-void HardwareComposer::PostLayers() {
+void HardwareComposer::PostLayers(hwc2_display_t display) {
ATRACE_NAME("HardwareComposer::PostLayers");
// Setup the hardware composer layers with current buffers.
@@ -497,14 +514,14 @@
}
#endif
- HWC::Error error = Validate(composer_callback_->GetDisplayId());
+ HWC::Error error = Validate(display);
if (error != HWC::Error::None) {
- ALOGE("HardwareComposer::PostLayers: Validate failed: %s",
- error.to_string().c_str());
+ ALOGE("HardwareComposer::PostLayers: Validate failed: %s display=%" PRIu64,
+ error.to_string().c_str(), display);
return;
}
- error = Present(composer_callback_->GetDisplayId());
+ error = Present(display);
if (error != HWC::Error::None) {
ALOGE("HardwareComposer::PostLayers: Present failed: %s",
error.to_string().c_str());
@@ -513,7 +530,7 @@
std::vector<Hwc2::Layer> out_layers;
std::vector<int> out_fences;
- error = composer_->getReleaseFences(composer_callback_->GetDisplayId(),
+ error = composer_->getReleaseFences(display,
&out_layers, &out_fences);
ALOGE_IF(error != HWC::Error::None,
"HardwareComposer::PostLayers: Failed to get release fences: %s",
@@ -537,7 +554,8 @@
const bool display_idle = surfaces.size() == 0;
{
std::unique_lock<std::mutex> lock(post_thread_mutex_);
- pending_surfaces_ = std::move(surfaces);
+ surfaces_ = std::move(surfaces);
+ surfaces_changed_ = true;
}
if (request_display_callback_ && !is_standalone_device_)
@@ -653,13 +671,11 @@
}
}
-// Waits for the next vsync and returns the timestamp of the vsync event. If
-// vsync already passed since the last call, returns the latest vsync timestamp
-// instead of blocking.
-Status<int64_t> HardwareComposer::WaitForVSync() {
- const int64_t predicted_vsync_time =
- last_vsync_timestamp_ +
- display_metrics_.vsync_period_ns * vsync_prediction_interval_;
+// Sleep until the next predicted vsync, returning the predicted vsync
+// timestamp.
+Status<int64_t> HardwareComposer::WaitForPredictedVSync() {
+ const int64_t predicted_vsync_time = last_vsync_timestamp_ +
+ (target_display_->vsync_period_ns * vsync_prediction_interval_);
const int error = SleepUntil(predicted_vsync_time);
if (error < 0) {
ALOGE("HardwareComposer::WaifForVSync:: Failed to sleep: %s",
@@ -698,16 +714,6 @@
bool thread_policy_setup =
SetThreadPolicy("graphics:high", "/system/performance");
-#if ENABLE_BACKLIGHT_BRIGHTNESS
- // TODO(hendrikw): This isn't required at the moment. It's possible that there
- // is another method to access this when needed.
- // Open the backlight brightness control sysfs node.
- backlight_brightness_fd_ = LocalHandle(kBacklightBrightnessSysFile, O_RDWR);
- ALOGW_IF(!backlight_brightness_fd_,
- "HardwareComposer: Failed to open backlight brightness control: %s",
- strerror(errno));
-#endif // ENABLE_BACKLIGHT_BRIGHTNESS
-
// Create a timerfd based on CLOCK_MONOTINIC.
vsync_sleep_timer_fd_.Reset(timerfd_create(CLOCK_MONOTONIC, 0));
LOG_ALWAYS_FATAL_IF(
@@ -715,20 +721,28 @@
"HardwareComposer: Failed to create vsync sleep timerfd: %s",
strerror(errno));
- const int64_t ns_per_frame = display_metrics_.vsync_period_ns;
- const int64_t photon_offset_ns = GetPosePredictionTimeOffset(ns_per_frame);
-
- // TODO(jbates) Query vblank time from device, when such an API is available.
- // This value (6.3%) was measured on A00 in low persistence mode.
- int64_t vblank_ns = ns_per_frame * 63 / 1000;
- int64_t right_eye_photon_offset_ns = (ns_per_frame - vblank_ns) / 2;
-
- // Check property for overriding right eye offset value.
- right_eye_photon_offset_ns =
- property_get_int64(kRightEyeOffsetProperty, right_eye_photon_offset_ns);
-
+ struct VsyncEyeOffsets { int64_t left_ns, right_ns; };
bool was_running = false;
+ auto get_vsync_eye_offsets = [this]() -> VsyncEyeOffsets {
+ VsyncEyeOffsets offsets;
+ offsets.left_ns =
+ GetPosePredictionTimeOffset(target_display_->vsync_period_ns);
+
+ // TODO(jbates) Query vblank time from device, when such an API is
+ // available. This value (6.3%) was measured on A00 in low persistence mode.
+ int64_t vblank_ns = target_display_->vsync_period_ns * 63 / 1000;
+ offsets.right_ns = (target_display_->vsync_period_ns - vblank_ns) / 2;
+
+ // Check property for overriding right eye offset value.
+ offsets.right_ns =
+ property_get_int64(kRightEyeOffsetProperty, offsets.right_ns);
+
+ return offsets;
+ };
+
+ VsyncEyeOffsets vsync_eye_offsets = get_vsync_eye_offsets();
+
if (is_standalone_device_) {
// First, wait until boot finishes.
std::unique_lock<std::mutex> lock(post_thread_mutex_);
@@ -747,8 +761,8 @@
"Vr flinger should own the display by now.");
post_thread_resumed_ = true;
post_thread_ready_.notify_all();
- OnPostThreadResumed();
- was_running = true;
+ if (!composer_)
+ CreateComposer();
}
while (1) {
@@ -761,10 +775,8 @@
std::unique_lock<std::mutex> lock(post_thread_mutex_);
ALOGI("HardwareComposer::PostThread: Entering quiescent state.");
- // Tear down resources if necessary.
- if (was_running)
- OnPostThreadPaused();
-
+ // Tear down resources.
+ OnPostThreadPaused();
was_running = false;
post_thread_resumed_ = false;
post_thread_ready_.notify_all();
@@ -781,10 +793,18 @@
ALOGI("HardwareComposer::PostThread: Exiting quiescent state.");
}
- if (!was_running) {
- // Setup resources.
+ if (!composer_)
+ CreateComposer();
+
+ bool target_display_changed = UpdateTargetDisplay();
+ bool just_resumed_running = !was_running;
+ was_running = true;
+
+ if (target_display_changed)
+ vsync_eye_offsets = get_vsync_eye_offsets();
+
+ if (just_resumed_running) {
OnPostThreadResumed();
- was_running = true;
// Try to setup the scheduler policy if it failed during startup. Only
// attempt to do this on transitions from inactive to active to avoid
@@ -793,12 +813,16 @@
thread_policy_setup =
SetThreadPolicy("graphics:high", "/system/performance");
}
+ }
+ if (target_display_changed || just_resumed_running) {
// Initialize the last vsync timestamp with the current time. The
// predictor below uses this time + the vsync interval in absolute time
// units for the initial delay. Once the driver starts reporting vsync the
// predictor will sync up with the real vsync.
last_vsync_timestamp_ = GetSystemClockNs();
+ vsync_prediction_interval_ = 1;
+ retire_fence_fds_.clear();
}
int64_t vsync_timestamp = 0;
@@ -808,7 +832,7 @@
vsync_count_ + 1, last_vsync_timestamp_,
vsync_prediction_interval_);
- auto status = WaitForVSync();
+ auto status = WaitForPredictedVSync();
ALOGE_IF(
!status,
"HardwareComposer::PostThread: Failed to wait for vsync event: %s",
@@ -829,16 +853,16 @@
if (vsync_prediction_interval_ == 1)
++vsync_count_;
- const bool layer_config_changed = UpdateLayerConfig();
+ UpdateLayerConfig();
// Publish the vsync event.
if (vsync_ring_) {
DvrVsync vsync;
vsync.vsync_count = vsync_count_;
vsync.vsync_timestamp_ns = vsync_timestamp;
- vsync.vsync_left_eye_offset_ns = photon_offset_ns;
- vsync.vsync_right_eye_offset_ns = right_eye_photon_offset_ns;
- vsync.vsync_period_ns = ns_per_frame;
+ vsync.vsync_left_eye_offset_ns = vsync_eye_offsets.left_ns;
+ vsync.vsync_right_eye_offset_ns = vsync_eye_offsets.right_ns;
+ vsync.vsync_period_ns = target_display_->vsync_period_ns;
vsync_ring_->Publish(vsync);
}
@@ -852,7 +876,8 @@
// Sleep until shortly before vsync.
ATRACE_NAME("sleep");
- const int64_t display_time_est_ns = vsync_timestamp + ns_per_frame;
+ const int64_t display_time_est_ns =
+ vsync_timestamp + target_display_->vsync_period_ns;
const int64_t now_ns = GetSystemClockNs();
const int64_t sleep_time_ns = display_time_est_ns - now_ns -
post_thread_config_.frame_post_offset_ns;
@@ -873,11 +898,7 @@
}
{
- auto status = composer_callback_->GetVsyncTime();
- if (!status) {
- ALOGE("HardwareComposer::PostThread: Failed to get VSYNC time: %s",
- status.GetErrorMessage().c_str());
- }
+ auto status = composer_callback_->GetVsyncTime(target_display_->id);
// If we failed to read vsync there might be a problem with the driver.
// Since there's nothing we can do just behave as though we didn't get an
@@ -904,20 +925,84 @@
}
}
- PostLayers();
+ PostLayers(target_display_->id);
}
}
+bool HardwareComposer::UpdateTargetDisplay() {
+ bool target_display_changed = false;
+ auto displays = composer_callback_->GetDisplays();
+ if (displays.external_display_was_hotplugged) {
+ bool was_using_external_display = !target_display_->is_primary;
+ if (was_using_external_display) {
+ // The external display was hotplugged, so make sure to ignore any bad
+ // display errors as we destroy the layers.
+ for (auto& layer: layers_)
+ layer.IgnoreBadDisplayErrorsOnDestroy(true);
+ }
+
+ if (displays.external_display) {
+ // External display was connected
+ external_display_ = GetDisplayParams(composer_.get(),
+ *displays.external_display, /*is_primary*/ false);
+
+ if (property_get_bool(kUseExternalDisplayProperty, false)) {
+ ALOGI("External display connected. Switching to external display.");
+ target_display_ = &(*external_display_);
+ target_display_changed = true;
+ } else {
+ ALOGI("External display connected, but sysprop %s is unset, so"
+ " using primary display.", kUseExternalDisplayProperty);
+ if (was_using_external_display) {
+ target_display_ = &primary_display_;
+ target_display_changed = true;
+ }
+ }
+ } else {
+ // External display was disconnected
+ external_display_ = std::nullopt;
+ if (was_using_external_display) {
+ ALOGI("External display disconnected. Switching to primary display.");
+ target_display_ = &primary_display_;
+ target_display_changed = true;
+ }
+ }
+ }
+
+ if (target_display_changed) {
+ // If we're switching to the external display, turn the primary display off.
+ if (!target_display_->is_primary) {
+ EnableDisplay(primary_display_, false);
+ }
+ // If we're switching to the primary display, and the external display is
+ // still connected, turn the external display off.
+ else if (target_display_->is_primary && external_display_) {
+ EnableDisplay(*external_display_, false);
+ }
+
+ // Turn the new target display on.
+ EnableDisplay(*target_display_, true);
+
+ // When we switch displays we need to recreate all the layers, so clear the
+ // current list, which will trigger layer recreation.
+ layers_.clear();
+ }
+
+ return target_display_changed;
+}
+
// Checks for changes in the surface stack and updates the layer config to
// accomodate the new stack.
-bool HardwareComposer::UpdateLayerConfig() {
+void HardwareComposer::UpdateLayerConfig() {
std::vector<std::shared_ptr<DirectDisplaySurface>> surfaces;
{
std::unique_lock<std::mutex> lock(post_thread_mutex_);
- if (pending_surfaces_.empty())
- return false;
- surfaces = std::move(pending_surfaces_);
+ if (!surfaces_changed_ && (!layers_.empty() || surfaces_.empty()))
+ return;
+
+ surfaces = surfaces_;
+ surfaces_changed_ = false;
}
ATRACE_NAME("UpdateLayerConfig_HwLayers");
@@ -954,8 +1039,8 @@
layers_.erase(search);
} else {
// Insert a layer for the new surface.
- layers.emplace_back(surface, blending, display_transform_,
- HWC::Composition::Device, layer_index);
+ layers.emplace_back(composer_.get(), *target_display_, surface, blending,
+ HWC::Composition::Device, layer_index);
}
ALOGI_IF(
@@ -976,32 +1061,35 @@
ALOGD_IF(TRACE, "HardwareComposer::UpdateLayerConfig: %zd active layers",
layers_.size());
- return true;
}
void HardwareComposer::SetVSyncCallback(VSyncCallback callback) {
vsync_callback_ = callback;
}
-void HardwareComposer::SetBacklightBrightness(int brightness) {
- if (backlight_brightness_fd_) {
- std::array<char, 32> text;
- const int length = snprintf(text.data(), text.size(), "%d", brightness);
- write(backlight_brightness_fd_.Get(), text.data(), length);
- }
-}
-
Return<void> HardwareComposer::ComposerCallback::onHotplug(
Hwc2::Display display, IComposerCallback::Connection conn) {
+ std::lock_guard<std::mutex> lock(mutex_);
+ ALOGI("onHotplug display=%" PRIu64 " conn=%d", display, conn);
+
+ bool is_primary = !got_first_hotplug_ || display == primary_display_.id;
+
// Our first onHotplug callback is always for the primary display.
- //
- // Ignore any other hotplug callbacks since the primary display is never
- // disconnected and we don't care about other displays.
- if (!has_display_id_) {
+ if (!got_first_hotplug_) {
LOG_ALWAYS_FATAL_IF(conn != IComposerCallback::Connection::CONNECTED,
"Initial onHotplug callback should be primary display connected");
- has_display_id_ = true;
- display_id_ = display;
+ got_first_hotplug_ = true;
+ } else if (is_primary) {
+ ALOGE("Ignoring unexpected onHotplug() call for primary display");
+ return Void();
+ }
+
+ if (conn == IComposerCallback::Connection::CONNECTED) {
+ if (!is_primary)
+ external_display_ = DisplayInfo();
+ DisplayInfo& display_info = is_primary ?
+ primary_display_ : *external_display_;
+ display_info.id = display;
std::array<char, 1024> buffer;
snprintf(buffer.data(), buffer.size(),
@@ -1011,15 +1099,20 @@
"HardwareComposer::ComposerCallback::onHotplug: Driver supports "
"vsync_event node for display %" PRIu64,
display);
- driver_vsync_event_fd_ = std::move(handle);
+ display_info.driver_vsync_event_fd = std::move(handle);
} else {
ALOGI(
"HardwareComposer::ComposerCallback::onHotplug: Driver does not "
"support vsync_event node for display %" PRIu64,
display);
}
+ } else if (conn == IComposerCallback::Connection::DISCONNECTED) {
+ external_display_ = std::nullopt;
}
+ if (!is_primary)
+ external_display_was_hotplugged_ = true;
+
return Void();
}
@@ -1030,23 +1123,45 @@
Return<void> HardwareComposer::ComposerCallback::onVsync(Hwc2::Display display,
int64_t timestamp) {
- // Ignore any onVsync callbacks for the non-primary display.
- if (has_display_id_ && display == display_id_) {
+ DisplayInfo* display_info = GetDisplayInfo(display);
+ if (display_info) {
TRACE_FORMAT("vsync_callback|display=%" PRIu64 ";timestamp=%" PRId64 "|",
display, timestamp);
- callback_vsync_timestamp_ = timestamp;
+ display_info->callback_vsync_timestamp = timestamp;
}
+
return Void();
}
-Status<int64_t> HardwareComposer::ComposerCallback::GetVsyncTime() {
+HardwareComposer::ComposerCallback::Displays
+HardwareComposer::ComposerCallback::GetDisplays() {
+ std::lock_guard<std::mutex> lock(mutex_);
+ Displays displays;
+ displays.primary_display = primary_display_.id;
+ if (external_display_)
+ displays.external_display = external_display_->id;
+ if (external_display_was_hotplugged_) {
+ external_display_was_hotplugged_ = false;
+ displays.external_display_was_hotplugged = true;
+ }
+ return displays;
+}
+
+Status<int64_t> HardwareComposer::ComposerCallback::GetVsyncTime(
+ hwc2_display_t display) {
+ DisplayInfo* display_info = GetDisplayInfo(display);
+ if (!display_info) {
+ ALOGW("Attempt to get vsync time for unknown display %" PRIu64, display);
+ return ErrorStatus(EINVAL);
+ }
+
// See if the driver supports direct vsync events.
- LocalHandle& event_fd = driver_vsync_event_fd_;
+ LocalHandle& event_fd = display_info->driver_vsync_event_fd;
if (!event_fd) {
// Fall back to returning the last timestamp returned by the vsync
// callback.
- std::lock_guard<std::mutex> autolock(vsync_mutex_);
- return callback_vsync_timestamp_;
+ std::lock_guard<std::mutex> autolock(mutex_);
+ return display_info->callback_vsync_timestamp;
}
// When the driver supports the vsync_event sysfs node we can use it to
@@ -1094,19 +1209,32 @@
return {timestamp};
}
-Hwc2::Composer* Layer::composer_{nullptr};
-HWCDisplayMetrics Layer::display_metrics_{0, 0, {0, 0}, 0};
-hwc2_display_t Layer::display_id_{0};
+HardwareComposer::ComposerCallback::DisplayInfo*
+HardwareComposer::ComposerCallback::GetDisplayInfo(hwc2_display_t display) {
+ if (display == primary_display_.id) {
+ return &primary_display_;
+ } else if (external_display_ && display == external_display_->id) {
+ return &(*external_display_);
+ }
+ return nullptr;
+}
void Layer::Reset() {
if (hardware_composer_layer_) {
- composer_->destroyLayer(display_id_, hardware_composer_layer_);
+ HWC::Error error =
+ composer_->destroyLayer(display_params_.id, hardware_composer_layer_);
+ if (error != HWC::Error::None &&
+ (!ignore_bad_display_errors_on_destroy_ ||
+ error != HWC::Error::BadDisplay)) {
+ ALOGE("destroyLayer() failed for display %" PRIu64 ", layer %" PRIu64
+ ". error: %s", display_params_.id, hardware_composer_layer_,
+ error.to_string().c_str());
+ }
hardware_composer_layer_ = 0;
}
z_order_ = 0;
blending_ = HWC::BlendMode::None;
- transform_ = HWC::Transform::None;
composition_type_ = HWC::Composition::Invalid;
target_composition_type_ = composition_type_;
source_ = EmptyVariant{};
@@ -1114,25 +1242,29 @@
surface_rect_functions_applied_ = false;
pending_visibility_settings_ = true;
cached_buffer_map_.clear();
+ ignore_bad_display_errors_on_destroy_ = false;
}
-Layer::Layer(const std::shared_ptr<DirectDisplaySurface>& surface,
- HWC::BlendMode blending, HWC::Transform transform,
- HWC::Composition composition_type, size_t z_order)
- : z_order_{z_order},
+Layer::Layer(Hwc2::Composer* composer, const DisplayParams& display_params,
+ const std::shared_ptr<DirectDisplaySurface>& surface,
+ HWC::BlendMode blending, HWC::Composition composition_type,
+ size_t z_order)
+ : composer_(composer),
+ display_params_(display_params),
+ z_order_{z_order},
blending_{blending},
- transform_{transform},
target_composition_type_{composition_type},
source_{SourceSurface{surface}} {
CommonLayerSetup();
}
-Layer::Layer(const std::shared_ptr<IonBuffer>& buffer, HWC::BlendMode blending,
- HWC::Transform transform, HWC::Composition composition_type,
- size_t z_order)
- : z_order_{z_order},
+Layer::Layer(Hwc2::Composer* composer, const DisplayParams& display_params,
+ const std::shared_ptr<IonBuffer>& buffer, HWC::BlendMode blending,
+ HWC::Composition composition_type, size_t z_order)
+ : composer_(composer),
+ display_params_(display_params),
+ z_order_{z_order},
blending_{blending},
- transform_{transform},
target_composition_type_{composition_type},
source_{SourceBuffer{buffer}} {
CommonLayerSetup();
@@ -1146,10 +1278,11 @@
if (this != &other) {
Reset();
using std::swap;
+ swap(composer_, other.composer_);
+ swap(display_params_, other.display_params_);
swap(hardware_composer_layer_, other.hardware_composer_layer_);
swap(z_order_, other.z_order_);
swap(blending_, other.blending_);
- swap(transform_, other.transform_);
swap(composition_type_, other.composition_type_);
swap(target_composition_type_, other.target_composition_type_);
swap(source_, other.source_);
@@ -1158,6 +1291,8 @@
other.surface_rect_functions_applied_);
swap(pending_visibility_settings_, other.pending_visibility_settings_);
swap(cached_buffer_map_, other.cached_buffer_map_);
+ swap(ignore_bad_display_errors_on_destroy_,
+ other.ignore_bad_display_errors_on_destroy_);
}
return *this;
}
@@ -1197,14 +1332,14 @@
HWC::Error error;
error = composer_->setLayerBlendMode(
- display_id_, hardware_composer_layer_,
+ display_params_.id, hardware_composer_layer_,
blending_.cast<Hwc2::IComposerClient::BlendMode>());
ALOGE_IF(error != HWC::Error::None,
"Layer::UpdateLayerSettings: Error setting layer blend mode: %s",
error.to_string().c_str());
- error = composer_->setLayerZOrder(display_id_, hardware_composer_layer_,
- z_order_);
+ error = composer_->setLayerZOrder(display_params_.id,
+ hardware_composer_layer_, z_order_);
ALOGE_IF(error != HWC::Error::None,
"Layer::UpdateLayerSettings: Error setting z_ order: %s",
error.to_string().c_str());
@@ -1219,28 +1354,28 @@
// TODO(eieio): Use surface attributes or some other mechanism to control
// the layer display frame.
error = composer_->setLayerDisplayFrame(
- display_id_, hardware_composer_layer_,
- {0, 0, display_metrics_.width, display_metrics_.height});
+ display_params_.id, hardware_composer_layer_,
+ {0, 0, display_params_.width, display_params_.height});
ALOGE_IF(error != HWC::Error::None,
"Layer::UpdateLayerSettings: Error setting layer display frame: %s",
error.to_string().c_str());
error = composer_->setLayerVisibleRegion(
- display_id_, hardware_composer_layer_,
- {{0, 0, display_metrics_.width, display_metrics_.height}});
+ display_params_.id, hardware_composer_layer_,
+ {{0, 0, display_params_.width, display_params_.height}});
ALOGE_IF(error != HWC::Error::None,
"Layer::UpdateLayerSettings: Error setting layer visible region: %s",
error.to_string().c_str());
- error = composer_->setLayerPlaneAlpha(display_id_, hardware_composer_layer_,
- 1.0f);
+ error = composer_->setLayerPlaneAlpha(display_params_.id,
+ hardware_composer_layer_, 1.0f);
ALOGE_IF(error != HWC::Error::None,
"Layer::UpdateLayerSettings: Error setting layer plane alpha: %s",
error.to_string().c_str());
}
void Layer::CommonLayerSetup() {
- HWC::Error error = composer_->createLayer(display_id_,
+ HWC::Error error = composer_->createLayer(display_params_.id,
&hardware_composer_layer_);
ALOGE_IF(error != HWC::Error::None,
"Layer::CommonLayerSetup: Failed to create layer on primary "
@@ -1285,10 +1420,10 @@
if (composition_type_ == HWC::Composition::Invalid) {
composition_type_ = HWC::Composition::SolidColor;
composer_->setLayerCompositionType(
- display_id_, hardware_composer_layer_,
+ display_params_.id, hardware_composer_layer_,
composition_type_.cast<Hwc2::IComposerClient::Composition>());
Hwc2::IComposerClient::Color layer_color = {0, 0, 0, 0};
- composer_->setLayerColor(display_id_, hardware_composer_layer_,
+ composer_->setLayerColor(display_params_.id, hardware_composer_layer_,
layer_color);
} else {
// The composition type is already set. Nothing else to do until a
@@ -1298,7 +1433,7 @@
if (composition_type_ != target_composition_type_) {
composition_type_ = target_composition_type_;
composer_->setLayerCompositionType(
- display_id_, hardware_composer_layer_,
+ display_params_.id, hardware_composer_layer_,
composition_type_.cast<Hwc2::IComposerClient::Composition>());
}
@@ -1309,7 +1444,7 @@
HWC::Error error{HWC::Error::None};
error =
- composer_->setLayerBuffer(display_id_, hardware_composer_layer_,
+ composer_->setLayerBuffer(display_params_.id, hardware_composer_layer_,
slot, handle, acquire_fence_.Get());
ALOGE_IF(error != HWC::Error::None,
@@ -1319,7 +1454,7 @@
if (!surface_rect_functions_applied_) {
const float float_right = right;
const float float_bottom = bottom;
- error = composer_->setLayerSourceCrop(display_id_,
+ error = composer_->setLayerSourceCrop(display_params_.id,
hardware_composer_layer_,
{0, 0, float_right, float_bottom});
diff --git a/libs/vr/libvrflinger/hardware_composer.h b/libs/vr/libvrflinger/hardware_composer.h
index 1d0c7ef..1d8d463 100644
--- a/libs/vr/libvrflinger/hardware_composer.h
+++ b/libs/vr/libvrflinger/hardware_composer.h
@@ -13,6 +13,7 @@
#include <condition_variable>
#include <memory>
#include <mutex>
+#include <optional>
#include <thread>
#include <tuple>
#include <vector>
@@ -35,16 +36,19 @@
namespace android {
namespace dvr {
-// Basic display metrics for physical displays. Dimensions and densities are
-// relative to the physical display orientation, which may be different from the
-// logical display orientation exposed to applications.
-struct HWCDisplayMetrics {
+// Basic display metrics for physical displays.
+struct DisplayParams {
+ hwc2_display_t id;
+ bool is_primary;
+
int width;
int height;
+
struct {
int x;
int y;
} dpi;
+
int vsync_period_ns;
};
@@ -58,26 +62,29 @@
// automatically handles ACQUIRE/RELEASE phases for the surface's buffer train
// every frame.
//
+ // |composer| The composer instance.
+ // |display_params| Info about the display to use.
// |blending| receives HWC_BLENDING_* values.
- // |transform| receives HWC_TRANSFORM_* values.
// |composition_type| receives either HWC_FRAMEBUFFER for most layers or
// HWC_FRAMEBUFFER_TARGET (unless you know what you are doing).
// |index| is the index of this surface in the DirectDisplaySurface array.
- Layer(const std::shared_ptr<DirectDisplaySurface>& surface,
- HWC::BlendMode blending, HWC::Transform transform,
- HWC::Composition composition_type, size_t z_roder);
+ Layer(Hwc2::Composer* composer, const DisplayParams& display_params,
+ const std::shared_ptr<DirectDisplaySurface>& surface,
+ HWC::BlendMode blending, HWC::Composition composition_type,
+ size_t z_order);
// Sets up the layer to use a direct buffer as its content source. No special
// handling of the buffer is performed; responsibility for updating or
// changing the buffer each frame is on the caller.
//
+ // |composer| The composer instance.
+ // |display_params| Info about the display to use.
// |blending| receives HWC_BLENDING_* values.
- // |transform| receives HWC_TRANSFORM_* values.
// |composition_type| receives either HWC_FRAMEBUFFER for most layers or
// HWC_FRAMEBUFFER_TARGET (unless you know what you are doing).
- Layer(const std::shared_ptr<IonBuffer>& buffer, HWC::BlendMode blending,
- HWC::Transform transform, HWC::Composition composition_type,
- size_t z_order);
+ Layer(Hwc2::Composer* composer, const DisplayParams& display_params,
+ const std::shared_ptr<IonBuffer>& buffer, HWC::BlendMode blending,
+ HWC::Composition composition_type, size_t z_order);
Layer(Layer&&);
Layer& operator=(Layer&&);
@@ -144,17 +151,8 @@
}
bool operator<(int surface_id) const { return GetSurfaceId() < surface_id; }
- // Sets the composer instance used by all Layer instances.
- static void SetComposer(Hwc2::Composer* composer) { composer_ = composer; }
-
- // Sets the display metrics used by all Layer instances.
- static void SetDisplayMetrics(HWCDisplayMetrics display_metrics) {
- display_metrics_ = display_metrics;
- }
-
- // Sets the display id used by all Layer instances.
- static void SetDisplayId(hwc2_display_t display_id) {
- display_id_ = display_id;
+ void IgnoreBadDisplayErrorsOnDestroy(bool ignore) {
+ ignore_bad_display_errors_on_destroy_ = ignore;
}
private:
@@ -174,21 +172,11 @@
// associated and always returns false.
bool CheckAndUpdateCachedBuffer(std::size_t slot, int buffer_id);
- // Composer instance shared by all instances of Layer. This must be set
- // whenever a new instance of the Composer is created. This may be set to
- // nullptr as long as there are no instances of Layer that might need to use
- // it.
- static Hwc2::Composer* composer_;
+ // Composer instance.
+ Hwc2::Composer* composer_ = nullptr;
- // Display metrics shared by all instances of Layer. This must be set at least
- // once during VrFlinger initialization and is expected to remain constant
- // thereafter.
- static HWCDisplayMetrics display_metrics_;
-
- // Id of the primary display. Shared by all instances of Layer. This must be
- // set whenever the primary display id changes. This can be left unset as long
- // as there are no instances of Layer that might need to use it.
- static hwc2_display_t display_id_;
+ // Parameters of the display to use for this layer.
+ DisplayParams display_params_;
// The hardware composer layer and metrics to use during the prepare cycle.
hwc2_layer_t hardware_composer_layer_ = 0;
@@ -197,7 +185,6 @@
// Prepare phase.
size_t z_order_ = 0;
HWC::BlendMode blending_ = HWC::BlendMode::None;
- HWC::Transform transform_ = HWC::Transform::None;
HWC::Composition composition_type_ = HWC::Composition::Invalid;
HWC::Composition target_composition_type_ = HWC::Composition::Device;
@@ -293,6 +280,12 @@
// importing a buffer HWC already knows about.
std::map<std::size_t, int> cached_buffer_map_;
+ // When calling destroyLayer() on an external display that's been removed we
+ // typically get HWC2_ERROR_BAD_DISPLAY errors. If
+ // ignore_bad_display_errors_on_destroy_ is true, don't log the bad display
+ // errors, since they're expected.
+ bool ignore_bad_display_errors_on_destroy_ = false;
+
Layer(const Layer&) = delete;
void operator=(const Layer&) = delete;
};
@@ -330,22 +323,12 @@
// Called on a binder thread.
void OnBootFinished();
- // Get the HMD display metrics for the current display.
- display::Metrics GetHmdDisplayMetrics() const;
-
std::string Dump();
void SetVSyncCallback(VSyncCallback callback);
- // Metrics of the logical display, which is always landscape.
- int DisplayWidth() const { return display_metrics_.width; }
- int DisplayHeight() const { return display_metrics_.height; }
- HWCDisplayMetrics display_metrics() const { return display_metrics_; }
-
- // Metrics of the native display, which depends on the specific hardware
- // implementation of the display.
- HWCDisplayMetrics native_display_metrics() const {
- return native_display_metrics_;
+ const DisplayParams& GetPrimaryDisplayParams() const {
+ return primary_display_;
}
// Sets the display surfaces to compose the hardware layer stack.
@@ -356,16 +339,16 @@
void OnDeletedGlobalBuffer(DvrGlobalBufferKey key);
private:
- HWC::Error GetDisplayAttribute(Hwc2::Composer* composer,
- hwc2_display_t display, hwc2_config_t config,
- hwc2_attribute_t attributes,
- int32_t* out_value) const;
- HWC::Error GetDisplayMetrics(Hwc2::Composer* composer, hwc2_display_t display,
- hwc2_config_t config,
- HWCDisplayMetrics* out_metrics) const;
+ DisplayParams GetDisplayParams(Hwc2::Composer* composer,
+ hwc2_display_t display, bool is_primary);
- HWC::Error EnableVsync(bool enabled);
- HWC::Error SetPowerMode(bool active);
+ // Turn display vsync on/off. Returns true on success, false on failure.
+ bool EnableVsync(const DisplayParams& display, bool enabled);
+ // Turn display power on/off. Returns true on success, false on failure.
+ bool SetPowerMode(const DisplayParams& display, bool active);
+ // Convenience function to turn a display on/off. Turns both power and vsync
+ // on/off. Returns true on success, false on failure.
+ bool EnableDisplay(const DisplayParams& display, bool enabled);
class ComposerCallback : public Hwc2::IComposerCallback {
public:
@@ -376,24 +359,38 @@
hardware::Return<void> onVsync(Hwc2::Display display,
int64_t timestamp) override;
- bool HasDisplayId() { return has_display_id_; }
- hwc2_display_t GetDisplayId() { return display_id_; }
- pdx::Status<int64_t> GetVsyncTime();
+ bool GotFirstHotplug() { return got_first_hotplug_; }
+
+ struct Displays {
+ hwc2_display_t primary_display = 0;
+ std::optional<hwc2_display_t> external_display;
+ bool external_display_was_hotplugged = false;
+ };
+
+ Displays GetDisplays();
+ pdx::Status<int64_t> GetVsyncTime(hwc2_display_t display);
private:
- std::mutex vsync_mutex_;
- bool has_display_id_ = false;
- hwc2_display_t display_id_;
- pdx::LocalHandle driver_vsync_event_fd_;
- int64_t callback_vsync_timestamp_{0};
+ struct DisplayInfo {
+ hwc2_display_t id = 0;
+ pdx::LocalHandle driver_vsync_event_fd;
+ int64_t callback_vsync_timestamp{0};
+ };
+
+ DisplayInfo* GetDisplayInfo(hwc2_display_t display);
+
+ std::mutex mutex_;
+
+ bool got_first_hotplug_ = false;
+ DisplayInfo primary_display_;
+ std::optional<DisplayInfo> external_display_;
+ bool external_display_was_hotplugged_ = false;
};
HWC::Error Validate(hwc2_display_t display);
HWC::Error Present(hwc2_display_t display);
- void SetBacklightBrightness(int brightness);
-
- void PostLayers();
+ void PostLayers(hwc2_display_t display);
void PostThread();
// The post thread has two controlling states:
@@ -421,16 +418,24 @@
int PostThreadPollInterruptible(const pdx::LocalHandle& event_fd,
int requested_events, int timeout_ms);
- // WaitForVSync and SleepUntil are blocking calls made on the post thread that
- // can be interrupted by a control thread. If interrupted, these calls return
- // kPostThreadInterrupted.
+ // WaitForPredictedVSync and SleepUntil are blocking calls made on the post
+ // thread that can be interrupted by a control thread. If interrupted, these
+ // calls return kPostThreadInterrupted.
int ReadWaitPPState();
- pdx::Status<int64_t> WaitForVSync();
+ pdx::Status<int64_t> WaitForPredictedVSync();
int SleepUntil(int64_t wakeup_timestamp);
+ // Initialize any newly connected displays, and set target_display_ to the
+ // display we should render to. Returns true if target_display_
+ // changed. Called only from the post thread.
+ bool UpdateTargetDisplay();
+
// Reconfigures the layer stack if the display surfaces changed since the last
// frame. Called only from the post thread.
- bool UpdateLayerConfig();
+ void UpdateLayerConfig();
+
+ // Called on the post thread to create the Composer instance.
+ void CreateComposer();
// Called on the post thread when the post thread is resumed.
void OnPostThreadResumed();
@@ -461,18 +466,19 @@
sp<ComposerCallback> composer_callback_;
RequestDisplayCallback request_display_callback_;
- // Display metrics of the physical display.
- HWCDisplayMetrics native_display_metrics_;
- // Display metrics of the logical display, adjusted so that orientation is
- // landscape.
- HWCDisplayMetrics display_metrics_;
- // Transform required to get from native to logical display orientation.
- HWC::Transform display_transform_ = HWC::Transform::None;
+ DisplayParams primary_display_;
+ std::optional<DisplayParams> external_display_;
+ DisplayParams* target_display_ = &primary_display_;
- // Pending surface list. Set by the display service when DirectSurfaces are
- // added, removed, or change visibility. Written by the message dispatch
- // thread and read by the post thread.
- std::vector<std::shared_ptr<DirectDisplaySurface>> pending_surfaces_;
+ // The list of surfaces we should draw. Set by the display service when
+ // DirectSurfaces are added, removed, or change visibility. Written by the
+ // message dispatch thread and read by the post thread.
+ std::vector<std::shared_ptr<DirectDisplaySurface>> surfaces_;
+ // Set to true by the dispatch thread whenever surfaces_ changes. Set to false
+ // by the post thread when the new list of surfaces is processed.
+ bool surfaces_changed_ = false;
+
+ std::vector<std::shared_ptr<DirectDisplaySurface>> current_surfaces_;
// Layer set for handling buffer flow into hardware composer layers. This
// vector must be sorted by surface_id in ascending order.
@@ -499,9 +505,6 @@
// notified via post_thread_wait_.
bool boot_finished_ = false;
- // Backlight LED brightness sysfs node.
- pdx::LocalHandle backlight_brightness_fd_;
-
// VSync sleep timerfd.
pdx::LocalHandle vsync_sleep_timer_fd_;
diff --git a/opengl/libs/EGL/eglApi.cpp b/opengl/libs/EGL/eglApi.cpp
index 46e7a97..b453d19 100644
--- a/opengl/libs/EGL/eglApi.cpp
+++ b/opengl/libs/EGL/eglApi.cpp
@@ -87,6 +87,8 @@
"EGL_ANDROID_get_native_client_buffer "
"EGL_ANDROID_front_buffer_auto_refresh "
"EGL_ANDROID_get_frame_timestamps "
+ "EGL_EXT_surface_SMPTE2086_metadata "
+ "EGL_EXT_surface_CTA861_3_metadata "
;
char const * const gExtensionString =
@@ -240,8 +242,6 @@
!strcmp((procname), "eglHibernateProcessIMG") || \
!strcmp((procname), "eglAwakenProcessIMG"))
-
-
// accesses protected by sExtensionMapMutex
static std::unordered_map<std::string, __eglMustCastToProperFunctionPointerType> sGLExtentionMap;
@@ -476,26 +476,61 @@
return dataSpace;
}
-// Return true if we stripped any EGL_GL_COLORSPACE_KHR or HDR metadata attributes.
-// Protect devices from attributes they don't recognize that are managed by Android
+// stripAttributes is used by eglCreateWindowSurface, eglCreatePbufferSurface
+// and eglCreatePixmapSurface to clean up color space related Window parameters
+// that a driver does not advertise support for.
+// Return true if stripped_attrib_list has stripped contents.
+
static EGLBoolean stripAttributes(egl_display_ptr dp, const EGLint* attrib_list,
EGLint format,
std::vector<EGLint>& stripped_attrib_list) {
std::vector<EGLint> allowedColorSpaces;
+ bool haveColorSpaceSupport = dp->haveExtension("EGL_KHR_gl_colorspace");
switch (format) {
case HAL_PIXEL_FORMAT_RGBA_8888:
- case HAL_PIXEL_FORMAT_RGB_565:
- // driver okay with linear & sRGB for 8888, but can't handle
- // Display-P3 or other spaces.
- allowedColorSpaces.push_back(EGL_GL_COLORSPACE_SRGB_KHR);
- allowedColorSpaces.push_back(EGL_GL_COLORSPACE_LINEAR_KHR);
+ if (haveColorSpaceSupport) {
+ // Spec says:
+ // [fn1] Only OpenGL and OpenGL ES contexts which support sRGB
+ // rendering must respect requests for EGL_GL_COLORSPACE_SRGB_KHR, and
+ // only to sRGB formats supported by the context (normally just SRGB8)
+ // Older versions not supporting sRGB rendering will ignore this
+ // surface attribute.
+ //
+ // We support sRGB and pixel format is SRGB8, so allow
+ // the EGL_GL_COLORSPACE_SRGB_KHR and
+ // EGL_GL_COLORSPACE_LINEAR_KHR
+ // colorspaces to be specified.
+
+ allowedColorSpaces.push_back(EGL_GL_COLORSPACE_SRGB_KHR);
+ allowedColorSpaces.push_back(EGL_GL_COLORSPACE_LINEAR_KHR);
+ }
+ if (findExtension(dp->disp.queryString.extensions,
+ "EGL_EXT_gl_colorspace_display_p3_linear")) {
+ allowedColorSpaces.push_back(EGL_GL_COLORSPACE_DISPLAY_P3_LINEAR_EXT);
+ }
+ if (findExtension(dp->disp.queryString.extensions,
+ "EGL_EXT_gl_colorspace_display_p3")) {
+ allowedColorSpaces.push_back(EGL_GL_COLORSPACE_DISPLAY_P3_EXT);
+ }
+ if (findExtension(dp->disp.queryString.extensions,
+ "EGL_EXT_gl_colorspace_bt2020_linear")) {
+ allowedColorSpaces.push_back(EGL_GL_COLORSPACE_BT2020_LINEAR_EXT);
+ }
+ if (findExtension(dp->disp.queryString.extensions,
+ "EGL_EXT_gl_colorspace_bt2020_pq")) {
+ allowedColorSpaces.push_back(EGL_GL_COLORSPACE_BT2020_PQ_EXT);
+ }
+ if (findExtension(dp->disp.queryString.extensions,
+ "EGL_EXT_gl_colorspace_scrgb_linear")) {
+ allowedColorSpaces.push_back(EGL_GL_COLORSPACE_SCRGB_LINEAR_EXT);
+ }
break;
case HAL_PIXEL_FORMAT_RGBA_FP16:
case HAL_PIXEL_FORMAT_RGBA_1010102:
- default:
- // driver does not want to see colorspace attributes for 1010102 or fp16.
+ case HAL_PIXEL_FORMAT_RGB_565:
// Future: if driver supports XXXX extension, we can pass down that colorspace
+ default:
break;
}
@@ -513,40 +548,23 @@
found = true;
}
}
- if (found || !dp->haveExtension("EGL_KHR_gl_colorspace")) {
+ if (found) {
+ // Found supported attribute
+ stripped_attrib_list.push_back(attr[0]);
+ stripped_attrib_list.push_back(attr[1]);
+ } else if (!haveColorSpaceSupport) {
+ // Device does not support colorspace extension
+ // pass on the attribute and let downstream
+ // components validate like normal
stripped_attrib_list.push_back(attr[0]);
stripped_attrib_list.push_back(attr[1]);
} else {
+ // Found supported attribute that driver does not
+ // support, strip it.
stripped = true;
}
}
break;
- case EGL_SMPTE2086_DISPLAY_PRIMARY_RX_EXT:
- case EGL_SMPTE2086_DISPLAY_PRIMARY_RY_EXT:
- case EGL_SMPTE2086_DISPLAY_PRIMARY_GX_EXT:
- case EGL_SMPTE2086_DISPLAY_PRIMARY_GY_EXT:
- case EGL_SMPTE2086_DISPLAY_PRIMARY_BX_EXT:
- case EGL_SMPTE2086_DISPLAY_PRIMARY_BY_EXT:
- case EGL_SMPTE2086_WHITE_POINT_X_EXT:
- case EGL_SMPTE2086_WHITE_POINT_Y_EXT:
- case EGL_SMPTE2086_MAX_LUMINANCE_EXT:
- case EGL_SMPTE2086_MIN_LUMINANCE_EXT:
- if (dp->haveExtension("EGL_EXT_surface_SMPTE2086_metadata")) {
- stripped = true;
- } else {
- stripped_attrib_list.push_back(attr[0]);
- stripped_attrib_list.push_back(attr[1]);
- }
- break;
- case EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT:
- case EGL_CTA861_3_MAX_FRAME_AVERAGE_LEVEL_EXT:
- if (dp->haveExtension("EGL_EXT_surface_CTA861_3_metadata")) {
- stripped = true;
- } else {
- stripped_attrib_list.push_back(attr[0]);
- stripped_attrib_list.push_back(attr[1]);
- }
- break;
default:
stripped_attrib_list.push_back(attr[0]);
stripped_attrib_list.push_back(attr[1]);
@@ -700,34 +718,26 @@
}
}
-EGLBoolean setSurfaceMetadata(egl_surface_t* s, NativeWindowType window,
- const EGLint *attrib_list) {
- // set any HDR metadata
- bool smpte2086 = false;
- bool cta8613 = false;
- if (attrib_list == nullptr) return EGL_TRUE;
-
- for (const EGLint* attr = attrib_list; attr[0] != EGL_NONE; attr += 2) {
- smpte2086 |= s->setSmpte2086Attribute(attr[0], attr[1]);
- cta8613 |= s->setCta8613Attribute(attr[0], attr[1]);
- }
- if (smpte2086) {
- android_smpte2086_metadata metadata = s->getSmpte2086Metadata();
- int err = native_window_set_buffers_smpte2086_metadata(window, &metadata);
+EGLBoolean sendSurfaceMetadata(egl_surface_t* s) {
+ android_smpte2086_metadata smpteMetadata;
+ if (s->getSmpte2086Metadata(smpteMetadata)) {
+ int err =
+ native_window_set_buffers_smpte2086_metadata(s->getNativeWindow(), &smpteMetadata);
+ s->resetSmpte2086Metadata();
if (err != 0) {
ALOGE("error setting native window smpte2086 metadata: %s (%d)",
strerror(-err), err);
- native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
return EGL_FALSE;
}
}
- if (cta8613) {
- android_cta861_3_metadata metadata = s->getCta8613Metadata();
- int err = native_window_set_buffers_cta861_3_metadata(window, &metadata);
+ android_cta861_3_metadata cta8613Metadata;
+ if (s->getCta8613Metadata(cta8613Metadata)) {
+ int err =
+ native_window_set_buffers_cta861_3_metadata(s->getNativeWindow(), &cta8613Metadata);
+ s->resetCta8613Metadata();
if (err != 0) {
ALOGE("error setting native window CTS 861.3 metadata: %s (%d)",
strerror(-err), err);
- native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
return EGL_FALSE;
}
}
@@ -812,11 +822,7 @@
if (surface != EGL_NO_SURFACE) {
egl_surface_t* s =
new egl_surface_t(dp.get(), config, window, surface, colorSpace, cnx);
-
- if (setSurfaceMetadata(s, window, origAttribList)) {
- return s;
- }
- eglDestroySurface(dpy, s);
+ return s;
}
// EGLSurface creation failed
@@ -1424,7 +1430,7 @@
if (!_s.get())
return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE);
- egl_surface_t const * const s = get_surface(draw);
+ egl_surface_t* const s = get_surface(draw);
if (CC_UNLIKELY(dp->traceGpuCompletion)) {
EGLSyncKHR sync = eglCreateSyncKHR(dpy, EGL_SYNC_FENCE_KHR, NULL);
@@ -1443,6 +1449,11 @@
}
}
+ if (!sendSurfaceMetadata(s)) {
+ native_window_api_disconnect(s->getNativeWindow(), NATIVE_WINDOW_API_EGL);
+ return setError(EGL_BAD_NATIVE_WINDOW, (EGLBoolean)EGL_FALSE);
+ }
+
if (n_rects == 0) {
return s->cnx->egl.eglSwapBuffers(dp->disp.dpy, s->surface);
}
diff --git a/opengl/libs/EGL/egl_display.cpp b/opengl/libs/EGL/egl_display.cpp
index 0f36614..74ddd1c 100644
--- a/opengl/libs/EGL/egl_display.cpp
+++ b/opengl/libs/EGL/egl_display.cpp
@@ -51,8 +51,11 @@
// ----------------------------------------------------------------------------
-static bool findExtension(const char* exts, const char* name, size_t nameLen) {
+bool findExtension(const char* exts, const char* name, size_t nameLen) {
if (exts) {
+ if (!nameLen) {
+ nameLen = strlen(name);
+ }
for (const char* match = strstr(exts, name); match; match = strstr(match + nameLen, name)) {
if (match[nameLen] == '\0' || match[nameLen] == ' ') {
return true;
@@ -226,11 +229,6 @@
"EGL_EXT_gl_colorspace_bt2020_linear EGL_EXT_gl_colorspace_bt2020_pq ");
}
- // Always advertise HDR metadata extensions since it's okay for an application
- // to specify such information even though it may not be used by the system.
- mExtensionString.append(
- "EGL_EXT_surface_SMPTE2086_metadata EGL_EXT_surface_CTA861_3_metadata ");
-
char const* start = gExtensionString;
do {
// length of the extension name
diff --git a/opengl/libs/EGL/egl_display.h b/opengl/libs/EGL/egl_display.h
index 661f47e..ccd333d 100644
--- a/opengl/libs/EGL/egl_display.h
+++ b/opengl/libs/EGL/egl_display.h
@@ -42,6 +42,8 @@
class egl_context_t;
struct egl_connection_t;
+bool findExtension(const char* exts, const char* name, size_t nameLen = 0);
+
// ----------------------------------------------------------------------------
class EGLAPI egl_display_t { // marked as EGLAPI for testing purposes
diff --git a/opengl/libs/EGL/egl_object.cpp b/opengl/libs/EGL/egl_object.cpp
index b68fd61..f879254 100644
--- a/opengl/libs/EGL/egl_object.cpp
+++ b/opengl/libs/EGL/egl_object.cpp
@@ -64,8 +64,17 @@
cnx(cnx),
connected(true),
colorSpace(colorSpace),
- egl_smpte2086_metadata({}),
- egl_cta861_3_metadata({}) {
+ egl_smpte2086_dirty(false),
+ egl_cta861_3_dirty(false) {
+ egl_smpte2086_metadata.displayPrimaryRed = { EGL_DONT_CARE, EGL_DONT_CARE };
+ egl_smpte2086_metadata.displayPrimaryGreen = { EGL_DONT_CARE, EGL_DONT_CARE };
+ egl_smpte2086_metadata.displayPrimaryBlue = { EGL_DONT_CARE, EGL_DONT_CARE };
+ egl_smpte2086_metadata.whitePoint = { EGL_DONT_CARE, EGL_DONT_CARE };
+ egl_smpte2086_metadata.maxLuminance = EGL_DONT_CARE;
+ egl_smpte2086_metadata.minLuminance = EGL_DONT_CARE;
+ egl_cta861_3_metadata.maxFrameAverageLightLevel = EGL_DONT_CARE;
+ egl_cta861_3_metadata.maxContentLightLevel = EGL_DONT_CARE;
+
if (win) {
win->incStrong(this);
}
@@ -92,33 +101,43 @@
switch (attribute) {
case EGL_SMPTE2086_DISPLAY_PRIMARY_RX_EXT:
egl_smpte2086_metadata.displayPrimaryRed.x = value;
+ egl_smpte2086_dirty = true;
return EGL_TRUE;
case EGL_SMPTE2086_DISPLAY_PRIMARY_RY_EXT:
egl_smpte2086_metadata.displayPrimaryRed.y = value;
+ egl_smpte2086_dirty = true;
return EGL_TRUE;
case EGL_SMPTE2086_DISPLAY_PRIMARY_GX_EXT:
egl_smpte2086_metadata.displayPrimaryGreen.x = value;
+ egl_smpte2086_dirty = true;
return EGL_TRUE;
case EGL_SMPTE2086_DISPLAY_PRIMARY_GY_EXT:
egl_smpte2086_metadata.displayPrimaryGreen.y = value;
+ egl_smpte2086_dirty = true;
return EGL_TRUE;
case EGL_SMPTE2086_DISPLAY_PRIMARY_BX_EXT:
egl_smpte2086_metadata.displayPrimaryBlue.x = value;
+ egl_smpte2086_dirty = true;
return EGL_TRUE;
case EGL_SMPTE2086_DISPLAY_PRIMARY_BY_EXT:
egl_smpte2086_metadata.displayPrimaryBlue.y = value;
+ egl_smpte2086_dirty = true;
return EGL_TRUE;
case EGL_SMPTE2086_WHITE_POINT_X_EXT:
egl_smpte2086_metadata.whitePoint.x = value;
+ egl_smpte2086_dirty = true;
return EGL_TRUE;
case EGL_SMPTE2086_WHITE_POINT_Y_EXT:
egl_smpte2086_metadata.whitePoint.y = value;
+ egl_smpte2086_dirty = true;
return EGL_TRUE;
case EGL_SMPTE2086_MAX_LUMINANCE_EXT:
egl_smpte2086_metadata.maxLuminance = value;
+ egl_smpte2086_dirty = true;
return EGL_TRUE;
case EGL_SMPTE2086_MIN_LUMINANCE_EXT:
egl_smpte2086_metadata.minLuminance = value;
+ egl_smpte2086_dirty = true;
return EGL_TRUE;
}
return EGL_FALSE;
@@ -128,16 +147,32 @@
switch (attribute) {
case EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT:
egl_cta861_3_metadata.maxContentLightLevel = value;
+ egl_cta861_3_dirty = true;
return EGL_TRUE;
case EGL_CTA861_3_MAX_FRAME_AVERAGE_LEVEL_EXT:
egl_cta861_3_metadata.maxFrameAverageLightLevel = value;
+ egl_cta861_3_dirty = true;
return EGL_TRUE;
}
return EGL_FALSE;
}
-const android_smpte2086_metadata egl_surface_t::getSmpte2086Metadata() {
- android_smpte2086_metadata metadata;
+EGLBoolean egl_surface_t::getSmpte2086Metadata(android_smpte2086_metadata& metadata) const {
+ if (!egl_smpte2086_dirty) return EGL_FALSE;
+ if (egl_smpte2086_metadata.displayPrimaryRed.x == EGL_DONT_CARE ||
+ egl_smpte2086_metadata.displayPrimaryRed.y == EGL_DONT_CARE ||
+ egl_smpte2086_metadata.displayPrimaryGreen.x == EGL_DONT_CARE ||
+ egl_smpte2086_metadata.displayPrimaryGreen.y == EGL_DONT_CARE ||
+ egl_smpte2086_metadata.displayPrimaryBlue.x == EGL_DONT_CARE ||
+ egl_smpte2086_metadata.displayPrimaryBlue.y == EGL_DONT_CARE ||
+ egl_smpte2086_metadata.whitePoint.x == EGL_DONT_CARE ||
+ egl_smpte2086_metadata.whitePoint.y == EGL_DONT_CARE ||
+ egl_smpte2086_metadata.maxLuminance == EGL_DONT_CARE ||
+ egl_smpte2086_metadata.minLuminance == EGL_DONT_CARE) {
+ ALOGW("egl_surface_t: incomplete SMPTE 2086 metadata!");
+ return EGL_FALSE;
+ }
+
metadata.displayPrimaryRed.x = static_cast<float>(egl_smpte2086_metadata.displayPrimaryRed.x) / EGL_METADATA_SCALING_EXT;
metadata.displayPrimaryRed.y = static_cast<float>(egl_smpte2086_metadata.displayPrimaryRed.y) / EGL_METADATA_SCALING_EXT;
metadata.displayPrimaryGreen.x = static_cast<float>(egl_smpte2086_metadata.displayPrimaryGreen.x) / EGL_METADATA_SCALING_EXT;
@@ -149,14 +184,22 @@
metadata.maxLuminance = static_cast<float>(egl_smpte2086_metadata.maxLuminance) / EGL_METADATA_SCALING_EXT;
metadata.minLuminance = static_cast<float>(egl_smpte2086_metadata.minLuminance) / EGL_METADATA_SCALING_EXT;
- return metadata;
+ return EGL_TRUE;
}
-const android_cta861_3_metadata egl_surface_t::getCta8613Metadata() {
- android_cta861_3_metadata metadata;
+EGLBoolean egl_surface_t::getCta8613Metadata(android_cta861_3_metadata& metadata) const {
+ if (!egl_cta861_3_dirty) return EGL_FALSE;
+
+ if (egl_cta861_3_metadata.maxContentLightLevel == EGL_DONT_CARE ||
+ egl_cta861_3_metadata.maxFrameAverageLightLevel == EGL_DONT_CARE) {
+ ALOGW("egl_surface_t: incomplete CTA861.3 metadata!");
+ return EGL_FALSE;
+ }
+
metadata.maxContentLightLevel = static_cast<float>(egl_cta861_3_metadata.maxContentLightLevel) / EGL_METADATA_SCALING_EXT;
metadata.maxFrameAverageLightLevel = static_cast<float>(egl_cta861_3_metadata.maxFrameAverageLightLevel) / EGL_METADATA_SCALING_EXT;
- return metadata;
+
+ return EGL_TRUE;
}
diff --git a/opengl/libs/EGL/egl_object.h b/opengl/libs/EGL/egl_object.h
index bda91bb..4e1de5c 100644
--- a/opengl/libs/EGL/egl_object.h
+++ b/opengl/libs/EGL/egl_object.h
@@ -142,8 +142,10 @@
EGLBoolean getColorSpaceAttribute(EGLint attribute, EGLint* value) const;
EGLBoolean getSmpte2086Attribute(EGLint attribute, EGLint* value) const;
EGLBoolean getCta8613Attribute(EGLint attribute, EGLint* value) const;
- const android_smpte2086_metadata getSmpte2086Metadata();
- const android_cta861_3_metadata getCta8613Metadata();
+ EGLBoolean getSmpte2086Metadata(android_smpte2086_metadata& smpte2086) const;
+ EGLBoolean getCta8613Metadata(android_cta861_3_metadata& cta861_3) const;
+ void resetSmpte2086Metadata() { egl_smpte2086_dirty = false; }
+ void resetCta8613Metadata() { egl_cta861_3_dirty = false; }
// Try to keep the order of these fields and size unchanged. It's not public API, but
// it's not hard to imagine native games accessing them.
@@ -176,6 +178,10 @@
EGLint maxContentLightLevel;
EGLint maxFrameAverageLightLevel;
};
+
+ bool egl_smpte2086_dirty;
+ bool egl_cta861_3_dirty;
+
egl_smpte2086_metadata egl_smpte2086_metadata;
egl_cta861_3_metadata egl_cta861_3_metadata;
};
diff --git a/opengl/tests/EGLTest/EGL_test.cpp b/opengl/tests/EGLTest/EGL_test.cpp
index 9ffe036..5927dc1 100644
--- a/opengl/tests/EGLTest/EGL_test.cpp
+++ b/opengl/tests/EGLTest/EGL_test.cpp
@@ -61,8 +61,8 @@
class EGLTest : public ::testing::Test {
public:
void get8BitConfig(EGLConfig& config);
- void addOptionalWindowMetadata(std::vector<EGLint>& attrs);
- void checkOptionalWindowMetadata(EGLSurface eglSurface);
+ void setSurfaceSmpteMetadata(EGLSurface surface);
+ void checkSurfaceSmpteMetadata(EGLSurface eglSurface);
protected:
EGLDisplay mEglDisplay;
@@ -421,39 +421,39 @@
EXPECT_EQ(components[3], 8);
}
-void EGLTest::addOptionalWindowMetadata(std::vector<EGLint>& attrs) {
+void EGLTest::setSurfaceSmpteMetadata(EGLSurface surface) {
if (hasEglExtension(mEglDisplay, "EGL_EXT_surface_SMPTE2086_metadata")) {
- attrs.push_back(EGL_SMPTE2086_DISPLAY_PRIMARY_RX_EXT);
- attrs.push_back(METADATA_SCALE(0.640));
- attrs.push_back(EGL_SMPTE2086_DISPLAY_PRIMARY_RY_EXT);
- attrs.push_back(METADATA_SCALE(0.330));
- attrs.push_back(EGL_SMPTE2086_DISPLAY_PRIMARY_GX_EXT);
- attrs.push_back(METADATA_SCALE(0.290));
- attrs.push_back(EGL_SMPTE2086_DISPLAY_PRIMARY_GY_EXT);
- attrs.push_back(METADATA_SCALE(0.600));
- attrs.push_back(EGL_SMPTE2086_DISPLAY_PRIMARY_BX_EXT);
- attrs.push_back(METADATA_SCALE(0.150));
- attrs.push_back(EGL_SMPTE2086_DISPLAY_PRIMARY_BY_EXT);
- attrs.push_back(METADATA_SCALE(0.060));
- attrs.push_back(EGL_SMPTE2086_WHITE_POINT_X_EXT);
- attrs.push_back(METADATA_SCALE(0.3127));
- attrs.push_back(EGL_SMPTE2086_WHITE_POINT_Y_EXT);
- attrs.push_back(METADATA_SCALE(0.3290));
- attrs.push_back(EGL_SMPTE2086_MAX_LUMINANCE_EXT);
- attrs.push_back(METADATA_SCALE(300));
- attrs.push_back(EGL_SMPTE2086_MIN_LUMINANCE_EXT);
- attrs.push_back(METADATA_SCALE(0.7));
+ eglSurfaceAttrib(mEglDisplay, surface, EGL_SMPTE2086_DISPLAY_PRIMARY_RX_EXT,
+ METADATA_SCALE(0.640));
+ eglSurfaceAttrib(mEglDisplay, surface, EGL_SMPTE2086_DISPLAY_PRIMARY_RY_EXT,
+ METADATA_SCALE(0.330));
+ eglSurfaceAttrib(mEglDisplay, surface, EGL_SMPTE2086_DISPLAY_PRIMARY_GX_EXT,
+ METADATA_SCALE(0.290));
+ eglSurfaceAttrib(mEglDisplay, surface, EGL_SMPTE2086_DISPLAY_PRIMARY_GY_EXT,
+ METADATA_SCALE(0.600));
+ eglSurfaceAttrib(mEglDisplay, surface, EGL_SMPTE2086_DISPLAY_PRIMARY_BX_EXT,
+ METADATA_SCALE(0.150));
+ eglSurfaceAttrib(mEglDisplay, surface, EGL_SMPTE2086_DISPLAY_PRIMARY_BY_EXT,
+ METADATA_SCALE(0.060));
+ eglSurfaceAttrib(mEglDisplay, surface, EGL_SMPTE2086_WHITE_POINT_X_EXT,
+ METADATA_SCALE(0.3127));
+ eglSurfaceAttrib(mEglDisplay, surface, EGL_SMPTE2086_WHITE_POINT_Y_EXT,
+ METADATA_SCALE(0.3290));
+ eglSurfaceAttrib(mEglDisplay, surface, EGL_SMPTE2086_MAX_LUMINANCE_EXT,
+ METADATA_SCALE(300));
+ eglSurfaceAttrib(mEglDisplay, surface, EGL_SMPTE2086_MIN_LUMINANCE_EXT,
+ METADATA_SCALE(0.7));
}
if (hasEglExtension(mEglDisplay, "EGL_EXT_surface_CTA861_3_metadata")) {
- attrs.push_back(EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT);
- attrs.push_back(METADATA_SCALE(300));
- attrs.push_back(EGL_CTA861_3_MAX_FRAME_AVERAGE_LEVEL_EXT);
- attrs.push_back(METADATA_SCALE(75));
+ eglSurfaceAttrib(mEglDisplay, surface, EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT,
+ METADATA_SCALE(300));
+ eglSurfaceAttrib(mEglDisplay, surface, EGL_CTA861_3_MAX_FRAME_AVERAGE_LEVEL_EXT,
+ METADATA_SCALE(75));
}
}
-void EGLTest::checkOptionalWindowMetadata(EGLSurface eglSurface) {
+void EGLTest::checkSurfaceSmpteMetadata(EGLSurface eglSurface) {
EGLBoolean success;
EGLint value;
@@ -534,8 +534,6 @@
winAttrs.push_back(EGL_GL_COLORSPACE_KHR);
winAttrs.push_back(EGL_GL_COLORSPACE_BT2020_PQ_EXT);
- ASSERT_NO_FATAL_FAILURE(addOptionalWindowMetadata(winAttrs));
-
winAttrs.push_back(EGL_NONE);
EGLSurface eglSurface = eglCreateWindowSurface(mEglDisplay, config, mANW.get(), winAttrs.data());
@@ -547,7 +545,9 @@
ASSERT_EQ(EGL_UNSIGNED_TRUE, success);
ASSERT_EQ(EGL_GL_COLORSPACE_BT2020_PQ_EXT, value);
- ASSERT_NO_FATAL_FAILURE(checkOptionalWindowMetadata(eglSurface));
+ ASSERT_NO_FATAL_FAILURE(setSurfaceSmpteMetadata(eglSurface));
+
+ ASSERT_NO_FATAL_FAILURE(checkSurfaceSmpteMetadata(eglSurface));
EXPECT_TRUE(eglDestroySurface(mEglDisplay, eglSurface));
}
@@ -584,9 +584,6 @@
std::vector<EGLint> winAttrs;
winAttrs.push_back(EGL_GL_COLORSPACE_KHR);
winAttrs.push_back(EGL_GL_COLORSPACE_BT2020_PQ_EXT);
-
- ASSERT_NO_FATAL_FAILURE(addOptionalWindowMetadata(winAttrs));
-
winAttrs.push_back(EGL_NONE);
EGLSurface eglSurface = eglCreateWindowSurface(mEglDisplay, config, mANW.get(), winAttrs.data());
@@ -598,7 +595,9 @@
ASSERT_EQ(EGL_UNSIGNED_TRUE, success);
ASSERT_EQ(EGL_GL_COLORSPACE_BT2020_PQ_EXT, value);
- ASSERT_NO_FATAL_FAILURE(checkOptionalWindowMetadata(eglSurface));
+ ASSERT_NO_FATAL_FAILURE(setSurfaceSmpteMetadata(eglSurface));
+
+ ASSERT_NO_FATAL_FAILURE(checkSurfaceSmpteMetadata(eglSurface));
EXPECT_TRUE(eglDestroySurface(mEglDisplay, eglSurface));
}
diff --git a/opengl/tests/gl2_basic/gl2_basic.cpp b/opengl/tests/gl2_basic/gl2_basic.cpp
index 13f6fba..0bb77f3 100644
--- a/opengl/tests/gl2_basic/gl2_basic.cpp
+++ b/opengl/tests/gl2_basic/gl2_basic.cpp
@@ -32,6 +32,8 @@
using namespace android;
extern "C" EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);
+#define METADATA_SCALE(x) (static_cast<EGLint>(x * EGL_METADATA_SCALING_EXT))
+
static void printGLString(const char *name, GLenum s) {
// fprintf(stderr, "printGLString %s, %d\n", name, s);
const char *v = (const char *) glGetString(s);
@@ -265,6 +267,39 @@
return true;
}
+void setSurfaceMetadata(EGLDisplay dpy, EGLSurface surface) {
+ static EGLBoolean toggle = GL_FALSE;
+ if (EGLUtils::hasEglExtension(dpy, "EGL_EXT_surface_SMPTE2086_metadata")) {
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_DISPLAY_PRIMARY_RX_EXT, METADATA_SCALE(0.640));
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_DISPLAY_PRIMARY_RY_EXT, METADATA_SCALE(0.330));
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_DISPLAY_PRIMARY_GX_EXT, METADATA_SCALE(0.290));
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_DISPLAY_PRIMARY_GY_EXT, METADATA_SCALE(0.600));
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_DISPLAY_PRIMARY_BX_EXT, METADATA_SCALE(0.150));
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_DISPLAY_PRIMARY_BY_EXT, METADATA_SCALE(0.060));
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_WHITE_POINT_X_EXT, METADATA_SCALE(0.3127));
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_WHITE_POINT_Y_EXT, METADATA_SCALE(0.3290));
+ if (toggle) {
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_MAX_LUMINANCE_EXT, METADATA_SCALE(350));
+ } else {
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_MAX_LUMINANCE_EXT, METADATA_SCALE(300));
+ }
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_MIN_LUMINANCE_EXT, METADATA_SCALE(0.7));
+ }
+
+ if (EGLUtils::hasEglExtension(dpy, "EGL_EXT_surface_CTA861_3_metadata")) {
+ if (toggle) {
+ eglSurfaceAttrib(dpy, surface, EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT,
+ METADATA_SCALE(300));
+ } else {
+ eglSurfaceAttrib(dpy, surface, EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT,
+ METADATA_SCALE(325));
+ }
+ eglSurfaceAttrib(dpy, surface, EGL_CTA861_3_MAX_FRAME_AVERAGE_LEVEL_EXT,
+ METADATA_SCALE(75));
+ }
+ toggle = !toggle;
+}
+
int main(int /*argc*/, char** /*argv*/) {
EGLBoolean returnValue;
EGLConfig myConfig = {0};
@@ -318,10 +353,11 @@
printf("Chose this configuration:\n");
printEGLConfiguration(dpy, myConfig);
- surface = eglCreateWindowSurface(dpy, myConfig, window, NULL);
+ EGLint winAttribs[] = {EGL_GL_COLORSPACE_KHR, EGL_GL_COLORSPACE_SRGB_KHR, EGL_NONE};
+ surface = eglCreateWindowSurface(dpy, myConfig, window, winAttribs);
checkEglError("eglCreateWindowSurface");
if (surface == EGL_NO_SURFACE) {
- printf("gelCreateWindowSurface failed.\n");
+ printf("eglCreateWindowSurface failed.\n");
return 0;
}
@@ -356,6 +392,7 @@
for (;;) {
renderFrame();
+ setSurfaceMetadata(dpy, surface);
eglSwapBuffers(dpy, surface);
checkEglError("eglSwapBuffers");
}
diff --git a/opengl/tests/gl2_jni/Android.mk b/opengl/tests/gl2_jni/Android.mk
index af65b5f..b0081c2 100644
--- a/opengl/tests/gl2_jni/Android.mk
+++ b/opengl/tests/gl2_jni/Android.mk
@@ -37,13 +37,13 @@
gl_code.cpp
LOCAL_SHARED_LIBRARIES := \
- libutils \
liblog \
libEGL \
libGLESv2
LOCAL_MODULE := libgl2jni
+LOCAL_SDK_VERSION := current
include $(BUILD_SHARED_LIBRARY)
diff --git a/opengl/tests/gl2_jni/jni/gl_code.cpp b/opengl/tests/gl2_jni/jni/gl_code.cpp
index 5af4f6b..9b22c6c 100644
--- a/opengl/tests/gl2_jni/jni/gl_code.cpp
+++ b/opengl/tests/gl2_jni/jni/gl_code.cpp
@@ -2,7 +2,12 @@
#include <jni.h>
#define LOG_TAG "GL2JNI gl_code.cpp"
-#include <utils/Log.h>
+#include <android/log.h>
+
+#define ALOG(priority, tag, ...) ((void)__android_log_print(ANDROID_##priority, tag, __VA_ARGS__))
+
+#define ALOGI(...) ALOG(LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define ALOGE(...) ALOG(LOG_ERROR, LOG_TAG, __VA_ARGS__)
#include <EGL/egl.h>
#include <GLES2/gl2.h>
diff --git a/opengl/tests/gl_basic/gl_basic.cpp b/opengl/tests/gl_basic/gl_basic.cpp
index a675c7c..63d94be 100644
--- a/opengl/tests/gl_basic/gl_basic.cpp
+++ b/opengl/tests/gl_basic/gl_basic.cpp
@@ -15,6 +15,8 @@
using namespace android;
+#define METADATA_SCALE(x) (static_cast<EGLint>(x * EGL_METADATA_SCALING_EXT))
+
EGLDisplay eglDisplay;
EGLSurface eglSurface;
EGLContext eglContext;
@@ -330,6 +332,39 @@
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
}
+void setSurfaceMetadata(EGLDisplay dpy, EGLSurface surface) {
+ static EGLBoolean toggle = GL_FALSE;
+ if (EGLUtils::hasEglExtension(dpy, "EGL_EXT_surface_SMPTE2086_metadata")) {
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_DISPLAY_PRIMARY_RX_EXT, METADATA_SCALE(0.640));
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_DISPLAY_PRIMARY_RY_EXT, METADATA_SCALE(0.330));
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_DISPLAY_PRIMARY_GX_EXT, METADATA_SCALE(0.290));
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_DISPLAY_PRIMARY_GY_EXT, METADATA_SCALE(0.600));
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_DISPLAY_PRIMARY_BX_EXT, METADATA_SCALE(0.150));
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_DISPLAY_PRIMARY_BY_EXT, METADATA_SCALE(0.060));
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_WHITE_POINT_X_EXT, METADATA_SCALE(0.3127));
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_WHITE_POINT_Y_EXT, METADATA_SCALE(0.3290));
+ if (toggle) {
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_MAX_LUMINANCE_EXT, METADATA_SCALE(350));
+ } else {
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_MAX_LUMINANCE_EXT, METADATA_SCALE(300));
+ }
+ eglSurfaceAttrib(dpy, surface, EGL_SMPTE2086_MIN_LUMINANCE_EXT, METADATA_SCALE(0.7));
+ }
+
+ if (EGLUtils::hasEglExtension(dpy, "EGL_EXT_surface_CTA861_3_metadata")) {
+ if (toggle) {
+ eglSurfaceAttrib(dpy, surface, EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT,
+ METADATA_SCALE(300));
+ } else {
+ eglSurfaceAttrib(dpy, surface, EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT,
+ METADATA_SCALE(325));
+ }
+ eglSurfaceAttrib(dpy, surface, EGL_CTA861_3_MAX_FRAME_AVERAGE_LEVEL_EXT,
+ METADATA_SCALE(75));
+ }
+ toggle = !toggle;
+}
+
void render()
{
const GLfloat vertices[] = {
@@ -354,5 +389,6 @@
int nelem = sizeof(indices)/sizeof(indices[0]);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
glDrawElements(GL_TRIANGLES, nelem, GL_UNSIGNED_SHORT, indices);
+ setSurfaceMetadata(eglDisplay, eglSurface);
eglSwapBuffers(eglDisplay, eglSurface);
}
diff --git a/opengl/tests/gl_jni/Android.mk b/opengl/tests/gl_jni/Android.mk
index 570ae2b..d64dfcf 100644
--- a/opengl/tests/gl_jni/Android.mk
+++ b/opengl/tests/gl_jni/Android.mk
@@ -37,13 +37,14 @@
gl_code.cpp
LOCAL_SHARED_LIBRARIES := \
- libutils \
liblog \
libEGL \
libGLESv1_CM
LOCAL_MODULE := libgljni
+LOCAL_SDK_VERSION := current
+
LOCAL_ARM_MODE := arm
diff --git a/opengl/tests/gl_jni/jni/gl_code.cpp b/opengl/tests/gl_jni/jni/gl_code.cpp
index 3aa8adb..88f3228 100644
--- a/opengl/tests/gl_jni/jni/gl_code.cpp
+++ b/opengl/tests/gl_jni/jni/gl_code.cpp
@@ -2,7 +2,12 @@
#include <jni.h>
#define LOG_TAG "GLJNI gl_code.cpp"
-#include <utils/Log.h>
+#include <android/log.h>
+
+#define ALOG(priority, tag, ...) ((void)__android_log_print(ANDROID_##priority, tag, __VA_ARGS__))
+
+#define ALOGI(...) ALOG(LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define ALOGE(...) ALOG(LOG_ERROR, LOG_TAG, __VA_ARGS__)
#include <GLES/gl.h>
diff --git a/opengl/tests/gl_perfapp/Android.mk b/opengl/tests/gl_perfapp/Android.mk
index 854b54f..3f411ea 100644
--- a/opengl/tests/gl_perfapp/Android.mk
+++ b/opengl/tests/gl_perfapp/Android.mk
@@ -39,11 +39,12 @@
gl_code.cpp
LOCAL_SHARED_LIBRARIES := \
- libutils \
liblog \
libEGL \
libGLESv2
+LOCAL_SDK_VERSION := current
+
LOCAL_MODULE := libglperf
diff --git a/opengl/tests/gl_perfapp/jni/gl_code.cpp b/opengl/tests/gl_perfapp/jni/gl_code.cpp
index 0cb594a..bd1fd83 100644
--- a/opengl/tests/gl_perfapp/jni/gl_code.cpp
+++ b/opengl/tests/gl_perfapp/jni/gl_code.cpp
@@ -2,16 +2,21 @@
#include <jni.h>
#define LOG_TAG "GLPerf gl_code.cpp"
-#include <utils/Log.h>
+#include <android/log.h>
+
+#define ALOG(priority, tag, ...) ((void)__android_log_print(ANDROID_##priority, tag, __VA_ARGS__))
+
+#define ALOGI(...) ALOG(LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define ALOGE(...) ALOG(LOG_ERROR, LOG_TAG, __VA_ARGS__)
#include <EGL/egl.h>
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
-#include <utils/Timers.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
+#include <time.h>
#include "../../gl_perf/fill_common.cpp"
diff --git a/opengl/tests/gldual/Android.mk b/opengl/tests/gldual/Android.mk
index dc265b6..5bdc0a8 100644
--- a/opengl/tests/gldual/Android.mk
+++ b/opengl/tests/gldual/Android.mk
@@ -37,13 +37,13 @@
gl_code.cpp
LOCAL_SHARED_LIBRARIES := \
- libutils \
liblog \
libEGL \
libGLESv2
LOCAL_MODULE := libgldualjni
+LOCAL_SDK_VERSION := current
include $(BUILD_SHARED_LIBRARY)
diff --git a/opengl/tests/gldual/jni/gl_code.cpp b/opengl/tests/gldual/jni/gl_code.cpp
index 90d150b..4e44976 100644
--- a/opengl/tests/gldual/jni/gl_code.cpp
+++ b/opengl/tests/gldual/jni/gl_code.cpp
@@ -2,7 +2,12 @@
#include <jni.h>
#define LOG_TAG "GL2JNI gl_code.cpp"
-#include <utils/Log.h>
+#include <android/log.h>
+
+#define ALOG(priority, tag, ...) ((void)__android_log_print(ANDROID_##priority, tag, __VA_ARGS__))
+
+#define ALOGI(...) ALOG(LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define ALOGE(...) ALOG(LOG_ERROR, LOG_TAG, __VA_ARGS__)
#include <EGL/egl.h>
#include <GLES2/gl2.h>
diff --git a/services/inputflinger/InputDispatcher.cpp b/services/inputflinger/InputDispatcher.cpp
index c3f4f58..4d32ea6 100644
--- a/services/inputflinger/InputDispatcher.cpp
+++ b/services/inputflinger/InputDispatcher.cpp
@@ -894,12 +894,13 @@
void InputDispatcher::logOutboundMotionDetailsLocked(const char* prefix, const MotionEntry* entry) {
#if DEBUG_OUTBOUND_EVENT_DETAILS
- ALOGD("%seventTime=%" PRId64 ", deviceId=%d, source=0x%x, policyFlags=0x%x, "
+ ALOGD("%seventTime=%" PRId64 ", deviceId=%d, source=0x%x, displayId=%" PRId32
+ ", policyFlags=0x%x, "
"action=0x%x, actionButton=0x%x, flags=0x%x, "
"metaState=0x%x, buttonState=0x%x,"
"edgeFlags=0x%x, xPrecision=%f, yPrecision=%f, downTime=%" PRId64,
prefix,
- entry->eventTime, entry->deviceId, entry->source, entry->policyFlags,
+ entry->eventTime, entry->deviceId, entry->source, entry->displayId, entry->policyFlags,
entry->action, entry->actionButton, entry->flags,
entry->metaState, entry->buttonState,
entry->edgeFlags, entry->xPrecision, entry->yPrecision,
@@ -2354,6 +2355,7 @@
originalMotionEntry->eventTime,
originalMotionEntry->deviceId,
originalMotionEntry->source,
+ originalMotionEntry->displayId,
originalMotionEntry->policyFlags,
action,
originalMotionEntry->actionButton,
@@ -2364,7 +2366,6 @@
originalMotionEntry->xPrecision,
originalMotionEntry->yPrecision,
originalMotionEntry->downTime,
- originalMotionEntry->displayId,
splitPointerCount, splitPointerProperties, splitPointerCoords, 0, 0);
if (originalMotionEntry->injectionState) {
@@ -2496,10 +2497,11 @@
void InputDispatcher::notifyMotion(const NotifyMotionArgs* args) {
#if DEBUG_INBOUND_EVENT_DETAILS
- ALOGD("notifyMotion - eventTime=%" PRId64 ", deviceId=%d, source=0x%x, policyFlags=0x%x, "
+ ALOGD("notifyMotion - eventTime=%" PRId64 ", deviceId=%d, source=0x%x, displayId=%" PRId32
+ ", policyFlags=0x%x, "
"action=0x%x, actionButton=0x%x, flags=0x%x, metaState=0x%x, buttonState=0x%x,"
"edgeFlags=0x%x, xPrecision=%f, yPrecision=%f, downTime=%" PRId64,
- args->eventTime, args->deviceId, args->source, args->policyFlags,
+ args->eventTime, args->deviceId, args->source, args->displayId, args->policyFlags,
args->action, args->actionButton, args->flags, args->metaState, args->buttonState,
args->edgeFlags, args->xPrecision, args->yPrecision, args->downTime);
for (uint32_t i = 0; i < args->pointerCount; i++) {
@@ -2543,7 +2545,8 @@
mLock.unlock();
MotionEvent event;
- event.initialize(args->deviceId, args->source, args->action, args->actionButton,
+ event.initialize(args->deviceId, args->source, args->displayId,
+ args->action, args->actionButton,
args->flags, args->edgeFlags, args->metaState, args->buttonState,
0, 0, args->xPrecision, args->yPrecision,
args->downTime, args->eventTime,
@@ -2559,11 +2562,10 @@
// Just enqueue a new motion event.
MotionEntry* newEntry = new MotionEntry(args->eventTime,
- args->deviceId, args->source, policyFlags,
+ args->deviceId, args->source, args->displayId, policyFlags,
args->action, args->actionButton, args->flags,
args->metaState, args->buttonState,
args->edgeFlags, args->xPrecision, args->yPrecision, args->downTime,
- args->displayId,
args->pointerCount, args->pointerProperties, args->pointerCoords, 0, 0);
needWake = enqueueInboundEventLocked(newEntry);
@@ -2612,14 +2614,13 @@
}
}
-int32_t InputDispatcher::injectInputEvent(const InputEvent* event, int32_t displayId,
+int32_t InputDispatcher::injectInputEvent(const InputEvent* event,
int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis,
uint32_t policyFlags) {
#if DEBUG_INBOUND_EVENT_DETAILS
ALOGD("injectInputEvent - eventType=%d, injectorPid=%d, injectorUid=%d, "
- "syncMode=%d, timeoutMillis=%d, policyFlags=0x%08x, displayId=%d",
- event->getType(), injectorPid, injectorUid, syncMode, timeoutMillis, policyFlags,
- displayId);
+ "syncMode=%d, timeoutMillis=%d, policyFlags=0x%08x",
+ event->getType(), injectorPid, injectorUid, syncMode, timeoutMillis, policyFlags);
#endif
nsecs_t endTime = now() + milliseconds_to_nanoseconds(timeoutMillis);
@@ -2687,12 +2688,13 @@
const nsecs_t* sampleEventTimes = motionEvent->getSampleEventTimes();
const PointerCoords* samplePointerCoords = motionEvent->getSamplePointerCoords();
firstInjectedEntry = new MotionEntry(*sampleEventTimes,
- motionEvent->getDeviceId(), motionEvent->getSource(), policyFlags,
+ motionEvent->getDeviceId(), motionEvent->getSource(), motionEvent->getDisplayId(),
+ policyFlags,
action, actionButton, motionEvent->getFlags(),
motionEvent->getMetaState(), motionEvent->getButtonState(),
motionEvent->getEdgeFlags(),
motionEvent->getXPrecision(), motionEvent->getYPrecision(),
- motionEvent->getDownTime(), displayId,
+ motionEvent->getDownTime(),
uint32_t(pointerCount), pointerProperties, samplePointerCoords,
motionEvent->getXOffset(), motionEvent->getYOffset());
lastInjectedEntry = firstInjectedEntry;
@@ -2700,12 +2702,13 @@
sampleEventTimes += 1;
samplePointerCoords += pointerCount;
MotionEntry* nextInjectedEntry = new MotionEntry(*sampleEventTimes,
- motionEvent->getDeviceId(), motionEvent->getSource(), policyFlags,
+ motionEvent->getDeviceId(), motionEvent->getSource(),
+ motionEvent->getDisplayId(), policyFlags,
action, actionButton, motionEvent->getFlags(),
motionEvent->getMetaState(), motionEvent->getButtonState(),
motionEvent->getEdgeFlags(),
motionEvent->getXPrecision(), motionEvent->getYPrecision(),
- motionEvent->getDownTime(), displayId,
+ motionEvent->getDownTime(),
uint32_t(pointerCount), pointerProperties, samplePointerCoords,
motionEvent->getXOffset(), motionEvent->getYOffset());
lastInjectedEntry->next = nextInjectedEntry;
@@ -3996,18 +3999,19 @@
// --- InputDispatcher::MotionEntry ---
InputDispatcher::MotionEntry::MotionEntry(nsecs_t eventTime, int32_t deviceId,
- uint32_t source, uint32_t policyFlags, int32_t action, int32_t actionButton,
+ uint32_t source, int32_t displayId, uint32_t policyFlags, int32_t action,
+ int32_t actionButton,
int32_t flags, int32_t metaState, int32_t buttonState, int32_t edgeFlags,
float xPrecision, float yPrecision, nsecs_t downTime,
- int32_t displayId, uint32_t pointerCount,
+ uint32_t pointerCount,
const PointerProperties* pointerProperties, const PointerCoords* pointerCoords,
float xOffset, float yOffset) :
EventEntry(TYPE_MOTION, eventTime, policyFlags),
eventTime(eventTime),
- deviceId(deviceId), source(source), action(action), actionButton(actionButton),
- flags(flags), metaState(metaState), buttonState(buttonState),
+ deviceId(deviceId), source(source), displayId(displayId), action(action),
+ actionButton(actionButton), flags(flags), metaState(metaState), buttonState(buttonState),
edgeFlags(edgeFlags), xPrecision(xPrecision), yPrecision(yPrecision),
- downTime(downTime), displayId(displayId), pointerCount(pointerCount) {
+ downTime(downTime), pointerCount(pointerCount) {
for (uint32_t i = 0; i < pointerCount; i++) {
this->pointerProperties[i].copyFrom(pointerProperties[i]);
this->pointerCoords[i].copyFrom(pointerCoords[i]);
@@ -4021,11 +4025,12 @@
}
void InputDispatcher::MotionEntry::appendDescription(std::string& msg) const {
- msg += StringPrintf("MotionEvent(deviceId=%d, source=0x%08x, action=%d, actionButton=0x%08x, "
+ msg += StringPrintf("MotionEvent(deviceId=%d, source=0x%08x, displayId=%" PRId32
+ ", action=%d, actionButton=0x%08x, "
"flags=0x%08x, metaState=0x%08x, buttonState=0x%08x, "
- "edgeFlags=0x%08x, xPrecision=%.1f, yPrecision=%.1f, displayId=%d, pointers=[",
- deviceId, source, action, actionButton, flags, metaState, buttonState, edgeFlags,
- xPrecision, yPrecision, displayId);
+ "edgeFlags=0x%08x, xPrecision=%.1f, yPrecision=%.1f, pointers=[",
+ deviceId, source, displayId, action, actionButton, flags, metaState, buttonState,
+ edgeFlags, xPrecision, yPrecision);
for (uint32_t i = 0; i < pointerCount; i++) {
if (i) {
msg += ", ";
@@ -4154,8 +4159,8 @@
}
#if DEBUG_OUTBOUND_EVENT_DETAILS
ALOGD("Dropping inconsistent motion up or cancel event: deviceId=%d, source=%08x, "
- "actionMasked=%d",
- entry->deviceId, entry->source, actionMasked);
+ "displayId=%" PRId32 ", actionMasked=%d",
+ entry->deviceId, entry->source, entry->displayId, actionMasked);
#endif
return false;
}
@@ -4207,8 +4212,8 @@
}
#if DEBUG_OUTBOUND_EVENT_DETAILS
ALOGD("Dropping inconsistent motion pointer up/down or move event: "
- "deviceId=%d, source=%08x, actionMasked=%d",
- entry->deviceId, entry->source, actionMasked);
+ "deviceId=%d, source=%08x, displayId=%" PRId32 ", actionMasked=%d",
+ entry->deviceId, entry->source, entry->displayId, actionMasked);
#endif
return false;
}
@@ -4220,8 +4225,9 @@
return true;
}
#if DEBUG_OUTBOUND_EVENT_DETAILS
- ALOGD("Dropping inconsistent motion hover exit event: deviceId=%d, source=%08x",
- entry->deviceId, entry->source);
+ ALOGD("Dropping inconsistent motion hover exit event: deviceId=%d, source=%08x, "
+ "displayId=%" PRId32,
+ entry->deviceId, entry->source, entry->displayId);
#endif
return false;
}
@@ -4287,11 +4293,11 @@
MotionMemento& memento = mMotionMementos.editTop();
memento.deviceId = entry->deviceId;
memento.source = entry->source;
+ memento.displayId = entry->displayId;
memento.flags = flags;
memento.xPrecision = entry->xPrecision;
memento.yPrecision = entry->yPrecision;
memento.downTime = entry->downTime;
- memento.displayId = entry->displayId;
memento.setPointers(entry);
memento.hovering = hovering;
memento.policyFlags = entry->policyFlags;
@@ -4321,13 +4327,12 @@
const MotionMemento& memento = mMotionMementos.itemAt(i);
if (shouldCancelMotion(memento, options)) {
outEvents.push(new MotionEntry(currentTime,
- memento.deviceId, memento.source, memento.policyFlags,
+ memento.deviceId, memento.source, memento.displayId, memento.policyFlags,
memento.hovering
? AMOTION_EVENT_ACTION_HOVER_EXIT
: AMOTION_EVENT_ACTION_CANCEL,
memento.flags, 0, 0, 0, 0,
memento.xPrecision, memento.yPrecision, memento.downTime,
- memento.displayId,
memento.pointerCount, memento.pointerProperties, memento.pointerCoords,
0, 0));
}
diff --git a/services/inputflinger/InputDispatcher.h b/services/inputflinger/InputDispatcher.h
index 8da8450..5f76abe 100644
--- a/services/inputflinger/InputDispatcher.h
+++ b/services/inputflinger/InputDispatcher.h
@@ -299,7 +299,7 @@
*
* This method may be called on any thread (usually by the input manager).
*/
- virtual int32_t injectInputEvent(const InputEvent* event, int32_t displayId,
+ virtual int32_t injectInputEvent(const InputEvent* event,
int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis,
uint32_t policyFlags) = 0;
@@ -383,7 +383,7 @@
virtual void notifySwitch(const NotifySwitchArgs* args);
virtual void notifyDeviceReset(const NotifyDeviceResetArgs* args);
- virtual int32_t injectInputEvent(const InputEvent* event, int32_t displayId,
+ virtual int32_t injectInputEvent(const InputEvent* event,
int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis,
uint32_t policyFlags);
@@ -508,6 +508,7 @@
nsecs_t eventTime;
int32_t deviceId;
uint32_t source;
+ int32_t displayId;
int32_t action;
int32_t actionButton;
int32_t flags;
@@ -517,17 +518,15 @@
float xPrecision;
float yPrecision;
nsecs_t downTime;
- int32_t displayId;
uint32_t pointerCount;
PointerProperties pointerProperties[MAX_POINTERS];
PointerCoords pointerCoords[MAX_POINTERS];
MotionEntry(nsecs_t eventTime,
- int32_t deviceId, uint32_t source, uint32_t policyFlags,
+ int32_t deviceId, uint32_t source, int32_t displayId, uint32_t policyFlags,
int32_t action, int32_t actionButton, int32_t flags,
int32_t metaState, int32_t buttonState, int32_t edgeFlags,
- float xPrecision, float yPrecision, nsecs_t downTime,
- int32_t displayId, uint32_t pointerCount,
+ float xPrecision, float yPrecision, nsecs_t downTime, uint32_t pointerCount,
const PointerProperties* pointerProperties, const PointerCoords* pointerCoords,
float xOffset, float yOffset);
virtual void appendDescription(std::string& msg) const;
@@ -765,11 +764,11 @@
struct MotionMemento {
int32_t deviceId;
uint32_t source;
+ int32_t displayId;
int32_t flags;
float xPrecision;
float yPrecision;
nsecs_t downTime;
- int32_t displayId;
uint32_t pointerCount;
PointerProperties pointerProperties[MAX_POINTERS];
PointerCoords pointerCoords[MAX_POINTERS];
diff --git a/services/inputflinger/InputListener.cpp b/services/inputflinger/InputListener.cpp
index 520fea4..c36d7cf 100644
--- a/services/inputflinger/InputListener.cpp
+++ b/services/inputflinger/InputListener.cpp
@@ -67,16 +67,17 @@
// --- NotifyMotionArgs ---
NotifyMotionArgs::NotifyMotionArgs(nsecs_t eventTime, int32_t deviceId, uint32_t source,
- uint32_t policyFlags,
+ int32_t displayId, uint32_t policyFlags,
int32_t action, int32_t actionButton, int32_t flags, int32_t metaState,
- int32_t buttonState, int32_t edgeFlags, int32_t displayId, uint32_t deviceTimestamp,
+ int32_t buttonState, int32_t edgeFlags, uint32_t deviceTimestamp,
uint32_t pointerCount,
const PointerProperties* pointerProperties, const PointerCoords* pointerCoords,
float xPrecision, float yPrecision, nsecs_t downTime) :
- eventTime(eventTime), deviceId(deviceId), source(source), policyFlags(policyFlags),
+ eventTime(eventTime), deviceId(deviceId), source(source), displayId(displayId),
+ policyFlags(policyFlags),
action(action), actionButton(actionButton),
flags(flags), metaState(metaState), buttonState(buttonState),
- edgeFlags(edgeFlags), displayId(displayId), deviceTimestamp(deviceTimestamp),
+ edgeFlags(edgeFlags), deviceTimestamp(deviceTimestamp),
pointerCount(pointerCount),
xPrecision(xPrecision), yPrecision(yPrecision), downTime(downTime) {
for (uint32_t i = 0; i < pointerCount; i++) {
@@ -87,10 +88,10 @@
NotifyMotionArgs::NotifyMotionArgs(const NotifyMotionArgs& other) :
eventTime(other.eventTime), deviceId(other.deviceId), source(other.source),
- policyFlags(other.policyFlags),
+ displayId(other.displayId), policyFlags(other.policyFlags),
action(other.action), actionButton(other.actionButton), flags(other.flags),
metaState(other.metaState), buttonState(other.buttonState),
- edgeFlags(other.edgeFlags), displayId(other.displayId),
+ edgeFlags(other.edgeFlags),
deviceTimestamp(other.deviceTimestamp), pointerCount(other.pointerCount),
xPrecision(other.xPrecision), yPrecision(other.yPrecision), downTime(other.downTime) {
for (uint32_t i = 0; i < pointerCount; i++) {
diff --git a/services/inputflinger/InputListener.h b/services/inputflinger/InputListener.h
index 77afb34..d24be4c 100644
--- a/services/inputflinger/InputListener.h
+++ b/services/inputflinger/InputListener.h
@@ -82,6 +82,7 @@
nsecs_t eventTime;
int32_t deviceId;
uint32_t source;
+ int32_t displayId;
uint32_t policyFlags;
int32_t action;
int32_t actionButton;
@@ -89,7 +90,6 @@
int32_t metaState;
int32_t buttonState;
int32_t edgeFlags;
- int32_t displayId;
/**
* A timestamp in the input device's time base, not the platform's.
* The units are microseconds since the last reset.
@@ -106,10 +106,11 @@
inline NotifyMotionArgs() { }
- NotifyMotionArgs(nsecs_t eventTime, int32_t deviceId, uint32_t source, uint32_t policyFlags,
+ NotifyMotionArgs(nsecs_t eventTime, int32_t deviceId, uint32_t source, int32_t displayId,
+ uint32_t policyFlags,
int32_t action, int32_t actionButton, int32_t flags,
int32_t metaState, int32_t buttonState,
- int32_t edgeFlags, int32_t displayId, uint32_t deviceTimestamp, uint32_t pointerCount,
+ int32_t edgeFlags, uint32_t deviceTimestamp, uint32_t pointerCount,
const PointerProperties* pointerProperties, const PointerCoords* pointerCoords,
float xPrecision, float yPrecision, nsecs_t downTime);
diff --git a/services/inputflinger/InputReader.cpp b/services/inputflinger/InputReader.cpp
index e0cd8a0..50229cb 100644
--- a/services/inputflinger/InputReader.cpp
+++ b/services/inputflinger/InputReader.cpp
@@ -2279,15 +2279,12 @@
}
if (!changes || (changes & InputReaderConfiguration::CHANGE_DISPLAY_INFO)) {
+ mOrientation = DISPLAY_ORIENTATION_0;
if (mParameters.orientationAware && mParameters.hasAssociatedDisplay) {
DisplayViewport v;
if (config->getDisplayViewport(ViewportType::VIEWPORT_INTERNAL, NULL, &v)) {
mOrientation = v.orientation;
- } else {
- mOrientation = DISPLAY_ORIENTATION_0;
}
- } else {
- mOrientation = DISPLAY_ORIENTATION_0;
}
}
}
@@ -2699,15 +2696,12 @@
}
if (!changes || (changes & InputReaderConfiguration::CHANGE_DISPLAY_INFO)) {
+ mOrientation = DISPLAY_ORIENTATION_0;
if (mParameters.orientationAware && mParameters.hasAssociatedDisplay) {
DisplayViewport v;
if (config->getDisplayViewport(ViewportType::VIEWPORT_INTERNAL, NULL, &v)) {
mOrientation = v.orientation;
- } else {
- mOrientation = DISPLAY_ORIENTATION_0;
}
- } else {
- mOrientation = DISPLAY_ORIENTATION_0;
}
bumpGeneration();
}
@@ -2894,19 +2888,19 @@
while (!released.isEmpty()) {
int32_t actionButton = BitSet32::valueForBit(released.clearFirstMarkedBit());
buttonState &= ~actionButton;
- NotifyMotionArgs releaseArgs(when, getDeviceId(), mSource, policyFlags,
+ NotifyMotionArgs releaseArgs(when, getDeviceId(), mSource, displayId, policyFlags,
AMOTION_EVENT_ACTION_BUTTON_RELEASE, actionButton, 0,
metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,
- displayId, /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords,
+ /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords,
mXPrecision, mYPrecision, downTime);
getListener()->notifyMotion(&releaseArgs);
}
}
- NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags,
+ NotifyMotionArgs args(when, getDeviceId(), mSource, displayId, policyFlags,
motionEventAction, 0, 0, metaState, currentButtonState,
AMOTION_EVENT_EDGE_FLAG_NONE,
- displayId, /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords,
+ /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords,
mXPrecision, mYPrecision, downTime);
getListener()->notifyMotion(&args);
@@ -2915,10 +2909,10 @@
while (!pressed.isEmpty()) {
int32_t actionButton = BitSet32::valueForBit(pressed.clearFirstMarkedBit());
buttonState |= actionButton;
- NotifyMotionArgs pressArgs(when, getDeviceId(), mSource, policyFlags,
+ NotifyMotionArgs pressArgs(when, getDeviceId(), mSource, displayId, policyFlags,
AMOTION_EVENT_ACTION_BUTTON_PRESS, actionButton, 0,
metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,
- displayId, /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords,
+ /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords,
mXPrecision, mYPrecision, downTime);
getListener()->notifyMotion(&pressArgs);
}
@@ -2929,10 +2923,10 @@
// Send hover move after UP to tell the application that the mouse is hovering now.
if (motionEventAction == AMOTION_EVENT_ACTION_UP
&& (mSource == AINPUT_SOURCE_MOUSE)) {
- NotifyMotionArgs hoverArgs(when, getDeviceId(), mSource, policyFlags,
+ NotifyMotionArgs hoverArgs(when, getDeviceId(), mSource, displayId, policyFlags,
AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0,
metaState, currentButtonState, AMOTION_EVENT_EDGE_FLAG_NONE,
- displayId, /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords,
+ /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords,
mXPrecision, mYPrecision, downTime);
getListener()->notifyMotion(&hoverArgs);
}
@@ -2942,10 +2936,10 @@
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_VSCROLL, vscroll);
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_HSCROLL, hscroll);
- NotifyMotionArgs scrollArgs(when, getDeviceId(), mSource, policyFlags,
+ NotifyMotionArgs scrollArgs(when, getDeviceId(), mSource, displayId, policyFlags,
AMOTION_EVENT_ACTION_SCROLL, 0, 0, metaState, currentButtonState,
AMOTION_EVENT_EDGE_FLAG_NONE,
- displayId, /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords,
+ /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords,
mXPrecision, mYPrecision, downTime);
getListener()->notifyMotion(&scrollArgs);
}
@@ -3072,10 +3066,10 @@
int32_t metaState = mContext->getGlobalMetaState();
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_SCROLL, scroll * mScalingFactor);
- NotifyMotionArgs scrollArgs(when, getDeviceId(), mSource, policyFlags,
+ NotifyMotionArgs scrollArgs(when, getDeviceId(), mSource, displayId, policyFlags,
AMOTION_EVENT_ACTION_SCROLL, 0, 0, metaState, 0,
AMOTION_EVENT_EDGE_FLAG_NONE,
- displayId, /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords,
+ /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords,
0, 0, 0);
getListener()->notifyMotion(&scrollArgs);
}
@@ -5413,10 +5407,10 @@
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_X, x);
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, y);
- NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags,
+ NotifyMotionArgs args(when, getDeviceId(), mSource, mViewport.displayId, policyFlags,
AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0,
metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,
- mViewport.displayId, /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords,
+ /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords,
0, 0, mPointerGesture.downTime);
getListener()->notifyMotion(&args);
}
@@ -6336,9 +6330,9 @@
mPointerSimple.down = false;
// Send up.
- NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags,
+ NotifyMotionArgs args(when, getDeviceId(), mSource, mViewport.displayId, policyFlags,
AMOTION_EVENT_ACTION_UP, 0, 0, metaState, mLastRawState.buttonState, 0,
- mViewport.displayId, /* deviceTimestamp */ 0,
+ /* deviceTimestamp */ 0,
1, &mPointerSimple.lastProperties, &mPointerSimple.lastCoords,
mOrientedXPrecision, mOrientedYPrecision,
mPointerSimple.downTime);
@@ -6349,9 +6343,9 @@
mPointerSimple.hovering = false;
// Send hover exit.
- NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags,
+ NotifyMotionArgs args(when, getDeviceId(), mSource, mViewport.displayId, policyFlags,
AMOTION_EVENT_ACTION_HOVER_EXIT, 0, 0, metaState, mLastRawState.buttonState, 0,
- mViewport.displayId, /* deviceTimestamp */ 0,
+ /* deviceTimestamp */ 0,
1, &mPointerSimple.lastProperties, &mPointerSimple.lastCoords,
mOrientedXPrecision, mOrientedYPrecision,
mPointerSimple.downTime);
@@ -6364,9 +6358,9 @@
mPointerSimple.downTime = when;
// Send down.
- NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags,
+ NotifyMotionArgs args(when, getDeviceId(), mSource, mViewport.displayId, policyFlags,
AMOTION_EVENT_ACTION_DOWN, 0, 0, metaState, mCurrentRawState.buttonState, 0,
- mViewport.displayId, /* deviceTimestamp */ 0,
+ /* deviceTimestamp */ 0,
1, &mPointerSimple.currentProperties, &mPointerSimple.currentCoords,
mOrientedXPrecision, mOrientedYPrecision,
mPointerSimple.downTime);
@@ -6374,9 +6368,9 @@
}
// Send move.
- NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags,
+ NotifyMotionArgs args(when, getDeviceId(), mSource, mViewport.displayId, policyFlags,
AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, mCurrentRawState.buttonState, 0,
- mViewport.displayId, /* deviceTimestamp */ 0,
+ /* deviceTimestamp */ 0,
1, &mPointerSimple.currentProperties, &mPointerSimple.currentCoords,
mOrientedXPrecision, mOrientedYPrecision,
mPointerSimple.downTime);
@@ -6388,10 +6382,10 @@
mPointerSimple.hovering = true;
// Send hover enter.
- NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags,
+ NotifyMotionArgs args(when, getDeviceId(), mSource, mViewport.displayId, policyFlags,
AMOTION_EVENT_ACTION_HOVER_ENTER, 0, 0, metaState,
mCurrentRawState.buttonState, 0,
- mViewport.displayId, /* deviceTimestamp */ 0,
+ /* deviceTimestamp */ 0,
1, &mPointerSimple.currentProperties, &mPointerSimple.currentCoords,
mOrientedXPrecision, mOrientedYPrecision,
mPointerSimple.downTime);
@@ -6399,10 +6393,10 @@
}
// Send hover move.
- NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags,
+ NotifyMotionArgs args(when, getDeviceId(), mSource, mViewport.displayId, policyFlags,
AMOTION_EVENT_ACTION_HOVER_MOVE, 0, 0, metaState,
mCurrentRawState.buttonState, 0,
- mViewport.displayId, /* deviceTimestamp */ 0,
+ /* deviceTimestamp */ 0,
1, &mPointerSimple.currentProperties, &mPointerSimple.currentCoords,
mOrientedXPrecision, mOrientedYPrecision,
mPointerSimple.downTime);
@@ -6421,9 +6415,9 @@
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_VSCROLL, vscroll);
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_HSCROLL, hscroll);
- NotifyMotionArgs args(when, getDeviceId(), mSource, policyFlags,
+ NotifyMotionArgs args(when, getDeviceId(), mSource, mViewport.displayId, policyFlags,
AMOTION_EVENT_ACTION_SCROLL, 0, 0, metaState, mCurrentRawState.buttonState, 0,
- mViewport.displayId, /* deviceTimestamp */ 0,
+ /* deviceTimestamp */ 0,
1, &mPointerSimple.currentProperties, &pointerCoords,
mOrientedXPrecision, mOrientedYPrecision,
mPointerSimple.downTime);
@@ -6484,9 +6478,9 @@
}
}
- NotifyMotionArgs args(when, getDeviceId(), source, policyFlags,
+ NotifyMotionArgs args(when, getDeviceId(), source, mViewport.displayId, policyFlags,
action, actionButton, flags, metaState, buttonState, edgeFlags,
- mViewport.displayId, deviceTimestamp, pointerCount, pointerProperties, pointerCoords,
+ deviceTimestamp, pointerCount, pointerProperties, pointerCoords,
xPrecision, yPrecision, downTime);
getListener()->notifyMotion(&args);
}
@@ -7404,9 +7398,10 @@
// TODO: Use the input device configuration to control this behavior more finely.
uint32_t policyFlags = 0;
- NotifyMotionArgs args(when, getDeviceId(), AINPUT_SOURCE_JOYSTICK, policyFlags,
+ NotifyMotionArgs args(when, getDeviceId(), AINPUT_SOURCE_JOYSTICK, ADISPLAY_ID_NONE,
+ policyFlags,
AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,
- ADISPLAY_ID_NONE, /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords,
+ /* deviceTimestamp */ 0, 1, &pointerProperties, &pointerCoords,
0, 0, 0);
getListener()->notifyMotion(&args);
}
diff --git a/services/inputflinger/tests/InputDispatcher_test.cpp b/services/inputflinger/tests/InputDispatcher_test.cpp
index aa6df24..9c72c77 100644
--- a/services/inputflinger/tests/InputDispatcher_test.cpp
+++ b/services/inputflinger/tests/InputDispatcher_test.cpp
@@ -28,7 +28,7 @@
static const int32_t DEVICE_ID = 1;
// An arbitrary display id.
-static const int32_t DISPLAY_ID = 0;
+static const int32_t DISPLAY_ID = ADISPLAY_ID_DEFAULT;
// An arbitrary injector pid / uid pair that has permission to inject events.
static const int32_t INJECTOR_PID = 999;
@@ -124,7 +124,7 @@
/*action*/ -1, 0,
AKEYCODE_A, KEY_A, AMETA_NONE, 0, ARBITRARY_TIME, ARBITRARY_TIME);
ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(
- &event, DISPLAY_ID,
+ &event,
INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
<< "Should reject key events with undefined action.";
@@ -133,7 +133,7 @@
AKEY_EVENT_ACTION_MULTIPLE, 0,
AKEYCODE_A, KEY_A, AMETA_NONE, 0, ARBITRARY_TIME, ARBITRARY_TIME);
ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(
- &event, DISPLAY_ID,
+ &event,
INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
<< "Should reject key events with ACTION_MULTIPLE.";
}
@@ -149,106 +149,106 @@
}
// Rejects undefined motion actions.
- event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
+ event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID,
/*action*/ -1, 0, 0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
ARBITRARY_TIME, ARBITRARY_TIME,
/*pointerCount*/ 1, pointerProperties, pointerCoords);
ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(
- &event, DISPLAY_ID,
+ &event,
INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
<< "Should reject motion events with undefined action.";
// Rejects pointer down with invalid index.
- event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
+ event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID,
AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
0, 0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
ARBITRARY_TIME, ARBITRARY_TIME,
/*pointerCount*/ 1, pointerProperties, pointerCoords);
ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(
- &event, DISPLAY_ID,
+ &event,
INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
<< "Should reject motion events with pointer down index too large.";
- event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
+ event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID,
AMOTION_EVENT_ACTION_POINTER_DOWN | (~0U << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
0, 0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
ARBITRARY_TIME, ARBITRARY_TIME,
/*pointerCount*/ 1, pointerProperties, pointerCoords);
ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(
- &event, DISPLAY_ID,
+ &event,
INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
<< "Should reject motion events with pointer down index too small.";
// Rejects pointer up with invalid index.
- event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
+ event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID,
AMOTION_EVENT_ACTION_POINTER_UP | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
0, 0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
ARBITRARY_TIME, ARBITRARY_TIME,
/*pointerCount*/ 1, pointerProperties, pointerCoords);
ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(
- &event, DISPLAY_ID,
+ &event,
INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
<< "Should reject motion events with pointer up index too large.";
- event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
+ event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID,
AMOTION_EVENT_ACTION_POINTER_UP | (~0U << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
0, 0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
ARBITRARY_TIME, ARBITRARY_TIME,
/*pointerCount*/ 1, pointerProperties, pointerCoords);
ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(
- &event, DISPLAY_ID,
+ &event,
INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
<< "Should reject motion events with pointer up index too small.";
// Rejects motion events with invalid number of pointers.
- event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
+ event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID,
AMOTION_EVENT_ACTION_DOWN, 0, 0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
ARBITRARY_TIME, ARBITRARY_TIME,
/*pointerCount*/ 0, pointerProperties, pointerCoords);
ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(
- &event, DISPLAY_ID,
+ &event,
INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
<< "Should reject motion events with 0 pointers.";
- event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
+ event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID,
AMOTION_EVENT_ACTION_DOWN, 0, 0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
ARBITRARY_TIME, ARBITRARY_TIME,
/*pointerCount*/ MAX_POINTERS + 1, pointerProperties, pointerCoords);
ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(
- &event, DISPLAY_ID,
+ &event,
INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
<< "Should reject motion events with more than MAX_POINTERS pointers.";
// Rejects motion events with invalid pointer ids.
pointerProperties[0].id = -1;
- event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
+ event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID,
AMOTION_EVENT_ACTION_DOWN, 0, 0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
ARBITRARY_TIME, ARBITRARY_TIME,
/*pointerCount*/ 1, pointerProperties, pointerCoords);
ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(
- &event, DISPLAY_ID,
+ &event,
INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
<< "Should reject motion events with pointer ids less than 0.";
pointerProperties[0].id = MAX_POINTER_ID + 1;
- event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
+ event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID,
AMOTION_EVENT_ACTION_DOWN, 0, 0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
ARBITRARY_TIME, ARBITRARY_TIME,
/*pointerCount*/ 1, pointerProperties, pointerCoords);
ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(
- &event, DISPLAY_ID,
+ &event,
INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
<< "Should reject motion events with pointer ids greater than MAX_POINTER_ID.";
// Rejects motion events with duplicate pointer ids.
pointerProperties[0].id = 1;
pointerProperties[1].id = 1;
- event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
+ event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID,
AMOTION_EVENT_ACTION_DOWN, 0, 0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
ARBITRARY_TIME, ARBITRARY_TIME,
/*pointerCount*/ 2, pointerProperties, pointerCoords);
ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(
- &event, DISPLAY_ID,
+ &event,
INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
<< "Should reject motion events with duplicate pointer ids.";
}
diff --git a/services/sensorservice/OWNERS b/services/sensorservice/OWNERS
index 6a38a1f..d4393d6 100644
--- a/services/sensorservice/OWNERS
+++ b/services/sensorservice/OWNERS
@@ -1,2 +1,2 @@
-ashutoshj@google.com
-pengxu@google.com
+arthuri@google.com
+bduddie@google.com
diff --git a/services/sensorservice/SensorService.cpp b/services/sensorservice/SensorService.cpp
index c32ffb9..2bd0a19 100644
--- a/services/sensorservice/SensorService.cpp
+++ b/services/sensorservice/SensorService.cpp
@@ -24,6 +24,7 @@
#include <cutils/properties.h>
#include <hardware/sensors.h>
#include <hardware_legacy/power.h>
+#include <log/log.h>
#include <openssl/digest.h>
#include <openssl/hmac.h>
#include <openssl/rand.h>
@@ -1093,10 +1094,15 @@
// check specific to memory type
switch(type) {
case SENSOR_DIRECT_MEM_TYPE_ASHMEM: { // channel backed by ashmem
+ if (resource->numFds < 1) {
+ ALOGE("Ashmem direct channel requires a memory region to be supplied");
+ android_errorWriteLog(0x534e4554, "70986337"); // SafetyNet
+ return nullptr;
+ }
int fd = resource->data[0];
int size2 = ashmem_get_size_region(fd);
// check size consistency
- if (size2 < static_cast<int>(size)) {
+ if (size2 < static_cast<int64_t>(size)) {
ALOGE("Ashmem direct channel size %" PRIu32 " greater than shared memory size %d",
size, size2);
return nullptr;
diff --git a/services/surfaceflinger/Android.bp b/services/surfaceflinger/Android.bp
index 3531c4e..cba94d2 100644
--- a/services/surfaceflinger/Android.bp
+++ b/services/surfaceflinger/Android.bp
@@ -24,6 +24,7 @@
"android.hardware.configstore@1.0",
"android.hardware.graphics.allocator@2.0",
"android.hardware.graphics.composer@2.1",
+ "android.hardware.graphics.composer@2.2",
"android.hardware.power@1.0",
"libbase",
"libbinder",
@@ -57,6 +58,7 @@
],
header_libs: [
"android.hardware.graphics.composer@2.1-command-buffer",
+ "android.hardware.graphics.composer@2.2-command-buffer",
],
export_static_lib_headers: [
"libserviceutils",
@@ -64,6 +66,7 @@
export_shared_lib_headers: [
"android.hardware.graphics.allocator@2.0",
"android.hardware.graphics.composer@2.1",
+ "android.hardware.graphics.composer@2.2",
"libhidlbase",
"libhidltransport",
"libhwbinder",
@@ -84,6 +87,7 @@
"BufferLayerConsumer.cpp",
"Client.cpp",
"ColorLayer.cpp",
+ "ContainerLayer.cpp",
"DisplayDevice.cpp",
"DisplayHardware/ComposerHal.cpp",
"DisplayHardware/FramebufferSurface.cpp",
@@ -99,8 +103,10 @@
"FrameTracker.cpp",
"GpuService.cpp",
"Layer.cpp",
+ "LayerBE.cpp",
"LayerProtoHelper.cpp",
"LayerRejecter.cpp",
+ "LayerStats.cpp",
"LayerVector.cpp",
"MessageQueue.cpp",
"MonitoredProducer.cpp",
diff --git a/services/surfaceflinger/BufferLayer.cpp b/services/surfaceflinger/BufferLayer.cpp
index 82f398e..f02c5fa 100644
--- a/services/surfaceflinger/BufferLayer.cpp
+++ b/services/surfaceflinger/BufferLayer.cpp
@@ -98,15 +98,13 @@
}
bool BufferLayer::isProtected() const {
- const sp<GraphicBuffer>& buffer(getBE().compositionInfo.mBuffer);
- return (buffer != 0) &&
- (buffer->getUsage() & GRALLOC_USAGE_PROTECTED);
+ const sp<GraphicBuffer>& buffer(mActiveBuffer);
+ return (buffer != 0) && (buffer->getUsage() & GRALLOC_USAGE_PROTECTED);
}
bool BufferLayer::isVisible() const {
return !(isHiddenByPolicy()) && getAlpha() > 0.0f &&
- (getBE().compositionInfo.mBuffer != nullptr ||
- getBE().compositionInfo.hwc.sidebandStream != nullptr);
+ (mActiveBuffer != nullptr || getBE().compositionInfo.hwc.sidebandStream != nullptr);
}
bool BufferLayer::isFixedSize() const {
@@ -162,7 +160,7 @@
bool useIdentityTransform) const {
ATRACE_CALL();
- if (CC_UNLIKELY(getBE().compositionInfo.mBuffer == 0)) {
+ if (CC_UNLIKELY(mActiveBuffer == 0)) {
// the texture has not been created yet, this Layer has
// in fact never been drawn into. This happens frequently with
// SurfaceView because the WindowManager can't know when the client
@@ -240,8 +238,7 @@
}
// Set things up for texturing.
- mTexture.setDimensions(getBE().compositionInfo.mBuffer->getWidth(),
- getBE().compositionInfo.mBuffer->getHeight());
+ mTexture.setDimensions(mActiveBuffer->getWidth(), mActiveBuffer->getHeight());
mTexture.setFiltering(useFiltering);
mTexture.setMatrix(textureMatrix);
@@ -291,12 +288,10 @@
bool BufferLayer::onPreComposition(nsecs_t refreshStartTime) {
if (mBufferLatched) {
Mutex::Autolock lock(mFrameEventHistoryMutex);
- mFrameEventHistory.addPreComposition(mCurrentFrameNumber,
- refreshStartTime);
+ mFrameEventHistory.addPreComposition(mCurrentFrameNumber, refreshStartTime);
}
mRefreshPending = false;
- return mQueuedFrames > 0 || mSidebandStreamChanged ||
- mAutoRefresh;
+ return mQueuedFrames > 0 || mSidebandStreamChanged || mAutoRefresh;
}
bool BufferLayer::onPostComposition(const std::shared_ptr<FenceTime>& glDoneFence,
const std::shared_ptr<FenceTime>& presentFence,
@@ -308,8 +303,8 @@
// Update mFrameEventHistory.
{
Mutex::Autolock lock(mFrameEventHistoryMutex);
- mFrameEventHistory.addPostComposition(mCurrentFrameNumber, glDoneFence,
- presentFence, compositorTiming);
+ mFrameEventHistory.addPostComposition(mCurrentFrameNumber, glDoneFence, presentFence,
+ compositorTiming);
}
// Update mFrameTracker.
@@ -358,8 +353,7 @@
return;
}
- auto releaseFenceTime =
- std::make_shared<FenceTime>(mConsumer->getPrevFinalReleaseFence());
+ auto releaseFenceTime = std::make_shared<FenceTime>(mConsumer->getPrevFinalReleaseFence());
mReleaseTimeline.updateSignalTimes();
mReleaseTimeline.push(releaseFenceTime);
@@ -412,7 +406,7 @@
// Capture the old state of the layer for comparisons later
const State& s(getDrawingState());
const bool oldOpacity = isOpaque(s);
- sp<GraphicBuffer> oldBuffer = getBE().compositionInfo.mBuffer;
+ sp<GraphicBuffer> oldBuffer = mActiveBuffer;
if (!allTransactionsSignaled()) {
mFlinger->signalLayerUpdate();
@@ -425,12 +419,10 @@
// buffer mode.
bool queuedBuffer = false;
LayerRejecter r(mDrawingState, getCurrentState(), recomputeVisibleRegions,
- getProducerStickyTransform() != 0, mName.string(),
- mOverrideScalingMode, mFreezeGeometryUpdates);
- status_t updateResult =
- mConsumer->updateTexImage(&r, mFlinger->mPrimaryDispSync,
- &mAutoRefresh, &queuedBuffer,
- mLastFrameNumberReceived);
+ getProducerStickyTransform() != 0, mName.string(), mOverrideScalingMode,
+ mFreezeGeometryUpdates);
+ status_t updateResult = mConsumer->updateTexImage(&r, mFlinger->mPrimaryDispSync, &mAutoRefresh,
+ &queuedBuffer, mLastFrameNumberReceived);
if (updateResult == BufferQueue::PRESENT_LATER) {
// Producer doesn't want buffer to be displayed yet. Signal a
// layer update so we check again at the next opportunity.
@@ -483,17 +475,16 @@
// Decrement the queued-frames count. Signal another event if we
// have more frames pending.
- if ((queuedBuffer && android_atomic_dec(&mQueuedFrames) > 1) ||
- mAutoRefresh) {
+ if ((queuedBuffer && android_atomic_dec(&mQueuedFrames) > 1) || mAutoRefresh) {
mFlinger->signalLayerUpdate();
}
// update the active buffer
- getBE().compositionInfo.mBuffer =
- mConsumer->getCurrentBuffer(&getBE().compositionInfo.mBufferSlot);
- // replicated in LayerBE until FE/BE is ready to be synchronized
- mActiveBuffer = getBE().compositionInfo.mBuffer;
- if (getBE().compositionInfo.mBuffer == nullptr) {
+ mActiveBuffer = mConsumer->getCurrentBuffer(&mActiveBufferSlot);
+ getBE().compositionInfo.mBuffer = mActiveBuffer;
+ getBE().compositionInfo.mBufferSlot = mActiveBufferSlot;
+
+ if (mActiveBuffer == nullptr) {
// this can only happen if the very first buffer was rejected.
return outDirtyRegion;
}
@@ -520,8 +511,7 @@
Rect crop(mConsumer->getCurrentCrop());
const uint32_t transform(mConsumer->getCurrentTransform());
const uint32_t scalingMode(mConsumer->getCurrentScalingMode());
- if ((crop != mCurrentCrop) ||
- (transform != mCurrentTransform) ||
+ if ((crop != mCurrentCrop) || (transform != mCurrentTransform) ||
(scalingMode != mCurrentScalingMode)) {
mCurrentCrop = crop;
mCurrentTransform = transform;
@@ -530,15 +520,14 @@
}
if (oldBuffer != nullptr) {
- uint32_t bufWidth = getBE().compositionInfo.mBuffer->getWidth();
- uint32_t bufHeight = getBE().compositionInfo.mBuffer->getHeight();
- if (bufWidth != uint32_t(oldBuffer->width) ||
- bufHeight != uint32_t(oldBuffer->height)) {
+ uint32_t bufWidth = mActiveBuffer->getWidth();
+ uint32_t bufHeight = mActiveBuffer->getHeight();
+ if (bufWidth != uint32_t(oldBuffer->width) || bufHeight != uint32_t(oldBuffer->height)) {
recomputeVisibleRegions = true;
}
}
- mCurrentOpacity = getOpacityForFormat(getBE().compositionInfo.mBuffer->format);
+ mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format);
if (oldOpacity != isOpaque(s)) {
recomputeVisibleRegions = true;
}
@@ -586,14 +575,14 @@
auto hwcId = displayDevice->getHwcDisplayId();
auto& hwcInfo = getBE().mHwcLayers[hwcId];
auto& hwcLayer = hwcInfo.layer;
- auto error = hwcLayer->setVisibleRegion(visible);
+ auto error = (*hwcLayer)->setVisibleRegion(visible);
if (error != HWC2::Error::None) {
ALOGE("[%s] Failed to set visible region: %s (%d)", mName.string(),
to_string(error).c_str(), static_cast<int32_t>(error));
visible.dump(LOG_TAG);
}
- error = hwcLayer->setSurfaceDamage(surfaceDamageRegion);
+ error = (*hwcLayer)->setSurfaceDamage(surfaceDamageRegion);
if (error != HWC2::Error::None) {
ALOGE("[%s] Failed to set surface damage: %s (%d)", mName.string(),
to_string(error).c_str(), static_cast<int32_t>(error));
@@ -604,7 +593,7 @@
if (getBE().compositionInfo.hwc.sidebandStream.get()) {
setCompositionType(hwcId, HWC2::Composition::Sideband);
ALOGV("[%s] Requesting Sideband composition", mName.string());
- error = hwcLayer->setSidebandStream(getBE().compositionInfo.hwc.sidebandStream->handle());
+ error = (*hwcLayer)->setSidebandStream(getBE().compositionInfo.hwc.sidebandStream->handle());
if (error != HWC2::Error::None) {
ALOGE("[%s] Failed to set sideband stream %p: %s (%d)", mName.string(),
getBE().compositionInfo.hwc.sidebandStream->handle(), to_string(error).c_str(),
@@ -623,19 +612,26 @@
}
ALOGV("setPerFrameData: dataspace = %d", mDrawingState.dataSpace);
- error = hwcLayer->setDataspace(mDrawingState.dataSpace);
+ error = (*hwcLayer)->setDataspace(mDrawingState.dataSpace);
if (error != HWC2::Error::None) {
ALOGE("[%s] Failed to set dataspace %d: %s (%d)", mName.string(), mDrawingState.dataSpace,
to_string(error).c_str(), static_cast<int32_t>(error));
}
+ const HdrMetadata& metadata = mConsumer->getCurrentHdrMetadata();
+ error = (*hwcLayer)->setHdrMetadata(metadata);
+ if (error != HWC2::Error::None && error != HWC2::Error::Unsupported) {
+ ALOGE("[%s] Failed to set hdrMetadata: %s (%d)", mName.string(),
+ to_string(error).c_str(), static_cast<int32_t>(error));
+ }
+
uint32_t hwcSlot = 0;
sp<GraphicBuffer> hwcBuffer;
- hwcInfo.bufferCache.getHwcBuffer(getBE().compositionInfo.mBufferSlot,
- getBE().compositionInfo.mBuffer, &hwcSlot, &hwcBuffer);
+ getBE().mHwcLayers[hwcId].bufferCache.getHwcBuffer(mActiveBufferSlot, mActiveBuffer, &hwcSlot,
+ &hwcBuffer);
auto acquireFence = mConsumer->getCurrentFence();
- error = hwcLayer->setBuffer(hwcSlot, hwcBuffer, acquireFence);
+ error = (*hwcLayer)->setBuffer(hwcSlot, hwcBuffer, acquireFence);
if (error != HWC2::Error::None) {
ALOGE("[%s] Failed to set buffer %p: %s (%d)", mName.string(),
getBE().compositionInfo.mBuffer->handle, to_string(error).c_str(),
@@ -646,7 +642,7 @@
bool BufferLayer::isOpaque(const Layer::State& s) const {
// if we don't have a buffer or sidebandStream yet, we're translucent regardless of the
// layer's opaque flag.
- if ((getBE().compositionInfo.hwc.sidebandStream == nullptr) && (getBE().compositionInfo.mBuffer == nullptr)) {
+ if ((getBE().compositionInfo.hwc.sidebandStream == nullptr) && (mActiveBuffer == nullptr)) {
return false;
}
@@ -661,8 +657,7 @@
sp<IGraphicBufferConsumer> consumer;
BufferQueue::createBufferQueue(&producer, &consumer, true);
mProducer = new MonitoredProducer(producer, mFlinger, this);
- mConsumer = new BufferLayerConsumer(consumer,
- mFlinger->getRenderEngine(), mTextureName, this);
+ mConsumer = new BufferLayerConsumer(consumer, mFlinger->getRenderEngine(), mTextureName, this);
mConsumer->setConsumerUsageBits(getEffectiveUsage(0));
mConsumer->setContentsChangedListener(this);
mConsumer->setName(mName);
@@ -694,8 +689,7 @@
// Ensure that callbacks are handled in order
while (item.mFrameNumber != mLastFrameNumberReceived + 1) {
- status_t result = mQueueItemCondition.waitRelative(mQueueItemLock,
- ms2ns(500));
+ status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, ms2ns(500));
if (result != NO_ERROR) {
ALOGE("[%s] Timed out waiting on callback", mName.string());
}
@@ -718,8 +712,7 @@
// Ensure that callbacks are handled in order
while (item.mFrameNumber != mLastFrameNumberReceived + 1) {
- status_t result = mQueueItemCondition.waitRelative(mQueueItemLock,
- ms2ns(500));
+ status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, ms2ns(500));
if (result != NO_ERROR) {
ALOGE("[%s] Timed out waiting on callback", mName.string());
}
@@ -884,8 +877,7 @@
// able to be latched. To avoid this, grab this buffer anyway.
return true;
}
- return mQueueItems[0].mFenceTime->getSignalTime() !=
- Fence::SIGNAL_TIME_PENDING;
+ return mQueueItems[0].mFenceTime->getSignalTime() != Fence::SIGNAL_TIME_PENDING;
}
uint32_t BufferLayer::getEffectiveScalingMode() const {
diff --git a/services/surfaceflinger/ColorLayer.cpp b/services/surfaceflinger/ColorLayer.cpp
index 80a90a7..911b5a1 100644
--- a/services/surfaceflinger/ColorLayer.cpp
+++ b/services/surfaceflinger/ColorLayer.cpp
@@ -68,7 +68,7 @@
auto hwcId = displayDevice->getHwcDisplayId();
auto& hwcInfo = getBE().mHwcLayers[hwcId];
auto& hwcLayer = hwcInfo.layer;
- auto error = hwcLayer->setVisibleRegion(visible);
+ auto error = (*hwcLayer)->setVisibleRegion(visible);
if (error != HWC2::Error::None) {
ALOGE("[%s] Failed to set visible region: %s (%d)", mName.string(),
to_string(error).c_str(), static_cast<int32_t>(error));
@@ -77,14 +77,14 @@
setCompositionType(hwcId, HWC2::Composition::SolidColor);
- error = hwcLayer->setDataspace(mDrawingState.dataSpace);
+ error = (*hwcLayer)->setDataspace(mDrawingState.dataSpace);
if (error != HWC2::Error::None) {
ALOGE("[%s] Failed to set dataspace %d: %s (%d)", mName.string(), mDrawingState.dataSpace,
to_string(error).c_str(), static_cast<int32_t>(error));
}
half4 color = getColor();
- error = hwcLayer->setColor({static_cast<uint8_t>(std::round(255.0f * color.r)),
+ error = (*hwcLayer)->setColor({static_cast<uint8_t>(std::round(255.0f * color.r)),
static_cast<uint8_t>(std::round(255.0f * color.g)),
static_cast<uint8_t>(std::round(255.0f * color.b)), 255});
if (error != HWC2::Error::None) {
@@ -93,7 +93,7 @@
}
// Clear out the transform, because it doesn't make sense absent a source buffer
- error = hwcLayer->setTransform(HWC2::Transform::None);
+ error = (*hwcLayer)->setTransform(HWC2::Transform::None);
if (error != HWC2::Error::None) {
ALOGE("[%s] Failed to clear transform: %s (%d)", mName.string(), to_string(error).c_str(),
static_cast<int32_t>(error));
diff --git a/services/surfaceflinger/ColorLayer.h b/services/surfaceflinger/ColorLayer.h
index 4022b31..0cde398 100644
--- a/services/surfaceflinger/ColorLayer.h
+++ b/services/surfaceflinger/ColorLayer.h
@@ -13,16 +13,13 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+#pragma once
-#ifndef ANDROID_COLOR_LAYER_H
-#define ANDROID_COLOR_LAYER_H
-
-#include <stdint.h>
#include <sys/types.h>
-#include "Layer.h"
+#include <cstdint>
-// ---------------------------------------------------------------------------
+#include "Layer.h"
namespace android {
@@ -36,36 +33,8 @@
virtual void onDraw(const RenderArea& renderArea, const Region& clip,
bool useIdentityTransform) const;
bool isVisible() const override;
- virtual bool isOpaque(const Layer::State&) const { return false; }
- virtual bool isFixedSize() const { return true; }
- void notifyAvailableFrames() override {}
- PixelFormat getPixelFormat() const override { return PIXEL_FORMAT_NONE; }
- uint32_t getEffectiveScalingMode() const override { return 0; }
- void releasePendingBuffer(nsecs_t) override {}
- Region latchBuffer(bool&, nsecs_t) override { return Region(); }
- void useSurfaceDamage() override {}
- void useEmptyDamage() override {}
- bool isBufferLatched() const override { return false; }
- bool onPreComposition(nsecs_t) override { return true; }
- void abandon() override {}
void setPerFrameData(const sp<const DisplayDevice>& displayDevice) override;
- void setDefaultBufferSize(uint32_t /*w*/, uint32_t /*h*/) override {}
- bool shouldPresentNow(const DispSync& /*dispSync*/) const override { return false; }
- bool onPostComposition(const std::shared_ptr<FenceTime>& /*glDoneFence*/,
- const std::shared_ptr<FenceTime>& /*presentFence*/,
- const CompositorTiming& /*compositorTiming*/) override {
- return false;
- }
- void setTransformHint(uint32_t /*orientation*/) const override {}
- std::vector<OccupancyTracker::Segment> getOccupancyHistory(bool /*forceFlush*/) override {
- return {};
- }
- bool getTransformToDisplayInverse() const override { return false; }
};
-// ---------------------------------------------------------------------------
-
-}; // namespace android
-
-#endif // ANDROID_COLOR_LAYER_H
+} // namespace android
diff --git a/services/surfaceflinger/ContainerLayer.cpp b/services/surfaceflinger/ContainerLayer.cpp
new file mode 100644
index 0000000..f259d93
--- /dev/null
+++ b/services/surfaceflinger/ContainerLayer.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// #define LOG_NDEBUG 0
+#undef LOG_TAG
+#define LOG_TAG "ContainerLayer"
+
+#include "ContainerLayer.h"
+
+namespace android {
+
+ContainerLayer::ContainerLayer(SurfaceFlinger* flinger, const sp<Client>& client,
+ const String8& name, uint32_t w, uint32_t h, uint32_t flags)
+ : Layer(flinger, client, name, w, h, flags) {
+ mDrawingState = mCurrentState;
+}
+
+void ContainerLayer::onDraw(const RenderArea&, const Region& /* clip */, bool) const {}
+
+bool ContainerLayer::isVisible() const {
+ return !isHiddenByPolicy();
+}
+
+void ContainerLayer::setPerFrameData(const sp<const DisplayDevice>&) {}
+
+} // namespace android
diff --git a/services/surfaceflinger/ContainerLayer.h b/services/surfaceflinger/ContainerLayer.h
new file mode 100644
index 0000000..543f60a
--- /dev/null
+++ b/services/surfaceflinger/ContainerLayer.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <sys/types.h>
+
+#include <cstdint>
+
+#include "Layer.h"
+
+namespace android {
+
+class ContainerLayer : public Layer {
+public:
+ ContainerLayer(SurfaceFlinger* flinger, const sp<Client>& client, const String8& name,
+ uint32_t w, uint32_t h, uint32_t flags);
+ virtual ~ContainerLayer() = default;
+
+ const char* getTypeId() const override { return "ContainerLayer"; }
+ void onDraw(const RenderArea& renderArea, const Region& clip,
+ bool useIdentityTransform) const override;
+ bool isVisible() const override;
+
+ void setPerFrameData(const sp<const DisplayDevice>& displayDevice) override;
+};
+
+} // namespace android
diff --git a/services/surfaceflinger/DisplayDevice.cpp b/services/surfaceflinger/DisplayDevice.cpp
index d40666e..92d5e21 100644
--- a/services/surfaceflinger/DisplayDevice.cpp
+++ b/services/surfaceflinger/DisplayDevice.cpp
@@ -99,7 +99,7 @@
mNativeWindow = surface = new Surface(producer, false);
ANativeWindow* const window = mNativeWindow.get();
- mActiveColorMode = HAL_COLOR_MODE_NATIVE;
+ mActiveColorMode = ColorMode::NATIVE;
mDisplayHasWideColor = supportWideColor;
mDisplayHasHdr = supportHdr;
@@ -292,11 +292,11 @@
}
// ----------------------------------------------------------------------------
-void DisplayDevice::setActiveColorMode(android_color_mode_t mode) {
+void DisplayDevice::setActiveColorMode(ColorMode mode) {
mActiveColorMode = mode;
}
-android_color_mode_t DisplayDevice::getActiveColorMode() const {
+ColorMode DisplayDevice::getActiveColorMode() const {
return mActiveColorMode;
}
diff --git a/services/surfaceflinger/DisplayDevice.h b/services/surfaceflinger/DisplayDevice.h
index d5ed15f..737971f 100644
--- a/services/surfaceflinger/DisplayDevice.h
+++ b/services/surfaceflinger/DisplayDevice.h
@@ -31,6 +31,7 @@
#include <gui/ISurfaceComposer.h>
#include <hardware/hwcomposer_defs.h>
+#include <ui/GraphicsTypes.h>
#include "RenderArea.h"
#include "RenderEngine/Surface.h"
@@ -155,8 +156,8 @@
void setPowerMode(int mode);
bool isDisplayOn() const;
- android_color_mode_t getActiveColorMode() const;
- void setActiveColorMode(android_color_mode_t mode);
+ ColorMode getActiveColorMode() const;
+ void setActiveColorMode(ColorMode mode);
void setCompositionDataSpace(android_dataspace dataspace);
/* ------------------------------------------------------------------------
@@ -230,7 +231,7 @@
// Current active config
int mActiveConfig;
// current active color mode
- android_color_mode_t mActiveColorMode;
+ ColorMode mActiveColorMode;
// Need to know if display is wide-color capable or not.
// Initialized by SurfaceFlinger when the DisplayDevice is created.
@@ -279,7 +280,7 @@
bool needsFiltering() const override { return mDevice->needsFiltering(); }
Rect getSourceCrop() const override { return mSourceCrop; }
bool getWideColorSupport() const override { return mDevice->getWideColorSupport(); }
- android_color_mode_t getActiveColorMode() const override {
+ ColorMode getActiveColorMode() const override {
return mDevice->getActiveColorMode();
}
diff --git a/services/surfaceflinger/DisplayHardware/ComposerHal.cpp b/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
index 03b714f..0425a8a 100644
--- a/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
+++ b/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
@@ -19,15 +19,23 @@
#include <inttypes.h>
#include <log/log.h>
-#include <gui/BufferQueue.h>
#include "ComposerHal.h"
+#include <android/hardware/graphics/composer/2.2/IComposer.h>
+#include <composer-command-buffer/2.2/ComposerCommandBuffer.h>
+#include <gui/BufferQueue.h>
+#include <hidl/HidlTransportUtils.h>
+
namespace android {
using hardware::Return;
using hardware::hidl_vec;
using hardware::hidl_handle;
+using namespace hardware::graphics::composer;
+using PerFrameMetadata = hardware::graphics::composer::V2_2::IComposerClient::PerFrameMetadata;
+using PerFrameMetadataKey =
+ hardware::graphics::composer::V2_2::IComposerClient::PerFrameMetadataKey;
namespace Hwc2 {
@@ -117,10 +125,9 @@
void Composer::CommandWriter::setLayerInfo(uint32_t type, uint32_t appId)
{
constexpr uint16_t kSetLayerInfoLength = 2;
- beginCommand(
- static_cast<IComposerClient::Command>(
- IVrComposerClient::VrCommand::SET_LAYER_INFO),
- kSetLayerInfoLength);
+ beginCommand(static_cast<hardware::graphics::composer::V2_1::IComposerClient::Command>(
+ IVrComposerClient::VrCommand::SET_LAYER_INFO),
+ kSetLayerInfoLength);
write(type);
write(appId);
endCommand();
@@ -130,10 +137,9 @@
const IVrComposerClient::BufferMetadata& metadata)
{
constexpr uint16_t kSetClientTargetMetadataLength = 7;
- beginCommand(
- static_cast<IComposerClient::Command>(
- IVrComposerClient::VrCommand::SET_CLIENT_TARGET_METADATA),
- kSetClientTargetMetadataLength);
+ beginCommand(static_cast<hardware::graphics::composer::V2_1::IComposerClient::Command>(
+ IVrComposerClient::VrCommand::SET_CLIENT_TARGET_METADATA),
+ kSetClientTargetMetadataLength);
writeBufferMetadata(metadata);
endCommand();
}
@@ -142,10 +148,9 @@
const IVrComposerClient::BufferMetadata& metadata)
{
constexpr uint16_t kSetLayerBufferMetadataLength = 7;
- beginCommand(
- static_cast<IComposerClient::Command>(
- IVrComposerClient::VrCommand::SET_LAYER_BUFFER_METADATA),
- kSetLayerBufferMetadataLength);
+ beginCommand(static_cast<hardware::graphics::composer::V2_1::IComposerClient::Command>(
+ IVrComposerClient::VrCommand::SET_LAYER_BUFFER_METADATA),
+ kSetLayerBufferMetadataLength);
writeBufferMetadata(metadata);
endCommand();
}
@@ -182,6 +187,13 @@
LOG_ALWAYS_FATAL("failed to create composer client");
}
+ // 2.2 support is optional
+ sp<V2_2::IComposer> composer_2_2 = V2_2::IComposer::castFrom(mComposer);
+ if (composer_2_2 != nullptr) {
+ mClient_2_2 = IComposerClient::castFrom(mClient);
+ LOG_ALWAYS_FATAL_IF(mClient_2_2 == nullptr, "IComposer 2.2 did not return IComposerClient 2.2");
+ }
+
if (mIsUsingVrComposer) {
sp<IVrComposerClient> vrClient = IVrComposerClient::castFrom(mClient);
if (vrClient == nullptr) {
@@ -451,6 +463,25 @@
return error;
}
+Error Composer::getPerFrameMetadataKeys(
+ Display display, std::vector<IComposerClient::PerFrameMetadataKey>* outKeys) {
+ if (!mClient_2_2) {
+ return Error::UNSUPPORTED;
+ }
+
+ Error error = kDefaultError;
+ mClient_2_2->getPerFrameMetadataKeys(display, [&](const auto& tmpError, const auto& tmpKeys) {
+ error = tmpError;
+ if (error != Error::NONE) {
+ return;
+ }
+
+ *outKeys = tmpKeys;
+ });
+
+ return error;
+}
+
Error Composer::getReleaseFences(Display display,
std::vector<Layer>* outLayers, std::vector<int>* outReleaseFences)
{
@@ -530,7 +561,15 @@
Error Composer::setPowerMode(Display display, IComposerClient::PowerMode mode)
{
- auto ret = mClient->setPowerMode(display, mode);
+ hardware::Return<Error> ret(Error::UNSUPPORTED);
+ if (mClient_2_2) {
+ ret = mClient_2_2->setPowerMode_2_2(display, mode);
+ } else if (mode != IComposerClient::PowerMode::ON_SUSPEND) {
+ ret = mClient->setPowerMode(display,
+ static_cast<hardware::graphics::composer::V2_1::
+ IComposerClient::PowerMode>(mode));
+ }
+
return unwrapRet(ret);
}
@@ -666,6 +705,47 @@
return Error::NONE;
}
+Error Composer::setLayerHdrMetadata(Display display, Layer layer, const HdrMetadata& metadata) {
+ if (!mClient_2_2) {
+ return Error::UNSUPPORTED;
+ }
+
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+
+ std::vector<PerFrameMetadata> composerMetadata;
+ if (metadata.validTypes & HdrMetadata::SMPTE2086) {
+ composerMetadata
+ .insert(composerMetadata.end(),
+ {{PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X,
+ metadata.smpte2086.displayPrimaryRed.x},
+ {PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y,
+ metadata.smpte2086.displayPrimaryRed.y},
+ {PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X,
+ metadata.smpte2086.displayPrimaryGreen.x},
+ {PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y,
+ metadata.smpte2086.displayPrimaryGreen.y},
+ {PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X,
+ metadata.smpte2086.displayPrimaryBlue.x},
+ {PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y,
+ metadata.smpte2086.displayPrimaryBlue.y},
+ {PerFrameMetadataKey::WHITE_POINT_X, metadata.smpte2086.whitePoint.x},
+ {PerFrameMetadataKey::WHITE_POINT_Y, metadata.smpte2086.whitePoint.y},
+ {PerFrameMetadataKey::MAX_LUMINANCE, metadata.smpte2086.maxLuminance},
+ {PerFrameMetadataKey::MIN_LUMINANCE, metadata.smpte2086.minLuminance}});
+ }
+ if (metadata.validTypes & HdrMetadata::CTA861_3) {
+ composerMetadata.insert(composerMetadata.end(),
+ {{PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL,
+ metadata.cta8613.maxContentLightLevel},
+ {PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL,
+ metadata.cta8613.maxFrameAverageLightLevel}});
+ }
+
+ mWriter.setPerFrameMetadata(composerMetadata);
+ return Error::NONE;
+}
+
Error Composer::setLayerDisplayFrame(Display display, Layer layer,
const IComposerClient::Rect& frame)
{
@@ -810,7 +890,8 @@
mReader.takeErrors();
for (const auto& cmdErr : commandErrors) {
- auto command = mWriter.getCommand(cmdErr.location);
+ auto command =
+ static_cast<IComposerClient::Command>(mWriter.getCommand(cmdErr.location));
if (command == IComposerClient::Command::VALIDATE_DISPLAY ||
command == IComposerClient::Command::PRESENT_DISPLAY ||
@@ -841,7 +922,10 @@
uint16_t length = 0;
while (!isEmpty()) {
- if (!beginCommand(&command, &length)) {
+ auto command_2_1 =
+ reinterpret_cast<hardware::graphics::composer::V2_1::IComposerClient::Command*>(
+ &command);
+ if (!beginCommand(command_2_1, &length)) {
break;
}
diff --git a/services/surfaceflinger/DisplayHardware/ComposerHal.h b/services/surfaceflinger/DisplayHardware/ComposerHal.h
index 77675fb..c0373aa 100644
--- a/services/surfaceflinger/DisplayHardware/ComposerHal.h
+++ b/services/surfaceflinger/DisplayHardware/ComposerHal.h
@@ -24,8 +24,10 @@
#include <vector>
#include <android/frameworks/vr/composer/1.0/IVrComposerClient.h>
-#include <android/hardware/graphics/composer/2.1/IComposer.h>
-#include <composer-command-buffer/2.1/ComposerCommandBuffer.h>
+#include <android/hardware/graphics/composer/2.2/IComposer.h>
+#include <android/hardware/graphics/composer/2.2/IComposerClient.h>
+#include <composer-command-buffer/2.2/ComposerCommandBuffer.h>
+#include <gui/HdrMetadata.h>
#include <ui/GraphicBuffer.h>
#include <utils/StrongPointer.h>
@@ -42,16 +44,16 @@
using android::hardware::graphics::common::V1_0::PixelFormat;
using android::hardware::graphics::common::V1_0::Transform;
+using android::hardware::graphics::composer::V2_1::Config;
+using android::hardware::graphics::composer::V2_1::Display;
+using android::hardware::graphics::composer::V2_1::Error;
using android::hardware::graphics::composer::V2_1::IComposer;
using android::hardware::graphics::composer::V2_1::IComposerCallback;
-using android::hardware::graphics::composer::V2_1::IComposerClient;
-using android::hardware::graphics::composer::V2_1::Error;
-using android::hardware::graphics::composer::V2_1::Display;
using android::hardware::graphics::composer::V2_1::Layer;
-using android::hardware::graphics::composer::V2_1::Config;
+using android::hardware::graphics::composer::V2_2::IComposerClient;
-using android::hardware::graphics::composer::V2_1::CommandWriterBase;
-using android::hardware::graphics::composer::V2_1::CommandReaderBase;
+using android::hardware::graphics::composer::V2_2::CommandReaderBase;
+using android::hardware::graphics::composer::V2_2::CommandWriterBase;
using android::hardware::kSynchronizedReadWrite;
using android::hardware::MessageQueue;
@@ -111,6 +113,9 @@
float* outMaxLuminance, float* outMaxAverageLuminance,
float* outMinLuminance) = 0;
+ virtual Error getPerFrameMetadataKeys(
+ Display display, std::vector<IComposerClient::PerFrameMetadataKey>* outKeys) = 0;
+
virtual Error getReleaseFences(Display display, std::vector<Layer>* outLayers,
std::vector<int>* outReleaseFences) = 0;
@@ -155,6 +160,8 @@
virtual Error setLayerCompositionType(Display display, Layer layer,
IComposerClient::Composition type) = 0;
virtual Error setLayerDataspace(Display display, Layer layer, Dataspace dataspace) = 0;
+ virtual Error setLayerHdrMetadata(Display display, Layer layer,
+ const HdrMetadata& metadata) = 0;
virtual Error setLayerDisplayFrame(Display display, Layer layer,
const IComposerClient::Rect& frame) = 0;
virtual Error setLayerPlaneAlpha(Display display, Layer layer, float alpha) = 0;
@@ -298,6 +305,9 @@
Error getHdrCapabilities(Display display, std::vector<Hdr>* outTypes, float* outMaxLuminance,
float* outMaxAverageLuminance, float* outMinLuminance) override;
+ Error getPerFrameMetadataKeys(
+ Display display, std::vector<IComposerClient::PerFrameMetadataKey>* outKeys) override;
+
Error getReleaseFences(Display display, std::vector<Layer>* outLayers,
std::vector<int>* outReleaseFences) override;
@@ -339,6 +349,7 @@
Error setLayerCompositionType(Display display, Layer layer,
IComposerClient::Composition type) override;
Error setLayerDataspace(Display display, Layer layer, Dataspace dataspace) override;
+ Error setLayerHdrMetadata(Display display, Layer layer, const HdrMetadata& metadata) override;
Error setLayerDisplayFrame(Display display, Layer layer,
const IComposerClient::Rect& frame) override;
Error setLayerPlaneAlpha(Display display, Layer layer, float alpha) override;
@@ -375,7 +386,8 @@
Error execute();
sp<IComposer> mComposer;
- sp<IComposerClient> mClient;
+ sp<hardware::graphics::composer::V2_1::IComposerClient> mClient;
+ sp<IComposerClient> mClient_2_2;
// 64KiB minus a small space for metadata such as read/write pointers
static constexpr size_t kWriterInitialSize =
diff --git a/services/surfaceflinger/DisplayHardware/HWC2.cpp b/services/surfaceflinger/DisplayHardware/HWC2.cpp
index 950c964..381da63 100644
--- a/services/surfaceflinger/DisplayHardware/HWC2.cpp
+++ b/services/surfaceflinger/DisplayHardware/HWC2.cpp
@@ -37,6 +37,7 @@
using android::FloatRect;
using android::GraphicBuffer;
using android::HdrCapabilities;
+using android::HdrMetadata;
using android::Rect;
using android::Region;
using android::sp;
@@ -361,9 +362,9 @@
return Error::None;
}
-Error Display::getColorModes(std::vector<android_color_mode_t>* outModes) const
+Error Display::getColorModes(std::vector<android::ColorMode>* outModes) const
{
- std::vector<Hwc2::ColorMode> modes;
+ std::vector<android::ColorMode> modes;
auto intError = mComposer.getColorModes(mId, &modes);
uint32_t numModes = modes.size();
auto error = static_cast<Error>(intError);
@@ -373,7 +374,7 @@
outModes->resize(numModes);
for (size_t i = 0; i < numModes; i++) {
- (*outModes)[i] = static_cast<android_color_mode_t>(modes[i]);
+ (*outModes)[i] = modes[i];
}
return Error::None;
}
@@ -536,10 +537,9 @@
return static_cast<Error>(intError);
}
-Error Display::setColorMode(android_color_mode_t mode)
+Error Display::setColorMode(android::ColorMode mode)
{
- auto intError = mComposer.setColorMode(
- mId, static_cast<Hwc2::ColorMode>(mode));
+ auto intError = mComposer.setColorMode(mId, mode);
return static_cast<Error>(intError);
}
@@ -687,8 +687,7 @@
// Layer methods
-Layer::Layer(android::Hwc2::Composer& composer,
- const std::unordered_set<Capability>& capabilities,
+Layer::Layer(android::Hwc2::Composer& composer, const std::unordered_set<Capability>& capabilities,
hwc2_display_t displayId, hwc2_layer_t layerId)
: mComposer(composer),
mCapabilities(capabilities),
@@ -788,6 +787,16 @@
return static_cast<Error>(intError);
}
+Error Layer::setHdrMetadata(const android::HdrMetadata& metadata) {
+ if (metadata == mHdrMetadata) {
+ return Error::None;
+ }
+
+ mHdrMetadata = metadata;
+ auto intError = mComposer.setLayerHdrMetadata(mDisplayId, mId, metadata);
+ return static_cast<Error>(intError);
+}
+
Error Layer::setDisplayFrame(const Rect& frame)
{
Hwc2::IComposerClient::Rect hwcRect{frame.left, frame.top,
diff --git a/services/surfaceflinger/DisplayHardware/HWC2.h b/services/surfaceflinger/DisplayHardware/HWC2.h
index 12a7063..5b53b54 100644
--- a/services/surfaceflinger/DisplayHardware/HWC2.h
+++ b/services/surfaceflinger/DisplayHardware/HWC2.h
@@ -23,8 +23,10 @@
#undef HWC2_INCLUDE_STRINGIFICATION
#undef HWC2_USE_CPP11
-#include <ui/HdrCapabilities.h>
+#include <gui/HdrMetadata.h>
#include <math/mat4.h>
+#include <ui/GraphicsTypes.h>
+#include <ui/HdrCapabilities.h>
#include <utils/Log.h>
#include <utils/StrongPointer.h>
@@ -209,7 +211,7 @@
[[clang::warn_unused_result]] Error getChangedCompositionTypes(
std::unordered_map<Layer*, Composition>* outTypes);
[[clang::warn_unused_result]] Error getColorModes(
- std::vector<android_color_mode_t>* outModes) const;
+ std::vector<android::ColorMode>* outModes) const;
// Doesn't call into the HWC2 device, so no errors are possible
std::vector<std::shared_ptr<const Config>> getConfigs() const;
@@ -233,7 +235,7 @@
uint32_t slot, const android::sp<android::GraphicBuffer>& target,
const android::sp<android::Fence>& acquireFence,
android_dataspace_t dataspace);
- [[clang::warn_unused_result]] Error setColorMode(android_color_mode_t mode);
+ [[clang::warn_unused_result]] Error setColorMode(android::ColorMode mode);
[[clang::warn_unused_result]] Error setColorTransform(
const android::mat4& matrix, android_color_transform_t hint);
[[clang::warn_unused_result]] Error setOutputBuffer(
@@ -309,6 +311,7 @@
[[clang::warn_unused_result]] Error setCompositionType(Composition type);
[[clang::warn_unused_result]] Error setDataspace(
android_dataspace_t dataspace);
+ [[clang::warn_unused_result]] Error setHdrMetadata(const android::HdrMetadata& metadata);
[[clang::warn_unused_result]] Error setDisplayFrame(
const android::Rect& frame);
[[clang::warn_unused_result]] Error setPlaneAlpha(float alpha);
@@ -332,6 +335,7 @@
hwc2_display_t mDisplayId;
hwc2_layer_t mId;
android_dataspace mDataSpace = HAL_DATASPACE_UNKNOWN;
+ android::HdrMetadata mHdrMetadata;
std::function<void(Layer*)> mLayerDestroyedListener;
};
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.cpp b/services/surfaceflinger/DisplayHardware/HWComposer.cpp
index 2cafd8e..6d5917d 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer.cpp
+++ b/services/surfaceflinger/DisplayHardware/HWComposer.cpp
@@ -311,8 +311,8 @@
return config;
}
-std::vector<android_color_mode_t> HWComposer::getColorModes(int32_t displayId) const {
- std::vector<android_color_mode_t> modes;
+std::vector<ColorMode> HWComposer::getColorModes(int32_t displayId) const {
+ std::vector<ColorMode> modes;
if (!isValidDisplay(displayId)) {
ALOGE("getColorModes: Attempted to access invalid display %d",
@@ -324,13 +324,13 @@
if (error != HWC2::Error::None) {
ALOGE("getColorModes failed for display %d: %s (%d)", displayId,
to_string(error).c_str(), static_cast<int32_t>(error));
- return std::vector<android_color_mode_t>();
+ return std::vector<ColorMode>();
}
return modes;
}
-status_t HWComposer::setActiveColorMode(int32_t displayId, android_color_mode_t mode) {
+status_t HWComposer::setActiveColorMode(int32_t displayId, ColorMode mode) {
if (!isValidDisplay(displayId)) {
ALOGE("setActiveColorMode: Display %d is not valid", displayId);
return BAD_INDEX;
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.h b/services/surfaceflinger/DisplayHardware/HWComposer.h
index b75dc6a..c442b2f 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer.h
+++ b/services/surfaceflinger/DisplayHardware/HWComposer.h
@@ -23,6 +23,7 @@
#include <sys/types.h>
#include <ui/Fence.h>
+#include <ui/GraphicsTypes.h>
#include <utils/BitSet.h>
#include <utils/Condition.h>
@@ -158,9 +159,9 @@
std::shared_ptr<const HWC2::Display::Config>
getActiveConfig(int32_t displayId) const;
- std::vector<android_color_mode_t> getColorModes(int32_t displayId) const;
+ std::vector<ColorMode> getColorModes(int32_t displayId) const;
- status_t setActiveColorMode(int32_t displayId, android_color_mode_t mode);
+ status_t setActiveColorMode(int32_t displayId, ColorMode mode);
bool isUsingVrComposer() const;
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer_hwc1.h b/services/surfaceflinger/DisplayHardware/HWComposer_hwc1.h
deleted file mode 100644
index fe7944f..0000000
--- a/services/surfaceflinger/DisplayHardware/HWComposer_hwc1.h
+++ /dev/null
@@ -1,400 +0,0 @@
-/*
- * Copyright (C) 2010 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 ANDROID_SF_HWCOMPOSER_HWC1_H
-#define ANDROID_SF_HWCOMPOSER_HWC1_H
-
-#include <stdint.h>
-#include <sys/types.h>
-
-#include <hardware/hwcomposer_defs.h>
-
-#include <system/graphics.h>
-
-#include <ui/Fence.h>
-
-#include <utils/BitSet.h>
-#include <utils/Condition.h>
-#include <utils/Mutex.h>
-#include <utils/StrongPointer.h>
-#include <utils/Thread.h>
-#include <utils/Timers.h>
-#include <utils/Vector.h>
-
-extern "C" int clock_nanosleep(clockid_t clock_id, int flags,
- const struct timespec *request,
- struct timespec *remain);
-
-struct hwc_composer_device_1;
-struct hwc_display_contents_1;
-struct hwc_layer_1;
-struct hwc_procs;
-struct framebuffer_device_t;
-
-namespace android {
-// ---------------------------------------------------------------------------
-
-class Fence;
-class FloatRect;
-class GraphicBuffer;
-class NativeHandle;
-class Region;
-class String8;
-class SurfaceFlinger;
-
-class HWComposer
-{
-public:
- class EventHandler {
- friend class HWComposer;
- virtual void onVSyncReceived(
- HWComposer* composer, int32_t disp, nsecs_t timestamp) = 0;
- virtual void onHotplugReceived(HWComposer* composer, int disp, bool connected) = 0;
- virtual void onInvalidateReceived(HWComposer* composer) = 0;
- protected:
- virtual ~EventHandler() {}
- };
-
- enum {
- NUM_BUILTIN_DISPLAYS = HWC_NUM_PHYSICAL_DISPLAY_TYPES,
- MAX_HWC_DISPLAYS = HWC_NUM_DISPLAY_TYPES,
- VIRTUAL_DISPLAY_ID_BASE = HWC_DISPLAY_VIRTUAL,
- };
-
- HWComposer(
- const sp<SurfaceFlinger>& flinger,
- EventHandler& handler);
-
- ~HWComposer();
-
- status_t initCheck() const;
-
- // Returns a display ID starting at VIRTUAL_DISPLAY_ID_BASE, this ID is to
- // be used with createWorkList (and all other methods requiring an ID
- // below).
- // IDs below NUM_BUILTIN_DISPLAYS are pre-defined and therefore are
- // always valid.
- // Returns -1 if an ID cannot be allocated
- int32_t allocateDisplayId();
-
- // Recycles the given virtual display ID and frees the associated worklist.
- // IDs below NUM_BUILTIN_DISPLAYS are not recycled.
- status_t freeDisplayId(int32_t id);
-
-
- // Asks the HAL what it can do
- status_t prepare();
-
- // commits the list
- status_t commit();
-
- // set power mode
- status_t setPowerMode(int disp, int mode);
-
- // set active config
- status_t setActiveConfig(int disp, int mode);
-
- // reset state when an external, non-virtual display is disconnected
- void disconnectDisplay(int disp);
-
- // create a work list for numLayers layer. sets HWC_GEOMETRY_CHANGED.
- status_t createWorkList(int32_t id, size_t numLayers);
-
- bool supportsFramebufferTarget() const;
-
- // does this display have layers handled by HWC
- bool hasHwcComposition(int32_t id) const;
-
- // does this display have layers handled by GLES
- bool hasGlesComposition(int32_t id) const;
-
- // get the releaseFence file descriptor for a display's framebuffer layer.
- // the release fence is only valid after commit()
- sp<Fence> getAndResetReleaseFence(int32_t id);
-
- // needed forward declarations
- class LayerListIterator;
-
- // return the visual id to be used to find a suitable EGLConfig for
- // *ALL* displays.
- int getVisualID() const;
-
- // Forwarding to FB HAL for pre-HWC-1.1 code (see FramebufferSurface).
- int fbPost(int32_t id, const sp<Fence>& acquireFence, const sp<GraphicBuffer>& buf);
- int fbCompositionComplete();
- void fbDump(String8& result);
-
- // Set the output buffer and acquire fence for a virtual display.
- // Returns INVALID_OPERATION if id is not a virtual display.
- status_t setOutputBuffer(int32_t id, const sp<Fence>& acquireFence,
- const sp<GraphicBuffer>& buf);
-
- // Get the retire fence for the last committed frame. This fence will
- // signal when the h/w composer is completely finished with the frame.
- // For physical displays, it is no longer being displayed. For virtual
- // displays, writes to the output buffer are complete.
- sp<Fence> getLastRetireFence(int32_t id) const;
-
- status_t setCursorPositionAsync(int32_t id, const Rect &pos);
-
- /*
- * Interface to hardware composer's layers functionality.
- * This abstracts the HAL interface to layers which can evolve in
- * incompatible ways from one release to another.
- * The idea is that we could extend this interface as we add
- * features to h/w composer.
- */
- class HWCLayerInterface {
- protected:
- virtual ~HWCLayerInterface() { }
- public:
- virtual int32_t getCompositionType() const = 0;
- virtual uint32_t getHints() const = 0;
- virtual sp<Fence> getAndResetReleaseFence() = 0;
- virtual void setDefaultState() = 0;
- virtual void setSkip(bool skip) = 0;
- virtual void setIsCursorLayerHint(bool isCursor = true) = 0;
- virtual void setBlending(uint32_t blending) = 0;
- virtual void setTransform(uint32_t transform) = 0;
- virtual void setFrame(const Rect& frame) = 0;
- virtual void setCrop(const FloatRect& crop) = 0;
- virtual void setVisibleRegionScreen(const Region& reg) = 0;
- virtual void setSurfaceDamage(const Region& reg) = 0;
- virtual void setSidebandStream(const sp<NativeHandle>& stream) = 0;
- virtual void setBuffer(const sp<GraphicBuffer>& buffer) = 0;
- virtual void setAcquireFenceFd(int fenceFd) = 0;
- virtual void setPlaneAlpha(uint8_t alpha) = 0;
- virtual void onDisplayed() = 0;
- };
-
- /*
- * Interface used to implement an iterator to a list
- * of HWCLayer.
- */
- class HWCLayer : public HWCLayerInterface {
- friend class LayerListIterator;
- // select the layer at the given index
- virtual status_t setLayer(size_t index) = 0;
- virtual HWCLayer* dup() = 0;
- static HWCLayer* copy(HWCLayer *rhs) {
- return rhs ? rhs->dup() : nullptr;
- }
- protected:
- virtual ~HWCLayer() { }
- };
-
- /*
- * Iterator through a HWCLayer list.
- * This behaves more or less like a forward iterator.
- */
- class LayerListIterator {
- friend class HWComposer;
- HWCLayer* const mLayerList;
- size_t mIndex;
-
- LayerListIterator() : mLayerList(nullptr), mIndex(0) { }
-
- LayerListIterator(HWCLayer* layer, size_t index)
- : mLayerList(layer), mIndex(index) { }
-
- // we don't allow assignment, because we don't need it for now
- LayerListIterator& operator = (const LayerListIterator& rhs);
-
- public:
- // copy operators
- LayerListIterator(const LayerListIterator& rhs)
- : mLayerList(HWCLayer::copy(rhs.mLayerList)), mIndex(rhs.mIndex) {
- }
-
- ~LayerListIterator() { delete mLayerList; }
-
- // pre-increment
- LayerListIterator& operator++() {
- mLayerList->setLayer(++mIndex);
- return *this;
- }
-
- // dereference
- HWCLayerInterface& operator * () { return *mLayerList; }
- HWCLayerInterface* operator -> () { return mLayerList; }
-
- // comparison
- bool operator == (const LayerListIterator& rhs) const {
- return mIndex == rhs.mIndex;
- }
- bool operator != (const LayerListIterator& rhs) const {
- return !operator==(rhs);
- }
- };
-
- // Returns an iterator to the beginning of the layer list
- LayerListIterator begin(int32_t id);
-
- // Returns an iterator to the end of the layer list
- LayerListIterator end(int32_t id);
-
-
- // Events handling ---------------------------------------------------------
-
- enum {
- EVENT_VSYNC = HWC_EVENT_VSYNC
- };
-
- void eventControl(int disp, int event, int enabled);
-
- struct DisplayConfig {
- uint32_t width;
- uint32_t height;
- float xdpi;
- float ydpi;
- nsecs_t refresh;
- android_color_mode_t colorMode;
- bool operator==(const DisplayConfig& rhs) const {
- return width == rhs.width &&
- height == rhs.height &&
- xdpi == rhs.xdpi &&
- ydpi == rhs.ydpi &&
- refresh == rhs.refresh &&
- colorMode == rhs.colorMode;
- }
- };
-
- // Query display parameters. Pass in a display index (e.g.
- // HWC_DISPLAY_PRIMARY).
- nsecs_t getRefreshTimestamp(int disp) const;
- sp<Fence> getDisplayFence(int disp) const;
- uint32_t getFormat(int disp) const;
- bool isConnected(int disp) const;
-
- // These return the values for the current config of a given display index.
- // To get the values for all configs, use getConfigs below.
- uint32_t getWidth(int disp) const;
- uint32_t getHeight(int disp) const;
- float getDpiX(int disp) const;
- float getDpiY(int disp) const;
- nsecs_t getRefreshPeriod(int disp) const;
- android_color_mode_t getColorMode(int disp) const;
-
- const Vector<DisplayConfig>& getConfigs(int disp) const;
- size_t getCurrentConfig(int disp) const;
-
- status_t setVirtualDisplayProperties(int32_t id, uint32_t w, uint32_t h,
- uint32_t format);
-
- // this class is only used to fake the VSync event on systems that don't
- // have it.
- class VSyncThread : public Thread {
- HWComposer& mHwc;
- mutable Mutex mLock;
- Condition mCondition;
- bool mEnabled;
- mutable nsecs_t mNextFakeVSync;
- nsecs_t mRefreshPeriod;
- virtual void onFirstRef();
- virtual bool threadLoop();
- public:
- VSyncThread(HWComposer& hwc);
- void setEnabled(bool enabled);
- };
-
- friend class VSyncThread;
-
- // for debugging ----------------------------------------------------------
- void dump(String8& out) const;
-
-private:
- void loadHwcModule();
- int loadFbHalModule();
-
- LayerListIterator getLayerIterator(int32_t id, size_t index);
-
- struct cb_context;
-
- static void hook_invalidate(const struct hwc_procs* procs);
- static void hook_vsync(const struct hwc_procs* procs, int disp,
- int64_t timestamp);
- static void hook_hotplug(const struct hwc_procs* procs, int disp,
- int connected);
-
- inline void invalidate();
- inline void vsync(int disp, int64_t timestamp);
- inline void hotplug(int disp, int connected);
-
- status_t queryDisplayProperties(int disp);
-
- status_t setFramebufferTarget(int32_t id,
- const sp<Fence>& acquireFence, const sp<GraphicBuffer>& buf);
-
- struct DisplayData {
- DisplayData();
- ~DisplayData();
- Vector<DisplayConfig> configs;
- size_t currentConfig;
- uint32_t format; // pixel format from FB hal, for pre-hwc-1.1
- bool connected;
- bool hasFbComp;
- bool hasOvComp;
- size_t capacity;
- hwc_display_contents_1* list;
- hwc_layer_1* framebufferTarget;
- buffer_handle_t fbTargetHandle;
- sp<Fence> lastRetireFence; // signals when the last set op retires
- sp<Fence> lastDisplayFence; // signals when the last set op takes
- // effect on screen
- buffer_handle_t outbufHandle;
- sp<Fence> outbufAcquireFence;
-
- // protected by mEventControlLock
- int32_t events;
-
- // We need to hold "copies" of these for memory management purposes. The
- // actual hwc_layer_1_t holds pointers to the memory within. Vector<>
- // internally doesn't copy the memory unless one of the copies is
- // modified.
- Vector<Region> visibleRegions;
- Vector<Region> surfaceDamageRegions;
- };
-
- sp<SurfaceFlinger> mFlinger;
- framebuffer_device_t* mFbDev;
- struct hwc_composer_device_1* mHwc;
- // invariant: mLists[0] != nullptr iff mHwc != nullptr
- // mLists[i>0] can be nullptr. that display is to be ignored
- struct hwc_display_contents_1* mLists[MAX_HWC_DISPLAYS];
- DisplayData mDisplayData[MAX_HWC_DISPLAYS];
- // protect mDisplayData from races between prepare and dump
- mutable Mutex mDisplayLock;
- size_t mNumDisplays;
-
- cb_context* mCBContext;
- EventHandler& mEventHandler;
- size_t mVSyncCounts[HWC_NUM_PHYSICAL_DISPLAY_TYPES];
- sp<VSyncThread> mVSyncThread;
- bool mDebugForceFakeVSync;
- BitSet32 mAllocatedDisplayIDs;
-
- // protected by mLock
- mutable Mutex mLock;
- mutable nsecs_t mLastHwVSync[HWC_NUM_PHYSICAL_DISPLAY_TYPES];
-
- // thread-safe
- mutable Mutex mEventControlLock;
-};
-
-// ---------------------------------------------------------------------------
-}; // namespace android
-
-#endif // ANDROID_SF_HWCOMPOSER_H
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index 78dd40b..ba2d0a0 100644
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -61,11 +61,6 @@
namespace android {
-LayerBE::LayerBE()
- : mMesh(Mesh::TRIANGLE_FAN, 4, 2, 2) {
-}
-
-
int32_t Layer::sSequence = 1;
Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client, const String8& name, uint32_t w,
@@ -96,7 +91,8 @@
mQueueItems(),
mLastFrameNumberReceived(0),
mAutoRefresh(false),
- mFreezeGeometryUpdates(false) {
+ mFreezeGeometryUpdates(false),
+ mBE{this, name.string()} {
mCurrentCrop.makeInvalid();
@@ -221,15 +217,14 @@
bool Layer::createHwcLayer(HWComposer* hwc, int32_t hwcId) {
LOG_ALWAYS_FATAL_IF(getBE().mHwcLayers.count(hwcId) != 0,
"Already have a layer for hwcId %d", hwcId);
- HWC2::Layer* layer = hwc->createLayer(hwcId);
+
+ std::shared_ptr<LayerContainer> layer(new LayerContainer(hwc, hwcId));
if (!layer) {
return false;
}
LayerBE::HWCInfo& hwcInfo = getBE().mHwcLayers[hwcId];
hwcInfo.hwc = hwc;
hwcInfo.layer = layer;
- layer->setLayerDestroyedListener(
- [this, hwcId](HWC2::Layer* /*layer*/) { getBE().mHwcLayers.erase(hwcId); });
return true;
}
@@ -240,11 +235,12 @@
auto& hwcInfo = getBE().mHwcLayers[hwcId];
LOG_ALWAYS_FATAL_IF(hwcInfo.layer == nullptr, "Attempt to destroy null layer");
LOG_ALWAYS_FATAL_IF(hwcInfo.hwc == nullptr, "Missing HWComposer");
- hwcInfo.hwc->destroyLayer(hwcId, hwcInfo.layer);
- // The layer destroyed listener should have cleared the entry from
- // mHwcLayers. Verify that.
- LOG_ALWAYS_FATAL_IF(getBE().mHwcLayers.count(hwcId) != 0,
- "Stale layer entry in getBE().mHwcLayers");
+ hwcInfo.layer = nullptr;
+
+ if (getBE().mHwcLayers.count(hwcId) == 1) {
+ getBE().mHwcLayers.erase(hwcId);
+ }
+
return true;
}
@@ -503,7 +499,7 @@
blendMode =
mPremultipliedAlpha ? HWC2::BlendMode::Premultiplied : HWC2::BlendMode::Coverage;
}
- auto error = hwcLayer->setBlendMode(blendMode);
+ auto error = (*hwcLayer)->setBlendMode(blendMode);
ALOGE_IF(error != HWC2::Error::None,
"[%s] Failed to set blend mode %s:"
" %s (%d)",
@@ -551,7 +547,7 @@
}
const Transform& tr(displayDevice->getTransform());
Rect transformedFrame = tr.transform(frame);
- error = hwcLayer->setDisplayFrame(transformedFrame);
+ error = (*hwcLayer)->setDisplayFrame(transformedFrame);
if (error != HWC2::Error::None) {
ALOGE("[%s] Failed to set display frame [%d, %d, %d, %d]: %s (%d)", mName.string(),
transformedFrame.left, transformedFrame.top, transformedFrame.right,
@@ -561,7 +557,7 @@
}
FloatRect sourceCrop = computeCrop(displayDevice);
- error = hwcLayer->setSourceCrop(sourceCrop);
+ error = (*hwcLayer)->setSourceCrop(sourceCrop);
if (error != HWC2::Error::None) {
ALOGE("[%s] Failed to set source crop [%.3f, %.3f, %.3f, %.3f]: "
"%s (%d)",
@@ -572,13 +568,13 @@
}
float alpha = static_cast<float>(getAlpha());
- error = hwcLayer->setPlaneAlpha(alpha);
+ error = (*hwcLayer)->setPlaneAlpha(alpha);
ALOGE_IF(error != HWC2::Error::None,
"[%s] Failed to set plane alpha %.3f: "
"%s (%d)",
mName.string(), alpha, to_string(error).c_str(), static_cast<int32_t>(error));
- error = hwcLayer->setZOrder(z);
+ error = (*hwcLayer)->setZOrder(z);
ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set Z %u: %s (%d)", mName.string(), z,
to_string(error).c_str(), static_cast<int32_t>(error));
@@ -591,7 +587,7 @@
appId = parentState.appId;
}
- error = hwcLayer->setInfo(type, appId);
+ error = (*hwcLayer)->setInfo(type, appId);
ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set info (%d)", mName.string(),
static_cast<int32_t>(error));
@@ -639,7 +635,8 @@
hwcInfo.forceClientComposition = true;
} else {
auto transform = static_cast<HWC2::Transform>(orientation);
- auto error = hwcLayer->setTransform(transform);
+ hwcInfo.transform = transform;
+ auto error = (*hwcLayer)->setTransform(transform);
ALOGE_IF(error != HWC2::Error::None,
"[%s] Failed to set transform %s: "
"%s (%d)",
@@ -692,7 +689,7 @@
auto& displayTransform(displayDevice->getTransform());
auto position = displayTransform.transform(frame);
- auto error = getBE().mHwcLayers[hwcId].layer->setCursorPosition(position.left,
+ auto error = (*getBE().mHwcLayers[hwcId].layer)->setCursorPosition(position.left,
position.top);
ALOGE_IF(error != HWC2::Error::None,
"[%s] Failed to set cursor position "
@@ -736,13 +733,13 @@
}
auto& hwcInfo = getBE().mHwcLayers[hwcId];
auto& hwcLayer = hwcInfo.layer;
- ALOGV("setCompositionType(%" PRIx64 ", %s, %d)", hwcLayer->getId(), to_string(type).c_str(),
+ ALOGV("setCompositionType(%" PRIx64 ", %s, %d)", (*hwcLayer)->getId(), to_string(type).c_str(),
static_cast<int>(callIntoHwc));
if (hwcInfo.compositionType != type) {
ALOGV(" actually setting");
hwcInfo.compositionType = type;
if (callIntoHwc) {
- auto error = hwcLayer->setCompositionType(type);
+ auto error = (*hwcLayer)->setCompositionType(type);
ALOGE_IF(error != HWC2::Error::None,
"[%s] Failed to set "
"composition type %s: %s (%d)",
@@ -1440,7 +1437,7 @@
info.mMatrix[1][0] = ds.active.transform[1][0];
info.mMatrix[1][1] = ds.active.transform[1][1];
{
- sp<const GraphicBuffer> buffer = getBE().compositionInfo.mBuffer;
+ sp<const GraphicBuffer> buffer = mActiveBuffer;
if (buffer != 0) {
info.mActiveBufferWidth = buffer->getWidth();
info.mActiveBufferHeight = buffer->getHeight();
@@ -1594,6 +1591,12 @@
return true;
}
+void Layer::reparentChildrenForDrawing(const sp<Layer>& newParent) {
+ for (const sp<Layer>& child : mDrawingChildren) {
+ child->mDrawingParent = newParent;
+ }
+}
+
bool Layer::reparent(const sp<IBinder>& newParentHandle) {
if (newParentHandle == nullptr) {
return false;
@@ -1915,6 +1918,21 @@
layerInfo->set_refresh_pending(isBufferLatched());
}
+void Layer::writeToProto(LayerProto* layerInfo, int32_t hwcId) {
+ writeToProto(layerInfo, LayerVector::StateSet::Drawing);
+
+ const auto& hwcInfo = getBE().mHwcLayers.at(hwcId);
+
+ const Rect& frame = hwcInfo.displayFrame;
+ LayerProtoHelper::writeToProto(frame, layerInfo->mutable_hwc_frame());
+
+ const FloatRect& crop = hwcInfo.sourceCrop;
+ LayerProtoHelper::writeToProto(crop, layerInfo->mutable_hwc_crop());
+
+ const int32_t transform = static_cast<int32_t>(hwcInfo.transform);
+ layerInfo->set_hwc_transform(transform);
+}
+
// ---------------------------------------------------------------------------
}; // namespace android
diff --git a/services/surfaceflinger/Layer.h b/services/surfaceflinger/Layer.h
index 84fb827..c5715a2 100644
--- a/services/surfaceflinger/Layer.h
+++ b/services/surfaceflinger/Layer.h
@@ -17,7 +17,6 @@
#ifndef ANDROID_LAYER_H
#define ANDROID_LAYER_H
-#include <stdint.h>
#include <sys/types.h>
#include <utils/RefBase.h>
@@ -35,6 +34,7 @@
#include <gui/BufferQueue.h>
#include <list>
+#include <cstdint>
#include "Client.h"
#include "FrameTracker.h"
@@ -42,6 +42,7 @@
#include "MonitoredProducer.h"
#include "SurfaceFlinger.h"
#include "Transform.h"
+#include "LayerBE.h"
#include <layerproto/LayerProtoHeader.h>
#include "DisplayHardware/HWComposer.h"
@@ -72,68 +73,6 @@
// ---------------------------------------------------------------------------
-struct CompositionInfo {
- HWC2::Composition compositionType;
- sp<GraphicBuffer> mBuffer = nullptr;
- int mBufferSlot = BufferQueue::INVALID_BUFFER_SLOT;
- struct {
- HWComposer* hwc;
- sp<Fence> fence;
- HWC2::BlendMode blendMode;
- Rect displayFrame;
- float alpha;
- FloatRect sourceCrop;
- HWC2::Transform transform;
- int z;
- int type;
- int appId;
- Region visibleRegion;
- Region surfaceDamage;
- sp<NativeHandle> sidebandStream;
- android_dataspace dataspace;
- hwc_color_t color;
- } hwc;
- struct {
- RE::RenderEngine* renderEngine;
- Mesh* mesh;
- } renderEngine;
-};
-
-class LayerBE {
-public:
- LayerBE();
-
- // The mesh used to draw the layer in GLES composition mode
- Mesh mMesh;
-
- // HWC items, accessed from the main thread
- struct HWCInfo {
- HWCInfo()
- : hwc(nullptr),
- layer(nullptr),
- forceClientComposition(false),
- compositionType(HWC2::Composition::Invalid),
- clearClientTarget(false) {}
-
- HWComposer* hwc;
- HWC2::Layer* layer;
- bool forceClientComposition;
- HWC2::Composition compositionType;
- bool clearClientTarget;
- Rect displayFrame;
- FloatRect sourceCrop;
- HWComposerBufferCache bufferCache;
- };
-
- // A layer can be attached to multiple displays when operating in mirror mode
- // (a.k.a: when several displays are attached with equal layerStack). In this
- // case we need to keep track. In non-mirror mode, a layer will have only one
- // HWCInfo. This map key is a display layerStack.
- std::unordered_map<int32_t, HWCInfo> mHwcLayers;
-
- CompositionInfo compositionInfo;
-};
-
class Layer : public virtual RefBase {
static int32_t sSequence;
@@ -291,14 +230,15 @@
bool setOverrideScalingMode(int32_t overrideScalingMode);
void setInfo(uint32_t type, uint32_t appId);
bool reparentChildren(const sp<IBinder>& layer);
+ void reparentChildrenForDrawing(const sp<Layer>& layer);
bool reparent(const sp<IBinder>& newParentHandle);
bool detachChildren();
// If we have received a new buffer this frame, we will pass its surface
// damage down to hardware composer. Otherwise, we must send a region with
// one empty rect.
- virtual void useSurfaceDamage() = 0;
- virtual void useEmptyDamage() = 0;
+ virtual void useSurfaceDamage() {}
+ virtual void useEmptyDamage() {}
uint32_t getTransactionFlags(uint32_t flags);
uint32_t setTransactionFlags(uint32_t flags);
@@ -324,7 +264,7 @@
* pixel format includes an alpha channel) and the "opaque" flag set
* on the layer. It does not examine the current plane alpha value.
*/
- virtual bool isOpaque(const Layer::State& s) const = 0;
+ virtual bool isOpaque(const Layer::State&) const { return false; }
/*
* isSecure - true if this surface is secure, that is if it prevents
@@ -348,13 +288,16 @@
/*
* isFixedSize - true if content has a fixed size
*/
- virtual bool isFixedSize() const = 0;
+ virtual bool isFixedSize() const { return true; }
+
bool isPendingRemoval() const { return mPendingRemoval; }
void writeToProto(LayerProto* layerInfo,
LayerVector::StateSet stateSet = LayerVector::StateSet::Drawing);
+ void writeToProto(LayerProto* layerInfo, int32_t hwcId);
+
protected:
/*
* onDraw - draws the surface.
@@ -363,7 +306,7 @@
bool useIdentityTransform) const = 0;
public:
- virtual void setDefaultBufferSize(uint32_t w, uint32_t h) = 0;
+ virtual void setDefaultBufferSize(uint32_t /*w*/, uint32_t /*h*/) {}
void setGeometry(const sp<const DisplayDevice>& displayDevice, uint32_t z);
void forceClientComposition(int32_t hwcId);
@@ -383,27 +326,30 @@
*/
virtual void onLayerDisplayed(const sp<Fence>& releaseFence);
- virtual void abandon() = 0;
+ virtual void abandon() {}
- virtual bool shouldPresentNow(const DispSync& dispSync) const = 0;
- virtual void setTransformHint(uint32_t orientation) const = 0;
+ virtual bool shouldPresentNow(const DispSync& /*dispSync*/) const { return false; }
+ virtual void setTransformHint(uint32_t /*orientation*/) const { }
/*
* called before composition.
* returns true if the layer has pending updates.
*/
- virtual bool onPreComposition(nsecs_t refreshStartTime) = 0;
+ virtual bool onPreComposition(nsecs_t /*refreshStartTime*/) { return true; }
/*
* called after composition.
* returns true if the layer latched a new buffer this frame.
*/
- virtual bool onPostComposition(const std::shared_ptr<FenceTime>& glDoneFence,
- const std::shared_ptr<FenceTime>& presentFence,
- const CompositorTiming& compositorTiming) = 0;
+ virtual bool onPostComposition(const std::shared_ptr<FenceTime>& /*glDoneFence*/,
+ const std::shared_ptr<FenceTime>& /*presentFence*/,
+ const CompositorTiming& /*compositorTiming*/) {
+ return false;
+ }
// If a buffer was replaced this frame, release the former buffer
- virtual void releasePendingBuffer(nsecs_t dequeueReadyTime) = 0;
+ virtual void releasePendingBuffer(nsecs_t /*dequeueReadyTime*/) { }
+
/*
* draw - performs some global clipping optimizations
@@ -449,8 +395,11 @@
* operation, so this should be set only if needed). Typically this is used
* to figure out if the content or size of a surface has changed.
*/
- virtual Region latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime) = 0;
- virtual bool isBufferLatched() const = 0;
+ virtual Region latchBuffer(bool& /*recomputeVisibleRegions*/, nsecs_t /*latchTime*/) {
+ return {};
+ }
+
+ virtual bool isBufferLatched() const { return false; }
bool isPotentialCursor() const { return mPotentialCursor; }
/*
@@ -498,7 +447,15 @@
if (getBE().mHwcLayers.count(hwcId) == 0) {
return nullptr;
}
- return getBE().mHwcLayers[hwcId].layer;
+ return *(getBE().mHwcLayers[hwcId].layer.get());
+ }
+
+ bool setHwcLayer(int32_t hwcId) {
+ if (getBE().mHwcLayers.count(hwcId) == 0) {
+ return false;
+ }
+ getBE().compositionInfo.hwc.hwcLayer = getBE().mHwcLayers[hwcId].layer;
+ return true;
}
// -----------------------------------------------------------------------
@@ -523,13 +480,15 @@
void logFrameStats();
void getFrameStats(FrameStats* outStats) const;
- virtual std::vector<OccupancyTracker::Segment> getOccupancyHistory(bool forceFlush) = 0;
+ virtual std::vector<OccupancyTracker::Segment> getOccupancyHistory(bool /*forceFlush*/) {
+ return {};
+ }
void onDisconnect();
void addAndGetFrameTimestamps(const NewFrameEventsEntry* newEntry,
FrameEventHistoryDelta* outDelta);
- virtual bool getTransformToDisplayInverse() const = 0;
+ virtual bool getTransformToDisplayInverse() const { return false; }
Transform getTransform() const;
@@ -653,7 +612,7 @@
// Returns mCurrentScaling mode (originating from the
// Client) or mOverrideScalingMode mode (originating from
// the Surface Controller) if set.
- virtual uint32_t getEffectiveScalingMode() const = 0;
+ virtual uint32_t getEffectiveScalingMode() const { return 0; }
public:
/*
@@ -674,8 +633,8 @@
sp<IBinder> getHandle();
const String8& getName() const;
- virtual void notifyAvailableFrames() = 0;
- virtual PixelFormat getPixelFormat() const = 0;
+ virtual void notifyAvailableFrames() {}
+ virtual PixelFormat getPixelFormat() const { return PIXEL_FORMAT_NONE; }
bool getPremultipledAlpha() const;
protected:
diff --git a/services/surfaceflinger/LayerBE.cpp b/services/surfaceflinger/LayerBE.cpp
new file mode 100644
index 0000000..5287fe1
--- /dev/null
+++ b/services/surfaceflinger/LayerBE.cpp
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_NDEBUG 0
+#undef LOG_TAG
+#define LOG_TAG "LayerBE"
+#define ATRACE_TAG ATRACE_TAG_GRAPHICS
+
+#include "Layer.h"
+
+namespace android {
+
+LayerBE::LayerBE(Layer* layer, std::string layerName)
+ : mLayer(layer),
+ mMesh(Mesh::TRIANGLE_FAN, 4, 2, 2) {
+ compositionInfo.layer = this;
+ compositionInfo.layerName = layerName;
+}
+
+void LayerBE::onLayerDisplayed(const sp<Fence>& releaseFence) {
+ mLayer->onLayerDisplayed(releaseFence);
+}
+
+void CompositionInfo::dumpHwc(const char* tag) const {
+ ALOGV("[%s]\thwcLayer=%p", tag, static_cast<HWC2::Layer*>(*hwc.hwcLayer));
+ ALOGV("[%s]\tfence=%p", tag, hwc.fence.get());
+ ALOGV("[%s]\ttransform=%d", tag, hwc.transform);
+ ALOGV("[%s]\tz=%d", tag, hwc.z);
+ ALOGV("[%s]\ttype=%d", tag, hwc.type);
+ ALOGV("[%s]\tappId=%d", tag, hwc.appId);
+ ALOGV("[%s]\tdisplayFrame=%4d %4d %4d %4d", tag, hwc.displayFrame.left, hwc.displayFrame.top, hwc.displayFrame.right, hwc.displayFrame.bottom);
+ ALOGV("[%s]\talpha=%.3f", tag, hwc.alpha);
+ ALOGV("[%s]\tsourceCrop=%6.1f %6.1f %6.1f %6.1f", tag, hwc.sourceCrop.left, hwc.sourceCrop.top, hwc.sourceCrop.right, hwc.sourceCrop.bottom);
+
+ std::string label = tag;
+ label+=":visibleRegion";
+ hwc.visibleRegion.dump(label.c_str());
+ label = tag;
+ label+=":surfaceDamage";
+ hwc.surfaceDamage.dump(label.c_str());
+}
+
+void CompositionInfo::dumpRe(const char* tag) const {
+ ALOGV("[%s]\tblackoutLayer=%d", tag, re.blackoutLayer);
+ ALOGV("[%s]\tclearArea=%d", tag, re.clearArea);
+ ALOGV("[%s]\tpreMultipliedAlpha=%d", tag, re.preMultipliedAlpha);
+ ALOGV("[%s]\topaque=%d\n", tag, re.opaque);
+ ALOGV("[%s]\ttexture:name(%d), target(%d), size(%d/%d)", tag, re.texture.getTextureName(), re.texture.getTextureTarget(), (unsigned int)re.texture.getWidth(), (unsigned int)re.texture.getHeight());
+ ALOGV("[%s]\tuseIdentityTransform=%d\n", tag, re.useIdentityTransform);
+}
+
+void CompositionInfo::dump(const char* tag) const {
+ ALOGV("[%s] CompositionInfo", tag);
+ ALOGV("[%s]\tLayerName: %s", tag, layerName.c_str());
+ ALOGV("[%s]\tCompositionType: %d", tag, compositionType);
+ ALOGV("[%s]\tmBuffer = %p", tag, mBuffer.get());
+ ALOGV("[%s]\tmBufferSlot=%d", tag, mBufferSlot);
+ switch (compositionType) {
+ case HWC2::Composition::Device:
+ dumpHwc(tag);
+ break;
+ case HWC2::Composition::Client:
+ dumpRe(tag);
+ default:
+ break;
+ }
+}
+
+}; // namespace android
diff --git a/services/surfaceflinger/LayerBE.h b/services/surfaceflinger/LayerBE.h
new file mode 100644
index 0000000..981f756
--- /dev/null
+++ b/services/surfaceflinger/LayerBE.h
@@ -0,0 +1,149 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <sys/types.h>
+
+#include <ui/Region.h>
+
+#include "SurfaceFlinger.h"
+
+#include "DisplayHardware/HWComposer.h"
+#include "DisplayHardware/HWComposerBufferCache.h"
+#include "RenderEngine/Mesh.h"
+#include "RenderEngine/Texture.h"
+
+namespace android {
+
+class LayerBE;
+
+class LayerContainer
+{
+ public:
+ LayerContainer(HWComposer* hwc, int32_t hwcId) : mHwc(hwc), mHwcId(hwcId) {
+ mLayer = hwc->createLayer(hwcId);
+ }
+
+ ~LayerContainer() {
+ mHwc->destroyLayer(mHwcId, mLayer);
+ }
+
+ HWC2::Layer* operator->() {
+ return mLayer;
+ }
+
+ operator HWC2::Layer*const () const {
+ return mLayer;
+ }
+
+ private:
+ HWComposer* mHwc;
+ int32_t mHwcId;
+ HWC2::Layer* mLayer;
+};
+
+struct CompositionInfo {
+ std::string layerName;
+ HWC2::Composition compositionType;
+ sp<GraphicBuffer> mBuffer = nullptr;
+ int mBufferSlot = BufferQueue::INVALID_BUFFER_SLOT;
+ LayerBE* layer = nullptr;
+ struct {
+ std::shared_ptr<LayerContainer> hwcLayer;
+ int32_t hwid = -1;
+ sp<Fence> fence;
+ HWC2::BlendMode blendMode = HWC2::BlendMode::Invalid;
+ Rect displayFrame;
+ float alpha;
+ FloatRect sourceCrop;
+ HWC2::Transform transform = HWC2::Transform::None;
+ int z;
+ int type;
+ int appId;
+ Region visibleRegion;
+ Region surfaceDamage;
+ sp<NativeHandle> sidebandStream;
+ android_dataspace dataspace;
+ hwc_color_t color;
+ } hwc;
+ struct {
+ Mesh* mesh;
+ bool blackoutLayer = false;
+ bool clearArea = false;
+ bool preMultipliedAlpha = false;
+ bool opaque = false;
+ half4 color;
+ Texture texture;
+ bool useIdentityTransform = false;
+ } re;
+
+ void dump(const char* tag) const;
+ void dumpHwc(const char* tag) const;
+ void dumpRe(const char* tag) const;
+};
+
+class LayerBE {
+public:
+ friend class Layer;
+ friend class BufferLayer;
+ friend class ColorLayer;
+ friend class SurfaceFlinger;
+
+ LayerBE(Layer* layer, std::string layerName);
+
+ void onLayerDisplayed(const sp<Fence>& releaseFence);
+ Mesh& getMesh() { return mMesh; }
+
+private:
+ Layer*const mLayer;
+ // The mesh used to draw the layer in GLES composition mode
+ Mesh mMesh;
+
+ // HWC items, accessed from the main thread
+ struct HWCInfo {
+ HWCInfo()
+ : hwc(nullptr),
+ layer(nullptr),
+ forceClientComposition(false),
+ compositionType(HWC2::Composition::Invalid),
+ clearClientTarget(false),
+ transform(HWC2::Transform::None) {}
+
+ HWComposer* hwc;
+ std::shared_ptr<LayerContainer> layer;
+ bool forceClientComposition;
+ HWC2::Composition compositionType;
+ bool clearClientTarget;
+ Rect displayFrame;
+ FloatRect sourceCrop;
+ HWComposerBufferCache bufferCache;
+ HWC2::Transform transform;
+ };
+
+
+ // A layer can be attached to multiple displays when operating in mirror mode
+ // (a.k.a: when several displays are attached with equal layerStack). In this
+ // case we need to keep track. In non-mirror mode, a layer will have only one
+ // HWCInfo. This map key is a display layerStack.
+ std::unordered_map<int32_t, HWCInfo> mHwcLayers;
+
+ CompositionInfo compositionInfo;
+};
+
+}; // namespace android
+
diff --git a/services/surfaceflinger/LayerProtoHelper.cpp b/services/surfaceflinger/LayerProtoHelper.cpp
index 6a33148..cc39550 100644
--- a/services/surfaceflinger/LayerProtoHelper.cpp
+++ b/services/surfaceflinger/LayerProtoHelper.cpp
@@ -37,6 +37,13 @@
rectProto->set_right(rect.right);
}
+void LayerProtoHelper::writeToProto(const FloatRect& rect, FloatRectProto* rectProto) {
+ rectProto->set_left(rect.left);
+ rectProto->set_top(rect.top);
+ rectProto->set_bottom(rect.bottom);
+ rectProto->set_right(rect.right);
+}
+
void LayerProtoHelper::writeToProto(const half4 color, ColorProto* colorProto) {
colorProto->set_r(color.r);
colorProto->set_g(color.g);
diff --git a/services/surfaceflinger/LayerProtoHelper.h b/services/surfaceflinger/LayerProtoHelper.h
index 45a0b5d..860da63 100644
--- a/services/surfaceflinger/LayerProtoHelper.h
+++ b/services/surfaceflinger/LayerProtoHelper.h
@@ -29,6 +29,7 @@
class LayerProtoHelper {
public:
static void writeToProto(const Rect& rect, RectProto* rectProto);
+ static void writeToProto(const FloatRect& rect, FloatRectProto* rectProto);
static void writeToProto(const Region& region, RegionProto* regionProto);
static void writeToProto(const half4 color, ColorProto* colorProto);
static void writeToProto(const Transform& transform, TransformProto* transformProto);
@@ -36,4 +37,4 @@
};
} // namespace surfaceflinger
-} // namespace android
\ No newline at end of file
+} // namespace android
diff --git a/services/surfaceflinger/LayerStats.cpp b/services/surfaceflinger/LayerStats.cpp
new file mode 100644
index 0000000..ea2542c
--- /dev/null
+++ b/services/surfaceflinger/LayerStats.cpp
@@ -0,0 +1,182 @@
+/*
+ * Copyright 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#undef LOG_TAG
+#define LOG_TAG "LayerStats"
+#define ATRACE_TAG ATRACE_TAG_GRAPHICS
+
+#include "LayerStats.h"
+#include "DisplayHardware/HWComposer.h"
+
+#include <android-base/stringprintf.h>
+#include <log/log.h>
+#include <utils/String8.h>
+#include <utils/Trace.h>
+
+namespace android {
+
+void LayerStats::enable() {
+ ATRACE_CALL();
+ std::lock_guard<std::mutex> lock(mMutex);
+ if (mEnabled) return;
+ mLayerStatsMap.clear();
+ mEnabled = true;
+ ALOGD("Logging enabled");
+}
+
+void LayerStats::disable() {
+ ATRACE_CALL();
+ std::lock_guard<std::mutex> lock(mMutex);
+ if (!mEnabled) return;
+ mEnabled = false;
+ ALOGD("Logging disabled");
+}
+
+void LayerStats::clear() {
+ ATRACE_CALL();
+ std::lock_guard<std::mutex> lock(mMutex);
+ mLayerStatsMap.clear();
+ ALOGD("Cleared current layer stats");
+}
+
+bool LayerStats::isEnabled() {
+ return mEnabled;
+}
+
+void LayerStats::traverseLayerTreeStatsLocked(
+ const std::vector<const LayerProtoParser::Layer*>& layerTree,
+ const LayerProtoParser::LayerGlobal* layerGlobal) {
+ for (auto layer : layerTree) {
+ if (!layer) continue;
+ traverseLayerTreeStatsLocked(layer->children, layerGlobal);
+ std::string key =
+ base::StringPrintf("%s,%s,%s,%s,%s,%s,%s,%s,%s",
+ destinationLocation(layer->hwcFrame.left,
+ layerGlobal->resolution[0], true),
+ destinationLocation(layer->hwcFrame.top,
+ layerGlobal->resolution[1], false),
+ destinationSize(layer->hwcFrame.right - layer->hwcFrame.left,
+ layerGlobal->resolution[0], true),
+ destinationSize(layer->hwcFrame.bottom - layer->hwcFrame.top,
+ layerGlobal->resolution[1], false),
+ layer->type.c_str(), scaleRatioWH(layer).c_str(),
+ layerTransform(layer->hwcTransform), layer->pixelFormat.c_str(),
+ layer->dataspace.c_str());
+ mLayerStatsMap[key]++;
+ }
+}
+
+void LayerStats::logLayerStats(const LayersProto& layersProto) {
+ ATRACE_CALL();
+ auto layerGlobal = LayerProtoParser::generateLayerGlobalInfo(layersProto);
+ auto layerTree = LayerProtoParser::generateLayerTree(layersProto);
+ std::lock_guard<std::mutex> lock(mMutex);
+ traverseLayerTreeStatsLocked(layerTree, &layerGlobal);
+ LayerProtoParser::destroyLayerTree(layerTree);
+}
+
+void LayerStats::dump(String8& result) {
+ ATRACE_CALL();
+ ALOGD("Dumping");
+ result.append("Count,DstPosX,DstPosY,DstWidth,DstHeight,LayerType,WScale,HScale,");
+ result.append("Transform,PixelFormat,Dataspace\n");
+ std::lock_guard<std::mutex> lock(mMutex);
+ for (auto& u : mLayerStatsMap) {
+ result.appendFormat("%u,%s\n", u.second, u.first.c_str());
+ }
+}
+
+const char* LayerStats::destinationLocation(int32_t location, int32_t range, bool isHorizontal) {
+ static const char* locationArray[8] = {"0", "1/8", "1/4", "3/8", "1/2", "5/8", "3/4", "7/8"};
+ int32_t ratio = location * 8 / range;
+ if (ratio < 0) return "N/A";
+ if (isHorizontal) {
+ // X location is divided into 4 buckets {"0", "1/4", "1/2", "3/4"}
+ if (ratio > 6) return "3/4";
+ // use index 0, 2, 4, 6
+ return locationArray[ratio & ~1];
+ }
+ if (ratio > 7) return "7/8";
+ return locationArray[ratio];
+}
+
+const char* LayerStats::destinationSize(int32_t size, int32_t range, bool isWidth) {
+ static const char* sizeArray[8] = {"1/8", "1/4", "3/8", "1/2", "5/8", "3/4", "7/8", "1"};
+ int32_t ratio = size * 8 / range;
+ if (ratio < 0) return "N/A";
+ if (isWidth) {
+ // width is divided into 4 buckets {"1/4", "1/2", "3/4", "1"}
+ if (ratio > 6) return "1";
+ // use index 1, 3, 5, 7
+ return sizeArray[ratio | 1];
+ }
+ if (ratio > 7) return "1";
+ return sizeArray[ratio];
+}
+
+const char* LayerStats::layerTransform(int32_t transform) {
+ return getTransformName(static_cast<hwc_transform_t>(transform));
+}
+
+std::string LayerStats::scaleRatioWH(const LayerProtoParser::Layer* layer) {
+ if (!layer->type.compare("ColorLayer")) return "N/A,N/A";
+ std::string ret = "";
+ if (isRotated(layer->hwcTransform)) {
+ ret += scaleRatio(layer->hwcFrame.right - layer->hwcFrame.left,
+ static_cast<int32_t>(layer->hwcCrop.bottom - layer->hwcCrop.top));
+ ret += ",";
+ ret += scaleRatio(layer->hwcFrame.bottom - layer->hwcFrame.top,
+ static_cast<int32_t>(layer->hwcCrop.right - layer->hwcCrop.left));
+ } else {
+ ret += scaleRatio(layer->hwcFrame.right - layer->hwcFrame.left,
+ static_cast<int32_t>(layer->hwcCrop.right - layer->hwcCrop.left));
+ ret += ",";
+ ret += scaleRatio(layer->hwcFrame.bottom - layer->hwcFrame.top,
+ static_cast<int32_t>(layer->hwcCrop.bottom - layer->hwcCrop.top));
+ }
+ return ret;
+}
+
+const char* LayerStats::scaleRatio(int32_t destinationScale, int32_t sourceScale) {
+ // Make scale buckets from <1/64 to >= 16, to avoid floating point
+ // calculation, x64 on destinationScale first
+ int32_t scale = destinationScale * 64 / sourceScale;
+ if (!scale) return "<1/64";
+ if (scale < 2) return "1/64";
+ if (scale < 4) return "1/32";
+ if (scale < 8) return "1/16";
+ if (scale < 16) return "1/8";
+ if (scale < 32) return "1/4";
+ if (scale < 64) return "1/2";
+ if (scale < 128) return "1";
+ if (scale < 256) return "2";
+ if (scale < 512) return "4";
+ if (scale < 1024) return "8";
+ return ">=16";
+}
+
+bool LayerStats::isRotated(int32_t transform) {
+ return transform & HWC_TRANSFORM_ROT_90;
+}
+
+bool LayerStats::isVFlipped(int32_t transform) {
+ return transform & HWC_TRANSFORM_FLIP_V;
+}
+
+bool LayerStats::isHFlipped(int32_t transform) {
+ return transform & HWC_TRANSFORM_FLIP_H;
+}
+
+} // namespace android
diff --git a/services/surfaceflinger/LayerStats.h b/services/surfaceflinger/LayerStats.h
new file mode 100644
index 0000000..1924110
--- /dev/null
+++ b/services/surfaceflinger/LayerStats.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <layerproto/LayerProtoHeader.h>
+#include <layerproto/LayerProtoParser.h>
+#include <mutex>
+#include <unordered_map>
+
+using namespace android::surfaceflinger;
+
+namespace android {
+class String8;
+
+class LayerStats {
+public:
+ void enable();
+ void disable();
+ void clear();
+ bool isEnabled();
+ void logLayerStats(const LayersProto& layersProto);
+ void dump(String8& result);
+
+private:
+ // Traverse layer tree to get all visible layers' stats
+ void traverseLayerTreeStatsLocked(const std::vector<const LayerProtoParser::Layer*>& layerTree,
+ const LayerProtoParser::LayerGlobal* layerGlobal);
+ // Convert layer's top-left position into 8x8 percentage of the display
+ static const char* destinationLocation(int32_t location, int32_t range, bool isHorizontal);
+ // Convert layer's size into 8x8 percentage of the display
+ static const char* destinationSize(int32_t size, int32_t range, bool isWidth);
+ // Return the name of the transform
+ static const char* layerTransform(int32_t transform);
+ // Calculate scale ratios of layer's width/height with rotation information
+ static std::string scaleRatioWH(const LayerProtoParser::Layer* layer);
+ // Calculate scale ratio from source to destination and convert to string
+ static const char* scaleRatio(int32_t destinationScale, int32_t sourceScale);
+ // Return whether the original buffer is rotated in final composition
+ static bool isRotated(int32_t transform);
+ // Return whether the original buffer is V-flipped in final composition
+ static bool isVFlipped(int32_t transform);
+ // Return whether the original buffer is H-flipped in final composition
+ static bool isHFlipped(int32_t transform);
+
+ bool mEnabled = false;
+ // Protect mLayersStatsMap
+ std::mutex mMutex;
+ // Hashmap for tracking the layer stats
+ // KEY is a concatenation of a particular set of layer properties
+ // VALUE is the number of times this particular get scanned out
+ std::unordered_map<std::string, uint32_t> mLayerStatsMap;
+};
+
+} // namespace android
diff --git a/services/surfaceflinger/RenderArea.h b/services/surfaceflinger/RenderArea.h
index fa4df83..b9c4909 100644
--- a/services/surfaceflinger/RenderArea.h
+++ b/services/surfaceflinger/RenderArea.h
@@ -1,7 +1,11 @@
#pragma once
+#include <ui/GraphicsTypes.h>
+
#include "Transform.h"
+#include <functional>
+
namespace android {
class RenderArea {
@@ -22,11 +26,13 @@
virtual bool needsFiltering() const = 0;
virtual Rect getSourceCrop() const = 0;
+ virtual void render(std::function<void()> drawLayers) { drawLayers(); }
+
int getReqHeight() const { return mReqHeight; };
int getReqWidth() const { return mReqWidth; };
Transform::orientation_flags getRotationFlags() const { return mRotationFlags; };
virtual bool getWideColorSupport() const = 0;
- virtual android_color_mode_t getActiveColorMode() const = 0;
+ virtual ColorMode getActiveColorMode() const = 0;
status_t updateDimensions();
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index 06a11c8..af53a32 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -61,20 +61,21 @@
#include <private/android_filesystem_config.h>
#include <private/gui/SyncFeatures.h>
+#include "BufferLayer.h"
#include "Client.h"
-#include "clz.h"
+#include "ColorLayer.h"
#include "Colorizer.h"
+#include "ContainerLayer.h"
#include "DdmConnection.h"
-#include "DisplayDevice.h"
#include "DispSync.h"
+#include "DisplayDevice.h"
#include "EventControlThread.h"
#include "EventThread.h"
#include "Layer.h"
-#include "BufferLayer.h"
#include "LayerVector.h"
-#include "ColorLayer.h"
#include "MonitoredProducer.h"
#include "SurfaceFlinger.h"
+#include "clz.h"
#include "DisplayHardware/ComposerHal.h"
#include "DisplayHardware/FramebufferSurface.h"
@@ -260,6 +261,11 @@
mLayerTripleBufferingDisabled = atoi(value);
ALOGI_IF(mLayerTripleBufferingDisabled, "Disabling Triple Buffering");
+ // TODO (b/74616334): Reduce the default value once we isolate the leak
+ const size_t defaultListSize = 4 * MAX_LAYERS;
+ auto listSize = property_get_int32("debug.sf.max_igbp_list_size", int32_t(defaultListSize));
+ mMaxGraphicBufferProducerListSize = (listSize > 0) ? size_t(listSize) : defaultListSize;
+
// We should be reading 'persist.sys.sf.color_saturation' here
// but since /data may be encrypted, we need to wait until after vold
// comes online to attempt to read the property. The property is
@@ -913,7 +919,7 @@
return NO_ERROR;
}
status_t SurfaceFlinger::getDisplayColorModes(const sp<IBinder>& display,
- Vector<android_color_mode_t>* outColorModes) {
+ Vector<ColorMode>* outColorModes) {
if ((outColorModes == nullptr) || (display.get() == nullptr)) {
return BAD_VALUE;
}
@@ -934,7 +940,7 @@
return type;
}
- std::vector<android_color_mode_t> modes;
+ std::vector<ColorMode> modes;
{
ConditionalLock _l(mStateLock,
std::this_thread::get_id() != mMainThreadId);
@@ -946,18 +952,18 @@
return NO_ERROR;
}
-android_color_mode_t SurfaceFlinger::getActiveColorMode(const sp<IBinder>& display) {
+ColorMode SurfaceFlinger::getActiveColorMode(const sp<IBinder>& display) {
sp<const DisplayDevice> device(getDisplayDevice(display));
if (device != nullptr) {
return device->getActiveColorMode();
}
- return static_cast<android_color_mode_t>(BAD_VALUE);
+ return static_cast<ColorMode>(BAD_VALUE);
}
void SurfaceFlinger::setActiveColorModeInternal(const sp<DisplayDevice>& hw,
- android_color_mode_t mode) {
+ ColorMode mode) {
int32_t type = hw->getDisplayType();
- android_color_mode_t currentMode = hw->getActiveColorMode();
+ ColorMode currentMode = hw->getActiveColorMode();
if (mode == currentMode) {
return;
@@ -977,20 +983,20 @@
status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& display,
- android_color_mode_t colorMode) {
+ ColorMode colorMode) {
class MessageSetActiveColorMode: public MessageBase {
SurfaceFlinger& mFlinger;
sp<IBinder> mDisplay;
- android_color_mode_t mMode;
+ ColorMode mMode;
public:
MessageSetActiveColorMode(SurfaceFlinger& flinger, const sp<IBinder>& disp,
- android_color_mode_t mode) :
+ ColorMode mode) :
mFlinger(flinger), mDisplay(disp) { mMode = mode; }
virtual bool handler() {
- Vector<android_color_mode_t> modes;
+ Vector<ColorMode> modes;
mFlinger.getDisplayColorModes(mDisplay, &modes);
bool exists = std::find(std::begin(modes), std::end(modes), mMode) != std::end(modes);
- if (mMode < 0 || !exists) {
+ if (mMode < ColorMode::NATIVE || !exists) {
ALOGE("Attempt to set invalid active color mode %s (%d) for display %p",
decodeColorMode(mMode).c_str(), mMode, mDisplay.get());
return true;
@@ -1450,6 +1456,7 @@
setUpHWComposer();
doDebugFlashRegions();
doTracing("handleRefresh");
+ logLayerStats();
doComposition();
postComposition(refreshStartTime);
@@ -1519,6 +1526,25 @@
}
}
+void SurfaceFlinger::logLayerStats() {
+ ATRACE_CALL();
+ if (CC_UNLIKELY(mLayerStats.isEnabled())) {
+ int32_t hwcId = -1;
+ for (size_t dpy = 0; dpy < mDisplays.size(); ++dpy) {
+ const sp<const DisplayDevice>& displayDevice(mDisplays[dpy]);
+ if (displayDevice->isPrimary()) {
+ hwcId = displayDevice->getHwcDisplayId();
+ break;
+ }
+ }
+ if (hwcId < 0) {
+ ALOGE("LayerStats: Hmmm, no primary display?");
+ return;
+ }
+ mLayerStats.logLayerStats(dumpVisibleLayersProtoInfo(hwcId));
+ }
+}
+
void SurfaceFlinger::preComposition(nsecs_t refreshStartTime)
{
ATRACE_CALL();
@@ -1783,9 +1809,9 @@
// pickColorMode translates a given dataspace into the best available color mode.
// Currently only support sRGB and Display-P3.
-android_color_mode SurfaceFlinger::pickColorMode(android_dataspace dataSpace) const {
+ColorMode SurfaceFlinger::pickColorMode(android_dataspace dataSpace) const {
if (mForceNativeColorMode) {
- return HAL_COLOR_MODE_NATIVE;
+ return ColorMode::NATIVE;
}
switch (dataSpace) {
@@ -1794,18 +1820,18 @@
case HAL_DATASPACE_UNKNOWN:
case HAL_DATASPACE_SRGB:
case HAL_DATASPACE_V0_SRGB:
- return HAL_COLOR_MODE_SRGB;
+ return ColorMode::SRGB;
break;
case HAL_DATASPACE_DISPLAY_P3:
- return HAL_COLOR_MODE_DISPLAY_P3;
+ return ColorMode::DISPLAY_P3;
break;
default:
// TODO (courtneygo): Do we want to assert an error here?
ALOGE("No color mode mapping for %s (%#x)", dataspaceDetails(dataSpace).c_str(),
dataSpace);
- return HAL_COLOR_MODE_SRGB;
+ return ColorMode::SRGB;
break;
}
}
@@ -1927,7 +1953,7 @@
}
if (hasWideColorDisplay) {
- android_color_mode newColorMode;
+ ColorMode newColorMode;
android_dataspace newDataSpace = HAL_DATASPACE_V0_SRGB;
for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) {
@@ -2014,7 +2040,7 @@
displayDevice->getClientTargetAcquireFence());
}
- layer->onLayerDisplayed(releaseFence);
+ layer->getBE().onLayerDisplayed(releaseFence);
}
// We've got a list of layers needing fences, that are disjoint with
@@ -2023,7 +2049,7 @@
if (!displayDevice->getLayersNeedingFences().isEmpty()) {
sp<Fence> presentFence = getBE().mHwc->getPresentFence(hwcId);
for (auto& layer : displayDevice->getLayersNeedingFences()) {
- layer->onLayerDisplayed(presentFence);
+ layer->getBE().onLayerDisplayed(presentFence);
}
}
@@ -2269,13 +2295,13 @@
if (dispSurface != nullptr) {
bool hasWideColorSupport = false;
if (hasWideColorDisplay) {
- std::vector<android_color_mode_t> modes =
+ std::vector<ColorMode> modes =
getHwComposer().getColorModes(state.type);
- for (android_color_mode_t colorMode : modes) {
+ for (ColorMode colorMode : modes) {
switch (colorMode) {
- case HAL_COLOR_MODE_DISPLAY_P3:
- case HAL_COLOR_MODE_ADOBE_RGB:
- case HAL_COLOR_MODE_DCI_P3:
+ case ColorMode::DISPLAY_P3:
+ case ColorMode::ADOBE_RGB:
+ case ColorMode::DCI_P3:
hasWideColorSupport = true;
break;
default:
@@ -2298,9 +2324,9 @@
dispSurface, producer, hasWideColorSupport,
hasHdrSupport);
- android_color_mode defaultColorMode = HAL_COLOR_MODE_NATIVE;
+ ColorMode defaultColorMode = ColorMode::NATIVE;
if (hasWideColorSupport) {
- defaultColorMode = HAL_COLOR_MODE_SRGB;
+ defaultColorMode = ColorMode::SRGB;
}
setActiveColorModeInternal(hw, defaultColorMode);
hw->setCompositionDataSpace(HAL_DATASPACE_UNKNOWN);
@@ -2741,7 +2767,7 @@
android_dataspace outputDataspace = HAL_DATASPACE_UNKNOWN;
if (displayDevice->getWideColorSupport() &&
- displayDevice->getActiveColorMode() == HAL_COLOR_MODE_DISPLAY_P3) {
+ displayDevice->getActiveColorMode() == ColorMode::DISPLAY_P3) {
outputDataspace = HAL_DATASPACE_DISPLAY_P3;
}
getBE().mRenderEngine->setOutputDataSpace(outputDataspace);
@@ -2896,8 +2922,11 @@
}
mGraphicBufferProducerList.insert(IInterface::asBinder(gbc).get());
- LOG_ALWAYS_FATAL_IF(mGraphicBufferProducerList.size() > MAX_LAYERS,
- "Suspected IGBP leak");
+ // TODO (b/74616334): Change this back to a fatal assert once the leak is fixed
+ ALOGE_IF(mGraphicBufferProducerList.size() > mMaxGraphicBufferProducerListSize,
+ "Suspected IGBP leak: %zu IGBPs (%zu max), %zu Layers",
+ mGraphicBufferProducerList.size(), mMaxGraphicBufferProducerListSize,
+ mNumLayers);
mLayersAdded = true;
mNumLayers++;
}
@@ -3696,6 +3725,34 @@
dumpWideColorInfo(result);
dumpAll = false;
}
+
+ if ((index < numArgs) &&
+ (args[index] == String16("--enable-layer-stats"))) {
+ index++;
+ mLayerStats.enable();
+ dumpAll = false;
+ }
+
+ if ((index < numArgs) &&
+ (args[index] == String16("--disable-layer-stats"))) {
+ index++;
+ mLayerStats.disable();
+ dumpAll = false;
+ }
+
+ if ((index < numArgs) &&
+ (args[index] == String16("--clear-layer-stats"))) {
+ index++;
+ mLayerStats.clear();
+ dumpAll = false;
+ }
+
+ if ((index < numArgs) &&
+ (args[index] == String16("--dump-layer-stats"))) {
+ index++;
+ mLayerStats.dump(result);
+ dumpAll = false;
+ }
}
if (dumpAll) {
@@ -3879,12 +3936,12 @@
}
result.appendFormat("Display %d color modes:\n", hwcId);
- std::vector<android_color_mode_t> modes = getHwComposer().getColorModes(hwcId);
+ std::vector<ColorMode> modes = getHwComposer().getColorModes(hwcId);
for (auto&& mode : modes) {
result.appendFormat(" %s (%d)\n", decodeColorMode(mode).c_str(), mode);
}
- android_color_mode_t currentMode = displayDevice->getActiveColorMode();
+ ColorMode currentMode = displayDevice->getActiveColorMode();
result.appendFormat(" Current color mode: %s (%d)\n",
decodeColorMode(currentMode).c_str(), currentMode);
}
@@ -3903,6 +3960,25 @@
return layersProto;
}
+LayersProto SurfaceFlinger::dumpVisibleLayersProtoInfo(int32_t hwcId) const {
+ LayersProto layersProto;
+
+ const sp<DisplayDevice>& displayDevice(mDisplays[hwcId]);
+ SizeProto* resolution = layersProto.mutable_resolution();
+ resolution->set_w(displayDevice->getWidth());
+ resolution->set_h(displayDevice->getHeight());
+
+ mDrawingState.traverseInZOrder([&](Layer* layer) {
+ if (!layer->visibleRegion.isEmpty() &&
+ layer->getBE().mHwcLayers.count(hwcId)) {
+ LayerProto* layerProto = layersProto.add_layers();
+ layer->writeToProto(layerProto, hwcId);
+ }
+ });
+
+ return layersProto;
+}
+
void SurfaceFlinger::dumpAllLocked(const Vector<String16>& args, size_t& index,
String8& result) const
{
@@ -3966,6 +4042,8 @@
*/
colorizer.bold(result);
result.appendFormat("Visible layers (count = %zu)\n", mNumLayers);
+ result.appendFormat("GraphicBufferProducers: %zu, max %zu\n",
+ mGraphicBufferProducerList.size(), mMaxGraphicBufferProducerListSize);
colorizer.reset(result);
LayersProto layersProto = dumpProtoInfo(LayerVector::StateSet::Current);
@@ -4410,6 +4488,8 @@
if (CC_UNLIKELY(display == 0)) return BAD_VALUE;
const sp<const DisplayDevice> device(getDisplayDeviceLocked(display));
+ if (CC_UNLIKELY(device == 0)) return BAD_VALUE;
+
DisplayRenderArea renderArea(device, sourceCrop, reqHeight, reqWidth, rotation);
auto traverseLayers = std::bind(std::mem_fn(&SurfaceFlinger::traverseLayersInDisplay), this,
@@ -4419,19 +4499,18 @@
status_t SurfaceFlinger::captureLayers(const sp<IBinder>& layerHandleBinder,
sp<GraphicBuffer>* outBuffer, const Rect& sourceCrop,
- float frameScale) {
+ float frameScale, bool childrenOnly) {
ATRACE_CALL();
class LayerRenderArea : public RenderArea {
public:
- LayerRenderArea(const sp<Layer>& layer, const Rect crop, int32_t reqWidth,
- int32_t reqHeight)
- : RenderArea(reqHeight, reqWidth), mLayer(layer), mCrop(crop) {}
- const Transform& getTransform() const override {
- // Make the top level transform the inverse the transform and it's parent so it sets
- // the whole capture back to 0,0
- return *new Transform(mLayer->getTransform().inverse());
- }
+ LayerRenderArea(SurfaceFlinger* flinger, const sp<Layer>& layer, const Rect crop,
+ int32_t reqWidth, int32_t reqHeight, bool childrenOnly)
+ : RenderArea(reqHeight, reqWidth),
+ mLayer(layer),
+ mCrop(crop),
+ mFlinger(flinger),
+ mChildrenOnly(childrenOnly) {}
Rect getBounds() const override {
const Layer::State& layerState(mLayer->getDrawingState());
return Rect(layerState.active.w, layerState.active.h);
@@ -4440,6 +4519,34 @@
int getWidth() const override { return mLayer->getDrawingState().active.w; }
bool isSecure() const override { return false; }
bool needsFiltering() const override { return false; }
+ const Transform& getTransform() const { return mTransform; }
+
+ class ReparentForDrawing {
+ public:
+ const sp<Layer>& oldParent;
+ const sp<Layer>& newParent;
+
+ ReparentForDrawing(const sp<Layer>& oldParent, const sp<Layer>& newParent)
+ : oldParent(oldParent), newParent(newParent) {
+ oldParent->reparentChildrenForDrawing(newParent);
+ }
+ ~ReparentForDrawing() { newParent->reparentChildrenForDrawing(oldParent); }
+ };
+
+ void render(std::function<void()> drawLayers) override {
+ if (!mChildrenOnly) {
+ mTransform = mLayer->getTransform().inverse();
+ drawLayers();
+ } else {
+ Rect bounds = getBounds();
+ screenshotParentLayer =
+ new ContainerLayer(mFlinger, nullptr, String8("Screenshot Parent"),
+ bounds.getWidth(), bounds.getHeight(), 0);
+
+ ReparentForDrawing reparent(mLayer, screenshotParentLayer);
+ drawLayers();
+ }
+ }
Rect getSourceCrop() const override {
if (mCrop.isEmpty()) {
@@ -4449,11 +4556,19 @@
}
}
bool getWideColorSupport() const override { return false; }
- android_color_mode_t getActiveColorMode() const override { return HAL_COLOR_MODE_NATIVE; }
+ ColorMode getActiveColorMode() const override { return ColorMode::NATIVE; }
private:
const sp<Layer> mLayer;
const Rect mCrop;
+
+ // In the "childrenOnly" case we reparent the children to a screenshot
+ // layer which has no properties set and which does not draw.
+ sp<ContainerLayer> screenshotParentLayer;
+ Transform mTransform;
+
+ SurfaceFlinger* mFlinger;
+ const bool mChildrenOnly;
};
auto layerHandle = reinterpret_cast<Layer::Handle*>(layerHandleBinder.get());
@@ -4464,6 +4579,13 @@
return NAME_NOT_FOUND;
}
+ const int uid = IPCThreadState::self()->getCallingUid();
+ const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
+ if (!forSystem && parent->getCurrentState().flags & layer_state_t::eLayerSecure) {
+ ALOGW("Attempting to capture secure layer: PERMISSION_DENIED");
+ return PERMISSION_DENIED;
+ }
+
Rect crop(sourceCrop);
if (sourceCrop.width() <= 0) {
crop.left = 0;
@@ -4478,12 +4600,14 @@
int32_t reqWidth = crop.width() * frameScale;
int32_t reqHeight = crop.height() * frameScale;
- LayerRenderArea renderArea(parent, crop, reqWidth, reqHeight);
+ LayerRenderArea renderArea(this, parent, crop, reqWidth, reqHeight, childrenOnly);
- auto traverseLayers = [parent](const LayerVector::Visitor& visitor) {
+ auto traverseLayers = [parent, childrenOnly](const LayerVector::Visitor& visitor) {
parent->traverseChildrenInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
if (!layer->isVisible()) {
return;
+ } else if (childrenOnly && layer == parent.get()) {
+ return;
}
visitor(layer);
});
@@ -4530,8 +4654,10 @@
int fd = -1;
{
Mutex::Autolock _l(mStateLock);
- result = captureScreenImplLocked(renderArea, traverseLayers, (*outBuffer).get(),
- useIdentityTransform, forSystem, &fd);
+ renderArea.render([&]() {
+ result = captureScreenImplLocked(renderArea, traverseLayers, (*outBuffer).get(),
+ useIdentityTransform, forSystem, &fd);
+ });
}
{
@@ -4604,7 +4730,7 @@
android_dataspace outputDataspace = HAL_DATASPACE_UNKNOWN;
if (renderArea.getWideColorSupport() &&
- renderArea.getActiveColorMode() == HAL_COLOR_MODE_DISPLAY_P3) {
+ renderArea.getActiveColorMode() == ColorMode::DISPLAY_P3) {
outputDataspace = HAL_DATASPACE_DISPLAY_P3;
}
getBE().mRenderEngine->setOutputDataSpace(outputDataspace);
diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h
index 43e3907..c7ffea7 100644
--- a/services/surfaceflinger/SurfaceFlinger.h
+++ b/services/surfaceflinger/SurfaceFlinger.h
@@ -44,6 +44,7 @@
#include <gui/LayerState.h>
#include <gui/OccupancyTracker.h>
+#include <gui/BufferQueue.h>
#include <hardware/hwcomposer_defs.h>
@@ -55,11 +56,13 @@
#include "DisplayDevice.h"
#include "DispSync.h"
#include "FrameTracker.h"
+#include "LayerStats.h"
#include "LayerVector.h"
#include "MessageQueue.h"
#include "SurfaceInterceptor.h"
#include "SurfaceTracing.h"
#include "StartPropertySetThread.h"
+#include "LayerBE.h"
#include "DisplayHardware/HWC2.h"
#include "DisplayHardware/HWComposer.h"
@@ -390,16 +393,16 @@
int32_t minLayerZ, int32_t maxLayerZ, bool useIdentityTransform,
ISurfaceComposer::Rotation rotation);
virtual status_t captureLayers(const sp<IBinder>& parentHandle, sp<GraphicBuffer>* outBuffer,
- const Rect& sourceCrop, float frameScale);
+ const Rect& sourceCrop, float frameScale, bool childrenOnly);
virtual status_t getDisplayStats(const sp<IBinder>& display,
DisplayStatInfo* stats);
virtual status_t getDisplayConfigs(const sp<IBinder>& display,
Vector<DisplayInfo>* configs);
virtual int getActiveConfig(const sp<IBinder>& display);
virtual status_t getDisplayColorModes(const sp<IBinder>& display,
- Vector<android_color_mode_t>* configs);
- virtual android_color_mode_t getActiveColorMode(const sp<IBinder>& display);
- virtual status_t setActiveColorMode(const sp<IBinder>& display, android_color_mode_t colorMode);
+ Vector<ColorMode>* configs);
+ virtual ColorMode getActiveColorMode(const sp<IBinder>& display);
+ virtual status_t setActiveColorMode(const sp<IBinder>& display, ColorMode colorMode);
virtual void setPowerMode(const sp<IBinder>& display, int mode);
virtual status_t setActiveConfig(const sp<IBinder>& display, int id);
virtual status_t clearAnimationFrameStats();
@@ -449,7 +452,7 @@
bool stateLockHeld);
// Called on the main thread in response to setActiveColorMode()
- void setActiveColorModeInternal(const sp<DisplayDevice>& hw, android_color_mode_t colorMode);
+ void setActiveColorModeInternal(const sp<DisplayDevice>& hw, ColorMode colorMode);
// Returns whether the transaction actually modified any state
bool handleMessageTransaction();
@@ -622,7 +625,7 @@
// Given a dataSpace, returns the appropriate color_mode to use
// to display that dataSpace.
- android_color_mode pickColorMode(android_dataspace dataSpace) const;
+ ColorMode pickColorMode(android_dataspace dataSpace) const;
android_dataspace bestTargetDataSpace(android_dataspace a, android_dataspace b,
bool hasHdr) const;
@@ -632,6 +635,7 @@
void doComposition();
void doDebugFlashRegions();
void doTracing(const char* where);
+ void logLayerStats();
void doDisplayComposition(const sp<const DisplayDevice>& displayDevice, const Region& dirtyRegion);
// compose surfaces for display hw. this fails if using GL and the surface
@@ -694,6 +698,7 @@
void dumpBufferingStats(String8& result) const;
void dumpWideColorInfo(String8& result) const;
LayersProto dumpProtoInfo(LayerVector::StateSet stateSet) const;
+ LayersProto dumpVisibleLayersProtoInfo(int32_t hwcId) const;
bool isLayerTripleBufferingDisabled() const {
return this->mLayerTripleBufferingDisabled;
@@ -723,6 +728,7 @@
// Can't be unordered_set because wp<> isn't hashable
std::set<wp<IBinder>> mGraphicBufferProducerList;
+ size_t mMaxGraphicBufferProducerListSize = MAX_LAYERS;
// protected by mStateLock (but we could use another lock)
bool mLayersRemoved;
@@ -779,6 +785,7 @@
std::unique_ptr<SurfaceInterceptor> mInterceptor =
std::make_unique<impl::SurfaceInterceptor>(this);
SurfaceTracing mTracing;
+ LayerStats mLayerStats;
bool mUseHwcVirtualDisplays = false;
// Restrict layers to use two buffers in their bufferqueues.
diff --git a/services/surfaceflinger/layerproto/Android.bp b/services/surfaceflinger/layerproto/Android.bp
index 485090c..ac147fe 100644
--- a/services/surfaceflinger/layerproto/Android.bp
+++ b/services/surfaceflinger/layerproto/Android.bp
@@ -10,6 +10,7 @@
],
shared_libs: [
+ "android.hardware.graphics.common@1.1",
"libui",
"libprotobuf-cpp-lite",
"libbase",
diff --git a/services/surfaceflinger/layerproto/LayerProtoParser.cpp b/services/surfaceflinger/layerproto/LayerProtoParser.cpp
index bf37e1e..7483abd 100644
--- a/services/surfaceflinger/layerproto/LayerProtoParser.cpp
+++ b/services/surfaceflinger/layerproto/LayerProtoParser.cpp
@@ -38,6 +38,19 @@
return lhs->id < rhs->id;
}
+const LayerProtoParser::LayerGlobal LayerProtoParser::generateLayerGlobalInfo(
+ const LayersProto& layersProto) {
+ return {{layersProto.resolution().w(), layersProto.resolution().h()}};
+}
+
+void LayerProtoParser::destroyLayerTree(
+ const std::vector<const LayerProtoParser::Layer*>& layerTree) {
+ for (auto layer : layerTree) {
+ destroyLayerTree(layer->children);
+ delete layer;
+ }
+}
+
std::vector<const LayerProtoParser::Layer*> LayerProtoParser::generateLayerTree(
const LayersProto& layersProto) {
auto layerMap = generateMap(layersProto);
@@ -102,6 +115,9 @@
layer->activeBuffer = generateActiveBuffer(layerProto.active_buffer());
layer->queuedFrames = layerProto.queued_frames();
layer->refreshPending = layerProto.refresh_pending();
+ layer->hwcFrame = generateRect(layerProto.hwc_frame());
+ layer->hwcCrop = generateFloatRect(layerProto.hwc_crop());
+ layer->hwcTransform = layerProto.hwc_transform();
return layer;
}
@@ -127,6 +143,16 @@
return rect;
}
+LayerProtoParser::FloatRect LayerProtoParser::generateFloatRect(const FloatRectProto& rectProto) {
+ LayerProtoParser::FloatRect rect;
+ rect.left = rectProto.left();
+ rect.top = rectProto.top();
+ rect.right = rectProto.right();
+ rect.bottom = rectProto.bottom();
+
+ return rect;
+}
+
LayerProtoParser::Transform LayerProtoParser::generateTransform(
const TransformProto& transformProto) {
LayerProtoParser::Transform transform;
@@ -242,6 +268,10 @@
return StringPrintf("[%3d, %3d, %3d, %3d]", left, top, right, bottom);
}
+std::string LayerProtoParser::FloatRect::to_string() const {
+ return StringPrintf("[%.2f, %.2f, %.2f, %.2f]", left, top, right, bottom);
+}
+
std::string LayerProtoParser::Region::to_string(const char* what) const {
std::string result =
StringPrintf(" Region %s (this=%lx count=%d)\n", what, static_cast<unsigned long>(id),
diff --git a/services/surfaceflinger/layerproto/include/layerproto/LayerProtoParser.h b/services/surfaceflinger/layerproto/include/layerproto/LayerProtoParser.h
index 78c6cd1..4747275 100644
--- a/services/surfaceflinger/layerproto/include/layerproto/LayerProtoParser.h
+++ b/services/surfaceflinger/layerproto/include/layerproto/LayerProtoParser.h
@@ -13,6 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+#pragma once
#include <layerproto/LayerProtoHeader.h>
@@ -56,6 +57,16 @@
std::string to_string() const;
};
+ class FloatRect {
+ public:
+ float left;
+ float top;
+ float right;
+ float bottom;
+
+ std::string to_string() const;
+ };
+
class Region {
public:
uint64_t id;
@@ -95,11 +106,21 @@
LayerProtoParser::ActiveBuffer activeBuffer;
int32_t queuedFrames;
bool refreshPending;
+ LayerProtoParser::Rect hwcFrame;
+ LayerProtoParser::FloatRect hwcCrop;
+ int32_t hwcTransform;
std::string to_string() const;
};
+ class LayerGlobal {
+ public:
+ int2 resolution;
+ };
+
+ static const LayerGlobal generateLayerGlobalInfo(const LayersProto& layersProto);
static std::vector<const Layer*> generateLayerTree(const LayersProto& layersProto);
+ static void destroyLayerTree(const std::vector<const LayerProtoParser::Layer*>& layerTree);
static std::string layersToString(const std::vector<const LayerProtoParser::Layer*> layers);
private:
@@ -107,6 +128,7 @@
static LayerProtoParser::Layer* generateLayer(const LayerProto& layerProto);
static LayerProtoParser::Region generateRegion(const RegionProto& regionProto);
static LayerProtoParser::Rect generateRect(const RectProto& rectProto);
+ static LayerProtoParser::FloatRect generateFloatRect(const FloatRectProto& rectProto);
static LayerProtoParser::Transform generateTransform(const TransformProto& transformProto);
static LayerProtoParser::ActiveBuffer generateActiveBuffer(
const ActiveBufferProto& activeBufferProto);
diff --git a/services/surfaceflinger/layerproto/layers.proto b/services/surfaceflinger/layerproto/layers.proto
index d27dc9b..e232f05 100644
--- a/services/surfaceflinger/layerproto/layers.proto
+++ b/services/surfaceflinger/layerproto/layers.proto
@@ -7,6 +7,7 @@
// Contains a list of all layers.
message LayersProto {
repeated LayerProto layers = 1;
+ optional SizeProto resolution = 2;
}
// Information about each layer.
@@ -64,6 +65,12 @@
// The number of frames available.
optional int32 queued_frames = 28;
optional bool refresh_pending = 29;
+ // The layer's composer backend destination frame
+ optional RectProto hwc_frame = 30;
+ // The layer's composer backend source crop
+ optional FloatRectProto hwc_crop = 31;
+ // The layer's composer backend transform
+ optional int32 hwc_transform = 32;
}
message PositionProto {
@@ -95,6 +102,13 @@
optional int32 bottom = 4;
}
+message FloatRectProto {
+ optional float left = 1;
+ optional float top = 2;
+ optional float right = 3;
+ optional float bottom = 4;
+}
+
message ActiveBufferProto {
optional uint32 width = 1;
optional uint32 height = 2;
@@ -107,4 +121,4 @@
optional float g = 2;
optional float b = 3;
optional float a = 4;
-}
\ No newline at end of file
+}
diff --git a/services/surfaceflinger/tests/Transaction_test.cpp b/services/surfaceflinger/tests/Transaction_test.cpp
index 92c26af..fd21991 100644
--- a/services/surfaceflinger/tests/Transaction_test.cpp
+++ b/services/surfaceflinger/tests/Transaction_test.cpp
@@ -192,6 +192,16 @@
*sc = std::make_unique<ScreenCapture>(outBuffer);
}
+ static void captureChildLayers(std::unique_ptr<ScreenCapture>* sc, sp<IBinder>& parentHandle,
+ Rect crop = Rect::EMPTY_RECT, float frameScale = 1.0) {
+ sp<ISurfaceComposer> sf(ComposerService::getComposerService());
+ SurfaceComposerClient::Transaction().apply(true);
+
+ sp<GraphicBuffer> outBuffer;
+ ASSERT_EQ(NO_ERROR, sf->captureLayers(parentHandle, &outBuffer, crop, frameScale, true));
+ *sc = std::make_unique<ScreenCapture>(outBuffer);
+ }
+
void expectColor(const Rect& rect, const Color& color, uint8_t tolerance = 0) {
ASSERT_EQ(HAL_PIXEL_FORMAT_RGBA_8888, mOutBuffer->getPixelFormat());
expectBufferColor(mOutBuffer, mPixels, rect, color, tolerance);
@@ -2306,6 +2316,74 @@
mCapture->expectChildColor(0, 0);
}
+TEST_F(ScreenCaptureTest, CaptureLayerChildOnly) {
+ auto fgHandle = mFGSurfaceControl->getHandle();
+
+ sp<SurfaceControl> child =
+ mComposerClient->createSurface(String8("Child surface"), 10, 10, PIXEL_FORMAT_RGBA_8888,
+ 0, mFGSurfaceControl.get());
+ fillSurfaceRGBA8(child, 200, 200, 200);
+
+ SurfaceComposerClient::Transaction().show(child).apply(true);
+
+ // Captures mFGSurfaceControl's child
+ ScreenCapture::captureChildLayers(&mCapture, fgHandle);
+ mCapture->checkPixel(10, 10, 0, 0, 0);
+ mCapture->expectChildColor(0, 0);
+}
+
+
+// In the following tests we verify successful skipping of a parent layer,
+// so we use the same verification logic and only change how we mutate
+// the parent layer to verify that various properties are ignored.
+class ScreenCaptureChildOnlyTest : public LayerUpdateTest {
+public:
+ void SetUp() override {
+ LayerUpdateTest::SetUp();
+
+ mChild =
+ mComposerClient->createSurface(String8("Child surface"), 10, 10, PIXEL_FORMAT_RGBA_8888,
+ 0, mFGSurfaceControl.get());
+ fillSurfaceRGBA8(mChild, 200, 200, 200);
+
+ SurfaceComposerClient::Transaction().show(mChild).apply(true);
+ }
+
+ void verify() {
+ auto fgHandle = mFGSurfaceControl->getHandle();
+ ScreenCapture::captureChildLayers(&mCapture, fgHandle);
+ mCapture->checkPixel(10, 10, 0, 0, 0);
+ mCapture->expectChildColor(0, 0);
+ }
+
+ std::unique_ptr<ScreenCapture> mCapture;
+ sp<SurfaceControl> mChild;
+};
+
+TEST_F(ScreenCaptureChildOnlyTest, CaptureLayerIgnoresParentVisibility) {
+
+ SurfaceComposerClient::Transaction().hide(mFGSurfaceControl).apply(true);
+
+ // Even though the parent is hidden we should still capture the child.
+ verify();
+}
+
+TEST_F(ScreenCaptureChildOnlyTest, CaptureLayerIgnoresParentCrop) {
+
+ SurfaceComposerClient::Transaction().setCrop(mFGSurfaceControl, Rect(0, 0, 1, 1)).apply(true);
+
+ // Even though the parent is cropped out we should still capture the child.
+ verify();
+}
+
+TEST_F(ScreenCaptureChildOnlyTest, CaptureLayerIgnoresTransform) {
+
+ SurfaceComposerClient::Transaction().setMatrix(mFGSurfaceControl, 2, 0, 0, 2);
+
+ // We should not inherit the parent scaling.
+ verify();
+}
+
TEST_F(ScreenCaptureTest, CaptureLayerWithGrandchild) {
auto fgHandle = mFGSurfaceControl->getHandle();
diff --git a/services/surfaceflinger/tests/hwc2/Hwc2Test.cpp b/services/surfaceflinger/tests/hwc2/Hwc2Test.cpp
index 4878c14..86e2e1e 100644
--- a/services/surfaceflinger/tests/hwc2/Hwc2Test.cpp
+++ b/services/surfaceflinger/tests/hwc2/Hwc2Test.cpp
@@ -22,6 +22,7 @@
#include <android-base/unique_fd.h>
#include <hardware/hardware.h>
#include <sync/sync.h>
+#include <ui/GraphicsTypes.h>
#define HWC2_INCLUDE_STRINGIFICATION
#define HWC2_USE_CPP11
@@ -34,6 +35,8 @@
#include "Hwc2TestClientTarget.h"
#include "Hwc2TestVirtualDisplay.h"
+using android::ColorMode;
+
void hwc2TestHotplugCallback(hwc2_callback_data_t callbackData,
hwc2_display_t display, int32_t connected);
void hwc2TestVsyncCallback(hwc2_callback_data_t callbackData,
@@ -865,7 +868,7 @@
}
void getColorModes(hwc2_display_t display,
- std::vector<android_color_mode_t>* outColorModes,
+ std::vector<ColorMode>* outColorModes,
hwc2_error_t* outErr = nullptr)
{
auto pfn = reinterpret_cast<HWC2_PFN_GET_COLOR_MODES>(
@@ -892,7 +895,7 @@
}
}
- void setColorMode(hwc2_display_t display, android_color_mode_t colorMode,
+ void setColorMode(hwc2_display_t display, ColorMode colorMode,
hwc2_error_t* outErr = nullptr)
{
auto pfn = reinterpret_cast<HWC2_PFN_SET_COLOR_MODE>(
@@ -905,7 +908,7 @@
*outErr = err;
} else {
ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set color mode "
- << colorMode;
+ << static_cast<int>(colorMode);
}
}
@@ -4252,33 +4255,33 @@
EXPECT_EQ(err, HWC2_ERROR_BAD_DISPLAY) << "returned wrong error code";
}
-static const std::array<android_color_mode, 9> androidColorModes = {{
- HAL_COLOR_MODE_NATIVE,
- HAL_COLOR_MODE_STANDARD_BT601_625,
- HAL_COLOR_MODE_STANDARD_BT601_625_UNADJUSTED,
- HAL_COLOR_MODE_STANDARD_BT601_525,
- HAL_COLOR_MODE_STANDARD_BT601_525_UNADJUSTED,
- HAL_COLOR_MODE_STANDARD_BT709,
- HAL_COLOR_MODE_DCI_P3,
- HAL_COLOR_MODE_SRGB,
- HAL_COLOR_MODE_ADOBE_RGB,
+static const std::array<ColorMode, 9> androidColorModes = {{
+ ColorMode::NATIVE,
+ ColorMode::STANDARD_BT601_625,
+ ColorMode::STANDARD_BT601_625_UNADJUSTED,
+ ColorMode::STANDARD_BT601_525,
+ ColorMode::STANDARD_BT601_525_UNADJUSTED,
+ ColorMode::STANDARD_BT709,
+ ColorMode::DCI_P3,
+ ColorMode::SRGB,
+ ColorMode::ADOBE_RGB,
}};
/* TESTCASE: Tests that the HWC2 can get the color modes for a display. The
- * display must support HAL_COLOR_MODE_NATIVE */
+ * display must support ColorMode::NATIVE */
TEST_F(Hwc2Test, GET_COLOR_MODES)
{
ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
[] (Hwc2Test* test, hwc2_display_t display) {
- std::vector<android_color_mode_t> colorModes;
+ std::vector<ColorMode> colorModes;
ASSERT_NO_FATAL_FAILURE(test->getColorModes(display,
&colorModes));
EXPECT_NE(std::count(colorModes.begin(), colorModes.end(),
- HAL_COLOR_MODE_NATIVE), 0) << "all displays"
- " must support HAL_COLOR_MODE_NATIVE";
+ ColorMode::NATIVE), 0) << "all displays"
+ " must support ColorMode::NATIVE";
}
));
}
@@ -4287,7 +4290,7 @@
TEST_F(Hwc2Test, GET_COLOR_MODES_bad_display)
{
hwc2_display_t display;
- std::vector<android_color_mode_t> colorModes;
+ std::vector<ColorMode> colorModes;
hwc2_error_t err = HWC2_ERROR_NONE;
ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
@@ -4302,7 +4305,7 @@
ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
[] (Hwc2Test* test, hwc2_display_t display) {
- const android_color_mode_t colorMode = HAL_COLOR_MODE_NATIVE;
+ const ColorMode colorMode = ColorMode::NATIVE;
EXPECT_NO_FATAL_FAILURE(test->setColorMode(display, colorMode));
}
@@ -4313,7 +4316,7 @@
TEST_F(Hwc2Test, SET_COLOR_MODES_bad_display)
{
hwc2_display_t display;
- const android_color_mode_t colorMode = HAL_COLOR_MODE_NATIVE;
+ const ColorMode colorMode = ColorMode::NATIVE;
hwc2_error_t err = HWC2_ERROR_NONE;
ASSERT_NO_FATAL_FAILURE(getBadDisplay(&display));
@@ -4328,8 +4331,7 @@
ASSERT_NO_FATAL_FAILURE(setActiveDisplayConfig(
[] (Hwc2Test* test, hwc2_display_t display) {
- const android_color_mode_t colorMode =
- static_cast<android_color_mode_t>(-1);
+ const ColorMode colorMode = static_cast<ColorMode>(-1);
hwc2_error_t err = HWC2_ERROR_NONE;
ASSERT_NO_FATAL_FAILURE(test->setColorMode(display, colorMode,
diff --git a/services/surfaceflinger/tests/unittests/MockComposer.h b/services/surfaceflinger/tests/unittests/MockComposer.h
index 248afcf..acd9b30 100644
--- a/services/surfaceflinger/tests/unittests/MockComposer.h
+++ b/services/surfaceflinger/tests/unittests/MockComposer.h
@@ -39,8 +39,8 @@
using android::hardware::graphics::composer::V2_1::Error;
using android::hardware::graphics::composer::V2_1::IComposer;
using android::hardware::graphics::composer::V2_1::IComposerCallback;
-using android::hardware::graphics::composer::V2_1::IComposerClient;
using android::hardware::graphics::composer::V2_1::Layer;
+using android::hardware::graphics::composer::V2_2::IComposerClient;
class Composer : public Hwc2::Composer {
public:
@@ -73,6 +73,8 @@
MOCK_METHOD2(getDisplayType, Error(Display, IComposerClient::DisplayType*));
MOCK_METHOD2(getDozeSupport, Error(Display, bool*));
MOCK_METHOD5(getHdrCapabilities, Error(Display, std::vector<Hdr>*, float*, float*, float*));
+ MOCK_METHOD2(getPerFrameMetadataKeys,
+ Error(Display, std::vector<IComposerClient::PerFrameMetadataKey>*));
MOCK_METHOD3(getReleaseFences, Error(Display, std::vector<Layer>*, std::vector<int>*));
MOCK_METHOD2(presentDisplay, Error(Display, int*));
MOCK_METHOD2(setActiveConfig, Error(Display, Config));
@@ -95,6 +97,7 @@
MOCK_METHOD3(setLayerColor, Error(Display, Layer, const IComposerClient::Color&));
MOCK_METHOD3(setLayerCompositionType, Error(Display, Layer, IComposerClient::Composition));
MOCK_METHOD3(setLayerDataspace, Error(Display, Layer, Dataspace));
+ MOCK_METHOD3(setLayerHdrMetadata, Error(Display, Layer, const HdrMetadata&));
MOCK_METHOD3(setLayerDisplayFrame, Error(Display, Layer, const IComposerClient::Rect&));
MOCK_METHOD3(setLayerPlaneAlpha, Error(Display, Layer, float));
MOCK_METHOD3(setLayerSidebandStream, Error(Display, Layer, const native_handle_t*));
diff --git a/services/vr/bufferhubd/Android.bp b/services/vr/bufferhubd/Android.bp
new file mode 100644
index 0000000..6009a95
--- /dev/null
+++ b/services/vr/bufferhubd/Android.bp
@@ -0,0 +1,55 @@
+// 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.
+
+sourceFiles = [
+ "buffer_hub.cpp",
+ "bufferhubd.cpp",
+ "consumer_channel.cpp",
+ "producer_channel.cpp",
+ "consumer_queue_channel.cpp",
+ "producer_queue_channel.cpp",
+]
+
+headerLibraries = ["libdvr_headers"]
+
+staticLibraries = [
+ "libperformance",
+ "libbufferhub",
+]
+
+sharedLibraries = [
+ "libbase",
+ "libbinder",
+ "libcutils",
+ "liblog",
+ "libsync",
+ "libutils",
+ "libgui",
+ "libui",
+ "libpdx_default_transport",
+]
+
+cc_binary {
+ srcs: sourceFiles,
+ cflags: [
+ "-DLOG_TAG=\"bufferhubd\"",
+ "-DTRACE=0",
+ "-DATRACE_TAG=ATRACE_TAG_GRAPHICS",
+ ],
+ header_libs: headerLibraries,
+ static_libs: staticLibraries,
+ shared_libs: sharedLibraries,
+ name: "bufferhubd",
+ init_rc: ["bufferhubd.rc"],
+}
diff --git a/services/vr/bufferhubd/Android.mk b/services/vr/bufferhubd/Android.mk
deleted file mode 100644
index 1a99cf4..0000000
--- a/services/vr/bufferhubd/Android.mk
+++ /dev/null
@@ -1,54 +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)
-
-sourceFiles := \
- buffer_hub.cpp \
- bufferhubd.cpp \
- consumer_channel.cpp \
- producer_channel.cpp \
- consumer_queue_channel.cpp \
- producer_queue_channel.cpp \
-
-headerLibraries := \
- libdvr_headers
-
-staticLibraries := \
- libperformance \
- libbufferhub
-
-sharedLibraries := \
- libbase \
- libbinder \
- libcutils \
- liblog \
- libsync \
- libutils \
- libgui \
- libui \
- libpdx_default_transport \
-
-include $(CLEAR_VARS)
-LOCAL_SRC_FILES := $(sourceFiles)
-LOCAL_CFLAGS := -DLOG_TAG=\"bufferhubd\"
-LOCAL_CFLAGS += -DTRACE=0
-LOCAL_CFLAGS += -DATRACE_TAG=ATRACE_TAG_GRAPHICS
-LOCAL_HEADER_LIBRARIES := $(headerLibraries)
-LOCAL_STATIC_LIBRARIES := $(staticLibraries)
-LOCAL_SHARED_LIBRARIES := $(sharedLibraries)
-LOCAL_MODULE := bufferhubd
-LOCAL_INIT_RC := bufferhubd.rc
-include $(BUILD_EXECUTABLE)
-
diff --git a/services/vr/hardware_composer/impl/vr_hwc.cpp b/services/vr/hardware_composer/impl/vr_hwc.cpp
index 180e232..313c022 100644
--- a/services/vr/hardware_composer/impl/vr_hwc.cpp
+++ b/services/vr/hardware_composer/impl/vr_hwc.cpp
@@ -15,6 +15,7 @@
*/
#include "impl/vr_hwc.h"
+#include "android-base/stringprintf.h"
#include <cutils/properties.h>
#include <private/dvr/display_client.h>
#include <ui/Fence.h>
@@ -26,6 +27,7 @@
using namespace android::hardware::graphics::common::V1_0;
using namespace android::hardware::graphics::composer::V2_1;
+using android::base::StringPrintf;
using android::hardware::hidl_handle;
using android::hardware::hidl_string;
using android::hardware::hidl_vec;
@@ -225,6 +227,20 @@
memcpy(color_transform_, matrix, sizeof(color_transform_));
}
+void HwcDisplay::dumpDebugInfo(std::string* result) const {
+ if (!result) {
+ return;
+ }
+ *result += StringPrintf("HwcDisplay: width: %d, height: %d, layers size: %zu, colormode: %d\
+ , config: %d\n", width_, height_, layers_.size(), color_mode_, active_config_);
+ *result += StringPrintf("HwcDisplay buffer metadata: width: %d, height: %d, stride: %d,\
+ layerCount: %d, pixelFormat: %d\n", buffer_metadata_.width, buffer_metadata_.height,
+ buffer_metadata_.stride, buffer_metadata_.layerCount, buffer_metadata_.format);
+ for (const auto& layer : layers_) {
+ layer.dumpDebugInfo(result);
+ }
+}
+
////////////////////////////////////////////////////////////////////////////////
// VrHwcClient
@@ -831,7 +847,19 @@
}
Return<void> VrHwc::dumpDebugInfo(dumpDebugInfo_cb hidl_cb) {
- hidl_cb(hidl_string());
+ std::string result;
+
+ {
+ std::lock_guard<std::mutex> guard(mutex_);
+ result = "\nVrHwc states:\n";
+ for (const auto& pair : displays_) {
+ result += StringPrintf("Display id: %lu\n", (unsigned long)pair.first);
+ pair.second->dumpDebugInfo(&result);
+ }
+ result += "\n";
+ }
+
+ hidl_cb(hidl_string(result));
return Void();
}
@@ -881,5 +909,22 @@
return iter == displays_.end() ? nullptr : iter->second.get();
}
+void HwcLayer::dumpDebugInfo(std::string* result) const {
+ if (!result) {
+ return;
+ }
+ *result += StringPrintf("Layer: composition_type: %d, type: %d, app_id: %d, z_order: %d,\
+ cursor_x: %d, cursor_y: %d, color(rgba): (%d,%d,%d,%d), dataspace: %d, transform: %d,\
+ display_frame(LTRB): (%d,%d,%d,%d), crop(LTRB): (%.1f,%.1f,%.1f,%.1f), blend_mode: %d\n",
+ composition_type, info.type, info.app_id, info.z_order, info.cursor_x, info.cursor_y,
+ info.color.r, info.color.g, info.color.b, info.color.a, info.dataspace, info.transform,
+ info.display_frame.left, info.display_frame.top, info.display_frame.right,
+ info.display_frame.bottom, info.crop.left, info.crop.top, info.crop.right,
+ info.crop.bottom, info.blend_mode);
+ *result += StringPrintf("Layer buffer metadata: width: %d, height: %d, stride: %d, layerCount: %d\
+ , pixelFormat: %d\n", buffer_metadata.width, buffer_metadata.height, buffer_metadata.stride,
+ buffer_metadata.layerCount, buffer_metadata.format);
+}
+
} // namespace dvr
} // namespace android
diff --git a/services/vr/hardware_composer/impl/vr_hwc.h b/services/vr/hardware_composer/impl/vr_hwc.h
index 1c308f2..d5d5f55 100644
--- a/services/vr/hardware_composer/impl/vr_hwc.h
+++ b/services/vr/hardware_composer/impl/vr_hwc.h
@@ -116,6 +116,8 @@
info.id = new_id;
}
+ void dumpDebugInfo(std::string* result) const;
+
Composition composition_type;
ComposerView::ComposerLayer info;
IVrComposerClient::BufferMetadata buffer_metadata;
@@ -163,6 +165,8 @@
int32_t color_transform_hint() const { return color_transform_hint_; }
void SetColorTransform(const float* matrix, int32_t hint);
+ void dumpDebugInfo(std::string* result) const;
+
private:
// The client target buffer and the associated fence.
sp<GraphicBuffer> buffer_;
diff --git a/services/vr/hardware_composer/vr_hwc.rc b/services/vr/hardware_composer/vr_hwc.rc
index 6f930a8..645ab80 100644
--- a/services/vr/hardware_composer/vr_hwc.rc
+++ b/services/vr/hardware_composer/vr_hwc.rc
@@ -3,3 +3,4 @@
user system
group system graphics
onrestart restart surfaceflinger
+ writepid /dev/cpuset/system-background/tasks
diff --git a/vulkan/Android.bp b/vulkan/Android.bp
index 35c6e59..a49b6dd 100644
--- a/vulkan/Android.bp
+++ b/vulkan/Android.bp
@@ -45,6 +45,12 @@
sdk_version: "24",
}
+llndk_library {
+ name: "libvulkan",
+ symbol_file: "libvulkan/libvulkan.map.txt",
+ export_include_dirs: ["include"],
+}
+
subdirs = [
"nulldrv",
"libvulkan",
diff --git a/vulkan/libvulkan/code-generator.tmpl b/vulkan/libvulkan/code-generator.tmpl
index 84644a9..1f4df1e 100644
--- a/vulkan/libvulkan/code-generator.tmpl
+++ b/vulkan/libvulkan/code-generator.tmpl
@@ -983,6 +983,7 @@
{{else if eq $.Name "vkDestroyImage"}}true
{{else if eq $.Name "vkGetPhysicalDeviceProperties"}}true
+ {{else if eq $.Name "vkGetPhysicalDeviceProperties2"}}true
{{else if eq $.Name "vkGetPhysicalDeviceProperties2KHR"}}true
{{end}}
diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp
index a9d473d..8b8b280 100644
--- a/vulkan/libvulkan/driver.cpp
+++ b/vulkan/libvulkan/driver.cpp
@@ -407,6 +407,12 @@
for (uint32_t i = 0; i < ext_count; i++)
FilterExtension(ext_names[i]);
+ // Enable device extensions that contain physical-device commands, so that
+ // vkGetInstanceProcAddr will return those physical-device commands.
+ if (is_instance_) {
+ hook_extensions_.set(ProcHook::KHR_swapchain);
+ }
+
ext_names = extension_filter_.names;
ext_count = extension_filter_.name_count;
@@ -795,7 +801,8 @@
const InstanceData& data = GetData(physicalDevice);
// GPDP2 must be present and enabled on the instance.
- if (!data.driver.GetPhysicalDeviceProperties2KHR)
+ if (!data.driver.GetPhysicalDeviceProperties2KHR &&
+ !data.driver.GetPhysicalDeviceProperties2)
return false;
// Request the android-specific presentation properties via GPDP2
@@ -813,8 +820,12 @@
presentation_properties->pNext = nullptr;
presentation_properties->sharedImage = VK_FALSE;
- data.driver.GetPhysicalDeviceProperties2KHR(physicalDevice,
- &properties);
+ if (data.driver.GetPhysicalDeviceProperties2KHR) {
+ data.driver.GetPhysicalDeviceProperties2KHR(physicalDevice,
+ &properties);
+ } else {
+ data.driver.GetPhysicalDeviceProperties2(physicalDevice, &properties);
+ }
return true;
}
diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp
index 51e3abf..ec98b9f 100644
--- a/vulkan/libvulkan/driver_gen.cpp
+++ b/vulkan/libvulkan/driver_gen.cpp
@@ -494,6 +494,7 @@
INIT_PROC(true, instance, CreateDevice);
INIT_PROC(true, instance, EnumerateDeviceExtensionProperties);
INIT_PROC(false, instance, EnumeratePhysicalDeviceGroups);
+ INIT_PROC(false, instance, GetPhysicalDeviceProperties2);
INIT_PROC_EXT(EXT_debug_report, true, instance, CreateDebugReportCallbackEXT);
INIT_PROC_EXT(EXT_debug_report, true, instance, DestroyDebugReportCallbackEXT);
INIT_PROC_EXT(EXT_debug_report, true, instance, DebugReportMessageEXT);
diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h
index 99dc889..14c3aba 100644
--- a/vulkan/libvulkan/driver_gen.h
+++ b/vulkan/libvulkan/driver_gen.h
@@ -69,6 +69,7 @@
PFN_vkCreateDevice CreateDevice;
PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
PFN_vkEnumeratePhysicalDeviceGroups EnumeratePhysicalDeviceGroups;
+ PFN_vkGetPhysicalDeviceProperties2 GetPhysicalDeviceProperties2;
PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT;
PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallbackEXT;
PFN_vkDebugReportMessageEXT DebugReportMessageEXT;