Merge "Fix external cache and secondary user bugs." into oc-dev
diff --git a/cmds/atrace/Android.bp b/cmds/atrace/Android.bp
index 69ed416..6c5869a 100644
--- a/cmds/atrace/Android.bp
+++ b/cmds/atrace/Android.bp
@@ -18,4 +18,10 @@
],
init_rc: ["atrace.rc"],
+
+ product_variables: {
+ debuggable: {
+ init_rc: ["atrace_userdebug.rc"],
+ },
+ },
}
diff --git a/cmds/atrace/atrace.cpp b/cmds/atrace/atrace.cpp
index 05e1615..6cfbed9 100644
--- a/cmds/atrace/atrace.cpp
+++ b/cmds/atrace/atrace.cpp
@@ -552,7 +552,13 @@
// ignore
continue;
}
+
sp<IBase> interface = interfaceRet;
+ if (interface == nullptr) {
+ // ignore
+ continue;
+ }
+
auto notifyRet = interface->notifySyspropsChanged();
if (!notifyRet.isOk()) {
// ignore
diff --git a/cmds/atrace/atrace_userdebug.rc b/cmds/atrace/atrace_userdebug.rc
new file mode 100644
index 0000000..5fd28e2
--- /dev/null
+++ b/cmds/atrace/atrace_userdebug.rc
@@ -0,0 +1,47 @@
+## Permissions to allow additional system-wide tracing to the kernel trace buffer.
+## The default list of permissions is set in frameworks/native/cmds/atrace/atrace.rc
+
+# Allow the shell group to enable kernel tracepoints:
+
+on post-fs
+ chown root shell /sys/kernel/debug/tracing/events/sync/enable
+ chown root shell /sys/kernel/debug/tracing/events/workqueue/enable
+ chown root shell /sys/kernel/debug/tracing/events/regulator/enable
+ chown root shell /sys/kernel/debug/tracing/events/pagecache/enable
+
+ # irq
+ chown root shell /sys/kernel/debug/tracing/events/irq/enable
+ chown root shell /sys/kernel/debug/tracing/events/ipi/enable
+
+ # disk
+ chown root shell /sys/kernel/debug/tracing/events/f2fs/f2fs_sync_file_enter/enable
+ chown root shell /sys/kernel/debug/tracing/events/f2fs/f2fs_sync_file_exit/enable
+ chown root shell /sys/kernel/debug/tracing/events/f2fs/f2fs_write_begin/enable
+ chown root shell /sys/kernel/debug/tracing/events/f2fs/f2fs_write_end/enable
+ chown root shell /sys/kernel/debug/tracing/events/ext4/ext4_da_write_begin/enable
+ chown root shell /sys/kernel/debug/tracing/events/ext4/ext4_da_write_end/enable
+ chown root shell /sys/kernel/debug/tracing/events/ext4/ext4_sync_file_enter/enable
+ chown root shell /sys/kernel/debug/tracing/events/ext4/ext4_sync_file_exit/enable
+ chown root shell /sys/kernel/debug/tracing/events/block/block_rq_issue/enable
+ chown root shell /sys/kernel/debug/tracing/events/block/block_rq_complete/enable
+
+ chmod 0664 /sys/kernel/debug/tracing/events/sync/enable
+ chmod 0664 /sys/kernel/debug/tracing/events/workqueue/enable
+ chmod 0664 /sys/kernel/debug/tracing/events/regulator/enable
+ chmod 0664 /sys/kernel/debug/tracing/events/pagecache/enable
+
+ # irq
+ chmod 0664 /sys/kernel/debug/tracing/events/irq/enable
+ chmod 0664 /sys/kernel/debug/tracing/events/ipi/enable
+
+ # disk
+ chmod 0664 /sys/kernel/debug/tracing/events/f2fs/f2fs_sync_file_enter/enable
+ chmod 0664 /sys/kernel/debug/tracing/events/f2fs/f2fs_sync_file_exit/enable
+ chmod 0664 /sys/kernel/debug/tracing/events/f2fs/f2fs_write_begin/enable
+ chmod 0664 /sys/kernel/debug/tracing/events/f2fs/f2fs_write_end/enable
+ chmod 0664 /sys/kernel/debug/tracing/events/ext4/ext4_da_write_begin/enable
+ chmod 0664 /sys/kernel/debug/tracing/events/ext4/ext4_da_write_end/enable
+ chmod 0664 /sys/kernel/debug/tracing/events/ext4/ext4_sync_file_enter/enable
+ chmod 0664 /sys/kernel/debug/tracing/events/ext4/ext4_sync_file_exit/enable
+ chmod 0664 /sys/kernel/debug/tracing/events/block/block_rq_issue/enable
+ chmod 0664 /sys/kernel/debug/tracing/events/block/block_rq_complete/enable
diff --git a/cmds/installd/dexopt.cpp b/cmds/installd/dexopt.cpp
index facb189..e9d06d1 100644
--- a/cmds/installd/dexopt.cpp
+++ b/cmds/installd/dexopt.cpp
@@ -177,9 +177,20 @@
return count;
}
+static const char* get_location_from_path(const char* path) {
+ static constexpr char kLocationSeparator = '/';
+ const char *location = strrchr(path, kLocationSeparator);
+ if (location == NULL) {
+ return path;
+ } else {
+ // Skip the separator character.
+ return location + 1;
+ }
+}
+
static void run_dex2oat(int zip_fd, int oat_fd, int input_vdex_fd, int output_vdex_fd, int image_fd,
const char* input_file_name, const char* output_file_name, int swap_fd,
- const char *instruction_set, const char* compiler_filter, bool vm_safe_mode,
+ const char* instruction_set, const char* compiler_filter, bool vm_safe_mode,
bool debuggable, bool post_bootcomplete, int profile_fd, const char* shared_libraries) {
static const unsigned int MAX_INSTRUCTION_SET_LEN = 7;
@@ -189,6 +200,9 @@
return;
}
+ // Get the relative path to the input file.
+ const char* relative_input_file_name = get_location_from_path(input_file_name);
+
char dex2oat_Xms_flag[kPropertyValueMax];
bool have_dex2oat_Xms_flag = get_property("dalvik.vm.dex2oat-Xms", dex2oat_Xms_flag, NULL) > 0;
@@ -279,7 +293,7 @@
char dex2oat_image_fd[arraysize("--app-image-fd=") + MAX_INT_LEN];
sprintf(zip_fd_arg, "--zip-fd=%d", zip_fd);
- sprintf(zip_location_arg, "--zip-location=%s", input_file_name);
+ sprintf(zip_location_arg, "--zip-location=%s", relative_input_file_name);
sprintf(input_vdex_fd_arg, "--input-vdex-fd=%d", input_vdex_fd);
sprintf(output_vdex_fd_arg, "--output-vdex-fd=%d", output_vdex_fd);
sprintf(oat_fd_arg, "--oat-fd=%d", oat_fd);
@@ -341,8 +355,18 @@
sprintf(profile_arg, "--profile-file-fd=%d", profile_fd);
}
+ // Get the directory of the apk to pass as a base classpath directory.
+ char base_dir[arraysize("--classpath-dir=") + PKG_PATH_MAX];
+ std::string apk_dir(input_file_name);
+ unsigned long dir_index = apk_dir.rfind('/');
+ bool has_base_dir = dir_index != std::string::npos;
+ if (has_base_dir) {
+ apk_dir = apk_dir.substr(0, dir_index);
+ sprintf(base_dir, "--classpath-dir=%s", apk_dir.c_str());
+ }
- ALOGV("Running %s in=%s out=%s\n", DEX2OAT_BIN, input_file_name, output_file_name);
+
+ ALOGV("Running %s in=%s out=%s\n", DEX2OAT_BIN, relative_input_file_name, output_file_name);
const char* argv[9 // program name, mandatory arguments and the final NULL
+ (have_dex2oat_isa_variant ? 1 : 0)
@@ -360,6 +384,7 @@
+ dex2oat_flags_count
+ (profile_fd == -1 ? 0 : 1)
+ (shared_libraries != nullptr ? 4 : 0)
+ + (has_base_dir ? 1 : 0)
+ (have_dex2oat_large_app_threshold ? 1 : 0)];
int i = 0;
argv[i++] = DEX2OAT_BIN;
@@ -424,6 +449,9 @@
argv[i++] = RUNTIME_ARG;
argv[i++] = shared_libraries;
}
+ if (has_base_dir) {
+ argv[i++] = base_dir;
+ }
// Do not add after dex2oat_flags, they should override others for debugging.
argv[i] = NULL;
@@ -761,17 +789,6 @@
exit(68); /* only get here on exec failure */
}
-static const char* get_location_from_path(const char* path) {
- static constexpr char kLocationSeparator = '/';
- const char *location = strrchr(path, kLocationSeparator);
- if (location == NULL) {
- return path;
- } else {
- // Skip the separator character.
- return location + 1;
- }
-}
-
bool dump_profiles(int32_t uid, const std::string& pkgname, const char* code_paths) {
std::vector<unique_fd> profile_fds;
unique_fd reference_profile_fd;
@@ -1548,14 +1565,12 @@
_exit(67);
}
- // Pass dex2oat the relative path to the input file.
- const char *input_file_name = get_location_from_path(dex_path);
run_dex2oat(input_fd.get(),
out_oat_fd.get(),
in_vdex_fd.get(),
out_vdex_fd.get(),
image_fd.get(),
- input_file_name,
+ dex_path,
out_oat_path,
swap_fd.get(),
instruction_set,
diff --git a/cmds/installd/otapreopt.cpp b/cmds/installd/otapreopt.cpp
index 78eadf2..ff838ce 100644
--- a/cmds/installd/otapreopt.cpp
+++ b/cmds/installd/otapreopt.cpp
@@ -313,8 +313,7 @@
+ 1 // filter
+ 1 // volume
+ 1 // libs
- + 1 // seinfo
- + 1; // null
+ + 1; // seinfo
if (argc == kV2ArgCount) {
return ReadArgumentsV2(argc, argv, false);
} else {
@@ -789,40 +788,8 @@
return false;
}
- int RunPreopt() {
- if (ShouldSkipPreopt()) {
- return 0;
- }
-
- int dexopt_result = dexopt(package_parameters_.apk_path,
- package_parameters_.uid,
- package_parameters_.pkgName,
- package_parameters_.instruction_set,
- package_parameters_.dexopt_needed,
- package_parameters_.oat_dir,
- package_parameters_.dexopt_flags,
- package_parameters_.compiler_filter,
- package_parameters_.volume_uuid,
- package_parameters_.shared_libraries,
- package_parameters_.se_info);
- if (dexopt_result == 0) {
- return 0;
- }
-
- // If the dexopt failed, we may have a stale boot image from a previous OTA run.
- // Then regenerate and retry.
- if (WEXITSTATUS(dexopt_result) !=
- static_cast<int>(art::dex2oat::ReturnCode::kCreateRuntime)) {
- return dexopt_result;
- }
-
- if (!PrepareBootImage(/* force */ true)) {
- LOG(ERROR) << "Forced boot image creating failed. Original error return was "
- << dexopt_result;
- return dexopt_result;
- }
-
- LOG(WARNING) << "Original dexopt failed, re-trying after boot image was regenerated.";
+ // Run dexopt with the parameters of package_parameters_.
+ int Dexopt() {
return dexopt(package_parameters_.apk_path,
package_parameters_.uid,
package_parameters_.pkgName,
@@ -836,6 +803,43 @@
package_parameters_.se_info);
}
+ int RunPreopt() {
+ if (ShouldSkipPreopt()) {
+ return 0;
+ }
+
+ int dexopt_result = Dexopt();
+ if (dexopt_result == 0) {
+ return 0;
+ }
+
+ // If the dexopt failed, we may have a stale boot image from a previous OTA run.
+ // Then regenerate and retry.
+ if (WEXITSTATUS(dexopt_result) ==
+ static_cast<int>(art::dex2oat::ReturnCode::kCreateRuntime)) {
+ if (!PrepareBootImage(/* force */ true)) {
+ LOG(ERROR) << "Forced boot image creating failed. Original error return was "
+ << dexopt_result;
+ return dexopt_result;
+ }
+
+ int dexopt_result_boot_image_retry = Dexopt();
+ if (dexopt_result_boot_image_retry == 0) {
+ return 0;
+ }
+ }
+
+ // If this was a profile-guided run, we may have profile version issues. Try to downgrade,
+ // if possible.
+ if ((package_parameters_.dexopt_flags & DEXOPT_PROFILE_GUIDED) == 0) {
+ return dexopt_result;
+ }
+
+ LOG(WARNING) << "Downgrading compiler filter in an attempt to progress compilation";
+ package_parameters_.dexopt_flags &= ~DEXOPT_PROFILE_GUIDED;
+ return Dexopt();
+ }
+
////////////////////////////////////
// Helpers, mostly taken from ART //
////////////////////////////////////
diff --git a/cmds/servicemanager/service_manager.c b/cmds/servicemanager/service_manager.c
index 1f56a47..45bb1d0 100644
--- a/cmds/servicemanager/service_manager.c
+++ b/cmds/servicemanager/service_manager.c
@@ -65,11 +65,7 @@
static bool check_mac_perms(pid_t spid, uid_t uid, const char *tctx, const char *perm, const char *name)
{
char *sctx = NULL;
-#ifdef VENDORSERVICEMANAGER
- const char *class = "vndservice_manager";
-#else
const char *class = "service_manager";
-#endif
bool allowed;
struct audit_data ad;
diff --git a/include/gui/IGraphicBufferProducer.h b/include/gui/IGraphicBufferProducer.h
index 5810335..9250806 100644
--- a/include/gui/IGraphicBufferProducer.h
+++ b/include/gui/IGraphicBufferProducer.h
@@ -487,6 +487,7 @@
// is considered a no-op.
//
// Return of a value other than NO_ERROR means an error has occurred:
+ // * NO_INIT - the producer is not connected
// * BAD_VALUE - one of the following has occurred:
// * the api specified does not match the one that was connected
// * api was out of range (see above).
diff --git a/include/ui/Gralloc1.h b/include/ui/Gralloc1.h
deleted file mode 100644
index 90713b3..0000000
--- a/include/ui/Gralloc1.h
+++ /dev/null
@@ -1,295 +0,0 @@
-/*
- * Copyright 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ANDROID_UI_GRALLOC1_H
-#define ANDROID_UI_GRALLOC1_H
-
-#define GRALLOC1_LOG_TAG "Gralloc1"
-
-#include <functional>
-#include <memory>
-#include <unordered_set>
-
-#include <log/log.h>
-
-#include <ui/Fence.h>
-
-#include <hardware/gralloc1.h>
-
-
-namespace std {
- template <>
- struct hash<gralloc1_capability_t> {
- size_t operator()(gralloc1_capability_t capability) const {
- return std::hash<int32_t>()(static_cast<int32_t>(capability));
- }
- };
-}
-
-namespace android {
-class GraphicBuffer;
-class Fence;
-class GraphicBuffer;
-class Gralloc1On0Adapter;
-} // namespace android
-
-
-// This is not an "official" capability (i.e., it is not found in gralloc1.h),
-// but we will use it to detect that we are running through the adapter, which
-// is capable of collaborating with GraphicBuffer such that queries on a
-// buffer_handle_t succeed
-static const auto GRALLOC1_CAPABILITY_ON_ADAPTER =
- static_cast<gralloc1_capability_t>(GRALLOC1_LAST_CAPABILITY + 1);
-
-static const auto GRALLOC1_FUNCTION_RETAIN_GRAPHIC_BUFFER =
- static_cast<gralloc1_function_descriptor_t>(GRALLOC1_LAST_FUNCTION + 1);
-static const auto GRALLOC1_FUNCTION_ALLOCATE_WITH_ID =
- static_cast<gralloc1_function_descriptor_t>(GRALLOC1_LAST_FUNCTION + 2);
-static const auto GRALLOC1_FUNCTION_LOCK_YCBCR =
- static_cast<gralloc1_function_descriptor_t>(GRALLOC1_LAST_FUNCTION + 3);
-static const auto GRALLOC1_LAST_ADAPTER_FUNCTION = GRALLOC1_FUNCTION_LOCK_YCBCR;
-
-typedef gralloc1_error_t (*GRALLOC1_PFN_RETAIN_GRAPHIC_BUFFER)(
- gralloc1_device_t* device, const android::GraphicBuffer* buffer);
-typedef gralloc1_error_t (*GRALLOC1_PFN_ALLOCATE_WITH_ID)(
- gralloc1_device_t* device, gralloc1_buffer_descriptor_t descriptor,
- gralloc1_backing_store_t id, buffer_handle_t* outBuffer);
-typedef int32_t /*gralloc1_error_t*/ (*GRALLOC1_PFN_LOCK_YCBCR)(
- gralloc1_device_t* device, buffer_handle_t buffer,
- uint64_t /*gralloc1_producer_usage_t*/ producerUsage,
- uint64_t /*gralloc1_consumer_usage_t*/ consumerUsage,
- const gralloc1_rect_t* accessRegion, struct android_ycbcr* outYCbCr,
- int32_t acquireFence);
-
-
-namespace android {
-namespace Gralloc1 {
-
-class Device;
-
-class Descriptor {
-public:
- Descriptor(Device& device, gralloc1_buffer_descriptor_t deviceId)
- : mShimDevice(device),
- mDeviceId(deviceId),
- mWidth(0),
- mHeight(0),
- mFormat(static_cast<android_pixel_format_t>(0)),
- mLayerCount(0),
- mProducerUsage(GRALLOC1_PRODUCER_USAGE_NONE),
- mConsumerUsage(GRALLOC1_CONSUMER_USAGE_NONE) {}
-
- ~Descriptor();
-
- gralloc1_buffer_descriptor_t getDeviceId() const { return mDeviceId; }
-
- gralloc1_error_t setDimensions(uint32_t width, uint32_t height);
- gralloc1_error_t setFormat(android_pixel_format_t format);
- gralloc1_error_t setLayerCount(uint32_t layerCount);
- gralloc1_error_t setProducerUsage(gralloc1_producer_usage_t usage);
- gralloc1_error_t setConsumerUsage(gralloc1_consumer_usage_t usage);
-
-private:
- Device& mShimDevice;
- const gralloc1_buffer_descriptor_t mDeviceId;
-
- uint32_t mWidth;
- uint32_t mHeight;
- android_pixel_format_t mFormat;
- uint32_t mLayerCount;
- gralloc1_producer_usage_t mProducerUsage;
- gralloc1_consumer_usage_t mConsumerUsage;
-
-}; // Descriptor
-
-class Device {
- friend class Gralloc1::Descriptor;
-
-public:
- Device(gralloc1_device_t* device);
-
- bool hasCapability(gralloc1_capability_t capability) const;
-
- std::string dump();
-
- std::shared_ptr<Descriptor> createDescriptor();
-
- gralloc1_error_t allocate(
- const std::vector<std::shared_ptr<const Descriptor>>& descriptors,
- std::vector<buffer_handle_t>* outBuffers);
- gralloc1_error_t allocate(
- const std::shared_ptr<const Descriptor>& descriptor,
- gralloc1_backing_store_t id, buffer_handle_t* outBuffer);
-
- gralloc1_error_t retain(buffer_handle_t buffer);
- gralloc1_error_t retain(const GraphicBuffer* buffer);
-
- gralloc1_error_t release(buffer_handle_t buffer);
-
- gralloc1_error_t getDimensions(buffer_handle_t buffer,
- uint32_t* outWidth, uint32_t* outHeight);
- gralloc1_error_t getFormat(buffer_handle_t buffer,
- int32_t* outFormat);
- gralloc1_error_t getLayerCount(buffer_handle_t buffer,
- uint32_t* outLayerCount);
- gralloc1_error_t getProducerUsage(buffer_handle_t buffer,
- uint64_t* outProducerUsage);
- gralloc1_error_t getConsumerUsage(buffer_handle_t buffer,
- uint64_t* outConsumerUsage);
- gralloc1_error_t getBackingStore(buffer_handle_t buffer,
- uint64_t* outBackingStore);
- gralloc1_error_t getStride(buffer_handle_t buffer, uint32_t* outStride);
- gralloc1_error_t getNumFlexPlanes(buffer_handle_t buffer,
- uint32_t* outNumPlanes);
-
- gralloc1_error_t lock(buffer_handle_t buffer,
- gralloc1_producer_usage_t producerUsage,
- gralloc1_consumer_usage_t consumerUsage,
- const gralloc1_rect_t* accessRegion, void** outData,
- const sp<Fence>& acquireFence);
- gralloc1_error_t lockFlex(buffer_handle_t buffer,
- gralloc1_producer_usage_t producerUsage,
- gralloc1_consumer_usage_t consumerUsage,
- const gralloc1_rect_t* accessRegion,
- struct android_flex_layout* outData, const sp<Fence>& acquireFence);
- gralloc1_error_t lockYCbCr(buffer_handle_t buffer,
- gralloc1_producer_usage_t producerUsage,
- gralloc1_consumer_usage_t consumerUsage,
- const gralloc1_rect_t* accessRegion, struct android_ycbcr* outData,
- const sp<Fence>& acquireFence);
-
- gralloc1_error_t unlock(buffer_handle_t buffer, sp<Fence>* outFence);
-
-private:
- std::unordered_set<gralloc1_capability_t> loadCapabilities();
-
- bool loadFunctions();
-
- template <typename LockType, typename OutType>
- gralloc1_error_t lockHelper(LockType pfn, buffer_handle_t buffer,
- gralloc1_producer_usage_t producerUsage,
- gralloc1_consumer_usage_t consumerUsage,
- const gralloc1_rect_t* accessRegion, OutType* outData,
- const sp<Fence>& acquireFence) {
- int32_t intError = pfn(mDevice, buffer,
- static_cast<uint64_t>(producerUsage),
- static_cast<uint64_t>(consumerUsage), accessRegion, outData,
- acquireFence->dup());
- return static_cast<gralloc1_error_t>(intError);
- }
-
- gralloc1_device_t* const mDevice;
-
- const std::unordered_set<gralloc1_capability_t> mCapabilities;
-
- template <typename PFN, gralloc1_function_descriptor_t descriptor>
- struct FunctionLoader {
- FunctionLoader() : pfn(nullptr) {}
-
- bool load(gralloc1_device_t* device, bool errorIfNull) {
- gralloc1_function_pointer_t rawPointer =
- device->getFunction(device, descriptor);
- pfn = reinterpret_cast<PFN>(rawPointer);
- if (errorIfNull && !rawPointer) {
- ALOG(LOG_ERROR, GRALLOC1_LOG_TAG,
- "Failed to load function pointer %d", descriptor);
- }
- return rawPointer != nullptr;
- }
-
- template <typename ...Args>
- typename std::result_of<PFN(Args...)>::type operator()(Args... args) {
- return pfn(args...);
- }
-
- PFN pfn;
- };
-
- // Function pointers
- struct Functions {
- FunctionLoader<GRALLOC1_PFN_DUMP, GRALLOC1_FUNCTION_DUMP> dump;
- FunctionLoader<GRALLOC1_PFN_CREATE_DESCRIPTOR,
- GRALLOC1_FUNCTION_CREATE_DESCRIPTOR> createDescriptor;
- FunctionLoader<GRALLOC1_PFN_DESTROY_DESCRIPTOR,
- GRALLOC1_FUNCTION_DESTROY_DESCRIPTOR> destroyDescriptor;
- FunctionLoader<GRALLOC1_PFN_SET_CONSUMER_USAGE,
- GRALLOC1_FUNCTION_SET_CONSUMER_USAGE> setConsumerUsage;
- FunctionLoader<GRALLOC1_PFN_SET_DIMENSIONS,
- GRALLOC1_FUNCTION_SET_DIMENSIONS> setDimensions;
- FunctionLoader<GRALLOC1_PFN_SET_FORMAT,
- GRALLOC1_FUNCTION_SET_FORMAT> setFormat;
- FunctionLoader<GRALLOC1_PFN_SET_LAYER_COUNT,
- GRALLOC1_FUNCTION_SET_LAYER_COUNT> setLayerCount;
- FunctionLoader<GRALLOC1_PFN_SET_PRODUCER_USAGE,
- GRALLOC1_FUNCTION_SET_PRODUCER_USAGE> setProducerUsage;
- FunctionLoader<GRALLOC1_PFN_GET_BACKING_STORE,
- GRALLOC1_FUNCTION_GET_BACKING_STORE> getBackingStore;
- FunctionLoader<GRALLOC1_PFN_GET_CONSUMER_USAGE,
- GRALLOC1_FUNCTION_GET_CONSUMER_USAGE> getConsumerUsage;
- FunctionLoader<GRALLOC1_PFN_GET_DIMENSIONS,
- GRALLOC1_FUNCTION_GET_DIMENSIONS> getDimensions;
- FunctionLoader<GRALLOC1_PFN_GET_FORMAT,
- GRALLOC1_FUNCTION_GET_FORMAT> getFormat;
- FunctionLoader<GRALLOC1_PFN_GET_LAYER_COUNT,
- GRALLOC1_FUNCTION_GET_LAYER_COUNT> getLayerCount;
- FunctionLoader<GRALLOC1_PFN_GET_PRODUCER_USAGE,
- GRALLOC1_FUNCTION_GET_PRODUCER_USAGE> getProducerUsage;
- FunctionLoader<GRALLOC1_PFN_GET_STRIDE,
- GRALLOC1_FUNCTION_GET_STRIDE> getStride;
- FunctionLoader<GRALLOC1_PFN_ALLOCATE,
- GRALLOC1_FUNCTION_ALLOCATE> allocate;
- FunctionLoader<GRALLOC1_PFN_RETAIN,
- GRALLOC1_FUNCTION_RETAIN> retain;
- FunctionLoader<GRALLOC1_PFN_RELEASE,
- GRALLOC1_FUNCTION_RELEASE> release;
- FunctionLoader<GRALLOC1_PFN_GET_NUM_FLEX_PLANES,
- GRALLOC1_FUNCTION_GET_NUM_FLEX_PLANES> getNumFlexPlanes;
- FunctionLoader<GRALLOC1_PFN_LOCK,
- GRALLOC1_FUNCTION_LOCK> lock;
- FunctionLoader<GRALLOC1_PFN_LOCK_FLEX,
- GRALLOC1_FUNCTION_LOCK_FLEX> lockFlex;
- FunctionLoader<GRALLOC1_PFN_LOCK_YCBCR,
- GRALLOC1_FUNCTION_LOCK_YCBCR> lockYCbCr;
- FunctionLoader<GRALLOC1_PFN_UNLOCK,
- GRALLOC1_FUNCTION_UNLOCK> unlock;
-
- // Adapter-only functions
- FunctionLoader<GRALLOC1_PFN_RETAIN_GRAPHIC_BUFFER,
- GRALLOC1_FUNCTION_RETAIN_GRAPHIC_BUFFER> retainGraphicBuffer;
- FunctionLoader<GRALLOC1_PFN_ALLOCATE_WITH_ID,
- GRALLOC1_FUNCTION_ALLOCATE_WITH_ID> allocateWithId;
- } mFunctions;
-
-}; // class android::Gralloc1::Device
-
-class Loader
-{
-public:
- Loader();
- ~Loader();
-
- std::unique_ptr<Device> getDevice();
-
-private:
- static std::unique_ptr<Gralloc1On0Adapter> mAdapter;
- std::unique_ptr<Device> mDevice;
-};
-
-} // namespace android::Gralloc1
-
-} // namespace android
-
-#endif
diff --git a/include/ui/Gralloc1On0Adapter.h b/include/ui/Gralloc1On0Adapter.h
deleted file mode 100644
index 6379a08..0000000
--- a/include/ui/Gralloc1On0Adapter.h
+++ /dev/null
@@ -1,478 +0,0 @@
-/*
- * Copyright 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ANDROID_UI_GRALLOC_1_ON_0_ADAPTER_H
-#define ANDROID_UI_GRALLOC_1_ON_0_ADAPTER_H
-
-#include <log/log.h>
-
-#include <ui/Fence.h>
-
-#include <hardware/gralloc.h>
-#include <hardware/gralloc1.h>
-
-#include <mutex>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-namespace android {
-class GraphicBuffer;
-} // namespace android
-
-struct gralloc_module_t;
-
-namespace android {
-
-class Gralloc1On0Adapter : public gralloc1_device_t
-{
-public:
- Gralloc1On0Adapter(const hw_module_t* module);
- ~Gralloc1On0Adapter();
-
- gralloc1_device_t* getDevice() {
- return static_cast<gralloc1_device_t*>(this);
- }
-
-private:
- static inline Gralloc1On0Adapter* getAdapter(gralloc1_device_t* device) {
- return static_cast<Gralloc1On0Adapter*>(device);
- }
-
- // getCapabilities
-
- void doGetCapabilities(uint32_t* outCount,
- int32_t* /*gralloc1_capability_t*/ outCapabilities);
- static void getCapabilitiesHook(gralloc1_device_t* device,
- uint32_t* outCount,
- int32_t* /*gralloc1_capability_t*/ outCapabilities) {
- getAdapter(device)->doGetCapabilities(outCount, outCapabilities);
- }
-
- // getFunction
-
- gralloc1_function_pointer_t doGetFunction(
- int32_t /*gralloc1_function_descriptor_t*/ descriptor);
- static gralloc1_function_pointer_t getFunctionHook(
- gralloc1_device_t* device,
- int32_t /*gralloc1_function_descriptor_t*/ descriptor) {
- return getAdapter(device)->doGetFunction(descriptor);
- }
-
- // dump
-
- void dump(uint32_t* outSize, char* outBuffer);
- static void dumpHook(gralloc1_device_t* device, uint32_t* outSize,
- char* outBuffer) {
- return getAdapter(device)->dump(outSize, outBuffer);
- }
- std::string mCachedDump;
-
- // Buffer descriptor lifecycle functions
-
- struct Descriptor;
-
- gralloc1_error_t createDescriptor(
- gralloc1_buffer_descriptor_t* outDescriptor);
- static int32_t createDescriptorHook(gralloc1_device_t* device,
- gralloc1_buffer_descriptor_t* outDescriptor) {
- auto error = getAdapter(device)->createDescriptor(outDescriptor);
- return static_cast<int32_t>(error);
- }
-
- gralloc1_error_t destroyDescriptor(gralloc1_buffer_descriptor_t descriptor);
- static int32_t destroyDescriptorHook(gralloc1_device_t* device,
- gralloc1_buffer_descriptor_t descriptor) {
- auto error = getAdapter(device)->destroyDescriptor(descriptor);
- return static_cast<int32_t>(error);
- }
-
- // Buffer descriptor modification functions
-
- struct Descriptor : public std::enable_shared_from_this<Descriptor> {
- Descriptor(Gralloc1On0Adapter* _adapter,
- gralloc1_buffer_descriptor_t _id)
- : adapter(_adapter),
- id(_id),
- width(0),
- height(0),
- format(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED),
- layerCount(1),
- producerUsage(GRALLOC1_PRODUCER_USAGE_NONE),
- consumerUsage(GRALLOC1_CONSUMER_USAGE_NONE) {}
-
- gralloc1_error_t setDimensions(uint32_t w, uint32_t h) {
- width = w;
- height = h;
- return GRALLOC1_ERROR_NONE;
- }
-
- gralloc1_error_t setFormat(int32_t f) {
- format = f;
- return GRALLOC1_ERROR_NONE;
- }
-
- gralloc1_error_t setLayerCount(uint32_t lc) {
- layerCount = lc;
- return GRALLOC1_ERROR_NONE;
- }
-
- gralloc1_error_t setProducerUsage(gralloc1_producer_usage_t usage) {
- producerUsage = usage;
- return GRALLOC1_ERROR_NONE;
- }
-
- gralloc1_error_t setConsumerUsage(gralloc1_consumer_usage_t usage) {
- consumerUsage = usage;
- return GRALLOC1_ERROR_NONE;
- }
-
- Gralloc1On0Adapter* const adapter;
- const gralloc1_buffer_descriptor_t id;
-
- uint32_t width;
- uint32_t height;
- int32_t format;
- uint32_t layerCount;
- gralloc1_producer_usage_t producerUsage;
- gralloc1_consumer_usage_t consumerUsage;
- };
-
- template <typename ...Args>
- static int32_t callDescriptorFunction(gralloc1_device_t* device,
- gralloc1_buffer_descriptor_t descriptorId,
- gralloc1_error_t (Descriptor::*member)(Args...), Args... args) {
- auto descriptor = getAdapter(device)->getDescriptor(descriptorId);
- if (!descriptor) {
- return static_cast<int32_t>(GRALLOC1_ERROR_BAD_DESCRIPTOR);
- }
- auto error = ((*descriptor).*member)(std::forward<Args>(args)...);
- return static_cast<int32_t>(error);
- }
-
- static int32_t setConsumerUsageHook(gralloc1_device_t* device,
- gralloc1_buffer_descriptor_t descriptorId, uint64_t intUsage) {
- auto usage = static_cast<gralloc1_consumer_usage_t>(intUsage);
- return callDescriptorFunction(device, descriptorId,
- &Descriptor::setConsumerUsage, usage);
- }
-
- static int32_t setDimensionsHook(gralloc1_device_t* device,
- gralloc1_buffer_descriptor_t descriptorId, uint32_t width,
- uint32_t height) {
- return callDescriptorFunction(device, descriptorId,
- &Descriptor::setDimensions, width, height);
- }
-
- static int32_t setFormatHook(gralloc1_device_t* device,
- gralloc1_buffer_descriptor_t descriptorId, int32_t format) {
- return callDescriptorFunction(device, descriptorId,
- &Descriptor::setFormat, format);
- }
-
- static int32_t setLayerCountHook(gralloc1_device_t* device,
- gralloc1_buffer_descriptor_t descriptorId, uint32_t layerCount) {
- return callDescriptorFunction(device, descriptorId,
- &Descriptor::setLayerCount, layerCount);
- }
-
- static int32_t setProducerUsageHook(gralloc1_device_t* device,
- gralloc1_buffer_descriptor_t descriptorId, uint64_t intUsage) {
- auto usage = static_cast<gralloc1_producer_usage_t>(intUsage);
- return callDescriptorFunction(device, descriptorId,
- &Descriptor::setProducerUsage, usage);
- }
-
- // Buffer handle query functions
-
- class Buffer {
- public:
- Buffer(buffer_handle_t handle, gralloc1_backing_store_t store,
- const Descriptor& descriptor, uint32_t stride,
- bool wasAllocated);
-
- buffer_handle_t getHandle() const { return mHandle; }
-
- void retain() { ++mReferenceCount; }
-
- // Returns true if the reference count has dropped to 0, indicating that
- // the buffer needs to be released
- bool release() { return --mReferenceCount == 0; }
-
- bool wasAllocated() const { return mWasAllocated; }
-
- gralloc1_error_t getBackingStore(
- gralloc1_backing_store_t* outStore) const {
- *outStore = mStore;
- return GRALLOC1_ERROR_NONE;
- }
-
- gralloc1_error_t getConsumerUsage(
- gralloc1_consumer_usage_t* outUsage) const {
- *outUsage = mDescriptor.consumerUsage;
- return GRALLOC1_ERROR_NONE;
- }
-
- gralloc1_error_t getDimensions(uint32_t* outWidth,
- uint32_t* outHeight) const {
- *outWidth = mDescriptor.width;
- *outHeight = mDescriptor.height;
- return GRALLOC1_ERROR_NONE;
- }
-
- gralloc1_error_t getFormat(int32_t* outFormat) const {
- *outFormat = mDescriptor.format;
- return GRALLOC1_ERROR_NONE;
- }
-
- gralloc1_error_t getLayerCount(uint32_t* outLayerCount) const {
- *outLayerCount = mDescriptor.layerCount;
- return GRALLOC1_ERROR_NONE;
- }
-
- gralloc1_error_t getNumFlexPlanes(uint32_t* outNumPlanes) const {
- // TODO: This is conservative, and we could do better by examining
- // the format, but it won't hurt anything for now
- *outNumPlanes = 4;
- return GRALLOC1_ERROR_NONE;
- }
-
- gralloc1_error_t getProducerUsage(
- gralloc1_producer_usage_t* outUsage) const {
- *outUsage = mDescriptor.producerUsage;
- return GRALLOC1_ERROR_NONE;
- }
-
- gralloc1_error_t getStride(uint32_t* outStride) const {
- *outStride = mStride;
- return GRALLOC1_ERROR_NONE;
- }
-
- private:
-
- const buffer_handle_t mHandle;
- size_t mReferenceCount;
-
- // Since we're adapting to gralloc0, there will always be a 1:1
- // correspondence between buffer handles and backing stores, and the
- // backing store ID will be the same as the GraphicBuffer unique ID
- const gralloc1_backing_store_t mStore;
-
- const Descriptor mDescriptor;
- const uint32_t mStride;
-
- // Whether this buffer allocated in this process (as opposed to just
- // being retained here), which determines whether to free or unregister
- // the buffer when this Buffer is released
- const bool mWasAllocated;
- };
-
- template <typename ...Args>
- static int32_t callBufferFunction(gralloc1_device_t* device,
- buffer_handle_t bufferHandle,
- gralloc1_error_t (Buffer::*member)(Args...) const, Args... args) {
- auto buffer = getAdapter(device)->getBuffer(bufferHandle);
- if (!buffer) {
- return static_cast<int32_t>(GRALLOC1_ERROR_BAD_HANDLE);
- }
- auto error = ((*buffer).*member)(std::forward<Args>(args)...);
- return static_cast<int32_t>(error);
- }
-
- template <typename MF, MF memFunc, typename ...Args>
- static int32_t bufferHook(gralloc1_device_t* device,
- buffer_handle_t bufferHandle, Args... args) {
- return Gralloc1On0Adapter::callBufferFunction(device, bufferHandle,
- memFunc, std::forward<Args>(args)...);
- }
-
- static int32_t getConsumerUsageHook(gralloc1_device_t* device,
- buffer_handle_t bufferHandle, uint64_t* outUsage) {
- auto usage = GRALLOC1_CONSUMER_USAGE_NONE;
- auto error = callBufferFunction(device, bufferHandle,
- &Buffer::getConsumerUsage, &usage);
- if (error == GRALLOC1_ERROR_NONE) {
- *outUsage = static_cast<uint64_t>(usage);
- }
- return error;
- }
-
- static int32_t getProducerUsageHook(gralloc1_device_t* device,
- buffer_handle_t bufferHandle, uint64_t* outUsage) {
- auto usage = GRALLOC1_PRODUCER_USAGE_NONE;
- auto error = callBufferFunction(device, bufferHandle,
- &Buffer::getProducerUsage, &usage);
- if (error == GRALLOC1_ERROR_NONE) {
- *outUsage = static_cast<uint64_t>(usage);
- }
- return error;
- }
-
- // Buffer management functions
-
- // We don't provide GRALLOC1_FUNCTION_ALLOCATE, since this should always be
- // called through GRALLOC1_FUNCTION_ALLOCATE_WITH_ID
- gralloc1_error_t allocate(
- const std::shared_ptr<Descriptor>& descriptor,
- gralloc1_backing_store_t id,
- buffer_handle_t* outBufferHandle);
- static gralloc1_error_t allocateWithIdHook(gralloc1_device_t* device,
- gralloc1_buffer_descriptor_t descriptors,
- gralloc1_backing_store_t id, buffer_handle_t* outBuffer);
-
- gralloc1_error_t retain(const std::shared_ptr<Buffer>& buffer);
- gralloc1_error_t release(const std::shared_ptr<Buffer>& buffer);
-
- // Member function pointer 'member' will either be retain or release
- template <gralloc1_error_t (Gralloc1On0Adapter::*member)(
- const std::shared_ptr<Buffer>& buffer)>
- static int32_t managementHook(gralloc1_device_t* device,
- buffer_handle_t bufferHandle) {
- auto adapter = getAdapter(device);
-
- auto buffer = adapter->getBuffer(bufferHandle);
- if (!buffer) {
- return static_cast<int32_t>(GRALLOC1_ERROR_BAD_HANDLE);
- }
-
- auto error = ((*adapter).*member)(buffer);
- return static_cast<int32_t>(error);
- }
-
- gralloc1_error_t retain(const GraphicBuffer* buffer);
- static gralloc1_error_t retainGraphicBufferHook(gralloc1_device_t* device,
- const GraphicBuffer* buffer) {
- auto adapter = getAdapter(device);
- return adapter->retain(buffer);
- }
-
- // Buffer access functions
-
- gralloc1_error_t lock(const std::shared_ptr<Buffer>& buffer,
- gralloc1_producer_usage_t producerUsage,
- gralloc1_consumer_usage_t consumerUsage,
- const gralloc1_rect_t& accessRegion, void** outData,
- const sp<Fence>& acquireFence);
- gralloc1_error_t lockFlex(const std::shared_ptr<Buffer>& buffer,
- gralloc1_producer_usage_t producerUsage,
- gralloc1_consumer_usage_t consumerUsage,
- const gralloc1_rect_t& accessRegion,
- struct android_flex_layout* outFlex,
- const sp<Fence>& acquireFence);
- gralloc1_error_t lockYCbCr(const std::shared_ptr<Buffer>& buffer,
- gralloc1_producer_usage_t producerUsage,
- gralloc1_consumer_usage_t consumerUsage,
- const gralloc1_rect_t& accessRegion,
- struct android_ycbcr* outFlex,
- const sp<Fence>& acquireFence);
-
- template <typename OUT, gralloc1_error_t (Gralloc1On0Adapter::*member)(
- const std::shared_ptr<Buffer>&, gralloc1_producer_usage_t,
- gralloc1_consumer_usage_t, const gralloc1_rect_t&, OUT*,
- const sp<Fence>&)>
- static int32_t lockHook(gralloc1_device_t* device,
- buffer_handle_t bufferHandle,
- uint64_t /*gralloc1_producer_usage_t*/ uintProducerUsage,
- uint64_t /*gralloc1_consumer_usage_t*/ uintConsumerUsage,
- const gralloc1_rect_t* accessRegion, OUT* outData,
- int32_t acquireFenceFd) {
- auto adapter = getAdapter(device);
-
- // Exactly one of producer and consumer usage must be *_USAGE_NONE,
- // but we can't check this until the upper levels of the framework
- // correctly distinguish between producer and consumer usage
- /*
- bool hasProducerUsage =
- uintProducerUsage != GRALLOC1_PRODUCER_USAGE_NONE;
- bool hasConsumerUsage =
- uintConsumerUsage != GRALLOC1_CONSUMER_USAGE_NONE;
- if (hasProducerUsage && hasConsumerUsage ||
- !hasProducerUsage && !hasConsumerUsage) {
- return static_cast<int32_t>(GRALLOC1_ERROR_BAD_VALUE);
- }
- */
-
- auto producerUsage =
- static_cast<gralloc1_producer_usage_t>(uintProducerUsage);
- auto consumerUsage =
- static_cast<gralloc1_consumer_usage_t>(uintConsumerUsage);
-
- if (!outData) {
- const auto producerCpuUsage = GRALLOC1_PRODUCER_USAGE_CPU_READ |
- GRALLOC1_PRODUCER_USAGE_CPU_WRITE;
- if ((producerUsage & producerCpuUsage) != 0) {
- return static_cast<int32_t>(GRALLOC1_ERROR_BAD_VALUE);
- }
- if ((consumerUsage & GRALLOC1_CONSUMER_USAGE_CPU_READ) != 0) {
- return static_cast<int32_t>(GRALLOC1_ERROR_BAD_VALUE);
- }
- }
-
- auto buffer = adapter->getBuffer(bufferHandle);
- if (!buffer) {
- return static_cast<int32_t>(GRALLOC1_ERROR_BAD_HANDLE);
- }
-
- if (!accessRegion) {
- ALOGE("accessRegion is null");
- return static_cast<int32_t>(GRALLOC1_ERROR_BAD_VALUE);
- }
-
- sp<Fence> acquireFence{new Fence(acquireFenceFd)};
- auto error = ((*adapter).*member)(buffer, producerUsage, consumerUsage,
- *accessRegion, outData, acquireFence);
- return static_cast<int32_t>(error);
- }
-
- gralloc1_error_t unlock(const std::shared_ptr<Buffer>& buffer,
- sp<Fence>* outReleaseFence);
- static int32_t unlockHook(gralloc1_device_t* device,
- buffer_handle_t bufferHandle, int32_t* outReleaseFenceFd) {
- auto adapter = getAdapter(device);
-
- auto buffer = adapter->getBuffer(bufferHandle);
- if (!buffer) {
- return static_cast<int32_t>(GRALLOC1_ERROR_BAD_HANDLE);
- }
-
- sp<Fence> releaseFence = Fence::NO_FENCE;
- auto error = adapter->unlock(buffer, &releaseFence);
- if (error == GRALLOC1_ERROR_NONE) {
- *outReleaseFenceFd = releaseFence->dup();
- }
- return static_cast<int32_t>(error);
- }
-
- // Adapter internals
- const gralloc_module_t* mModule;
- uint8_t mMinorVersion;
- alloc_device_t* mDevice;
-
- std::shared_ptr<Descriptor> getDescriptor(
- gralloc1_buffer_descriptor_t descriptorId);
- std::shared_ptr<Buffer> getBuffer(buffer_handle_t bufferHandle);
-
- static std::atomic<gralloc1_buffer_descriptor_t> sNextBufferDescriptorId;
- std::mutex mDescriptorMutex;
- std::unordered_map<gralloc1_buffer_descriptor_t,
- std::shared_ptr<Descriptor>> mDescriptors;
- std::mutex mBufferMutex;
- std::unordered_map<buffer_handle_t, std::shared_ptr<Buffer>> mBuffers;
-};
-
-} // namespace android
-
-#endif
diff --git a/include/ui/Gralloc2.h b/include/ui/Gralloc2.h
index c59d327..f826b92 100644
--- a/include/ui/Gralloc2.h
+++ b/include/ui/Gralloc2.h
@@ -41,9 +41,6 @@
public:
Mapper();
- // this will be removed and Mapper will be always valid
- bool valid() const { return (mMapper != nullptr); }
-
Error createDescriptor(
const IMapper::BufferDescriptorInfo& descriptorInfo,
BufferDescriptor* outDescriptor) const;
@@ -84,9 +81,6 @@
// time.
Allocator(const Mapper& mapper);
- // this will be removed and Allocator will be always valid
- bool valid() const { return (mAllocator != nullptr); }
-
std::string dumpDebugInfo() const;
/*
diff --git a/include/ui/GraphicBufferAllocator.h b/include/ui/GraphicBufferAllocator.h
index 95eb8fd..c4cbfc4 100644
--- a/include/ui/GraphicBufferAllocator.h
+++ b/include/ui/GraphicBufferAllocator.h
@@ -25,14 +25,15 @@
#include <cutils/native_handle.h>
+#include <system/window.h>
+
+#include <ui/PixelFormat.h>
+
#include <utils/Errors.h>
#include <utils/KeyedVector.h>
#include <utils/Mutex.h>
#include <utils/Singleton.h>
-#include <ui/Gralloc1.h>
-#include <ui/PixelFormat.h>
-
namespace android {
namespace Gralloc2 {
@@ -45,25 +46,6 @@
class GraphicBufferAllocator : public Singleton<GraphicBufferAllocator>
{
public:
- enum {
- USAGE_SW_READ_NEVER = GRALLOC1_CONSUMER_USAGE_CPU_READ_NEVER,
- USAGE_SW_READ_RARELY = GRALLOC1_CONSUMER_USAGE_CPU_READ,
- USAGE_SW_READ_OFTEN = GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN,
- USAGE_SW_READ_MASK = GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN,
-
- USAGE_SW_WRITE_NEVER = GRALLOC1_PRODUCER_USAGE_CPU_WRITE_NEVER,
- USAGE_SW_WRITE_RARELY = GRALLOC1_PRODUCER_USAGE_CPU_WRITE,
- USAGE_SW_WRITE_OFTEN = GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN,
- USAGE_SW_WRITE_MASK = GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN,
-
- USAGE_SOFTWARE_MASK = USAGE_SW_READ_MASK|USAGE_SW_WRITE_MASK,
-
- USAGE_HW_TEXTURE = GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE,
- USAGE_HW_RENDER = GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET,
- USAGE_HW_2D = 0x00000400, // Deprecated
- USAGE_HW_MASK = 0x00071F00, // Deprecated
- };
-
static inline GraphicBufferAllocator& get() { return getInstance(); }
status_t allocate(uint32_t w, uint32_t h, PixelFormat format,
@@ -98,9 +80,6 @@
GraphicBufferMapper& mMapper;
const std::unique_ptr<const Gralloc2::Allocator> mAllocator;
-
- std::unique_ptr<Gralloc1::Loader> mLoader;
- std::unique_ptr<Gralloc1::Device> mDevice;
};
// ---------------------------------------------------------------------------
diff --git a/include/ui/GraphicBufferMapper.h b/include/ui/GraphicBufferMapper.h
index d69f8fc..e0702e9 100644
--- a/include/ui/GraphicBufferMapper.h
+++ b/include/ui/GraphicBufferMapper.h
@@ -22,8 +22,6 @@
#include <memory>
-#include <ui/Gralloc1.h>
-
#include <utils/Singleton.h>
@@ -52,9 +50,6 @@
status_t importBuffer(buffer_handle_t rawHandle,
buffer_handle_t* outHandle);
- // This is temporary and will be removed soon
- status_t importBuffer(const GraphicBuffer* buffer);
-
status_t freeBuffer(buffer_handle_t handle);
status_t lock(buffer_handle_t handle,
@@ -89,9 +84,6 @@
GraphicBufferMapper();
const std::unique_ptr<const Gralloc2::Mapper> mMapper;
-
- std::unique_ptr<Gralloc1::Loader> mLoader;
- std::unique_ptr<Gralloc1::Device> mDevice;
};
// ---------------------------------------------------------------------------
diff --git a/libs/gui/BufferQueueProducer.cpp b/libs/gui/BufferQueueProducer.cpp
index a540ab9..49552dc 100644
--- a/libs/gui/BufferQueueProducer.cpp
+++ b/libs/gui/BufferQueueProducer.cpp
@@ -1267,7 +1267,10 @@
mCore->mSidebandStream.clear();
mCore->mDequeueCondition.broadcast();
listener = mCore->mConsumerListener;
- } else if (mCore->mConnectedApi != BufferQueueCore::NO_CONNECTED_API) {
+ } else if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) {
+ BQ_LOGE("disconnect: not connected (req=%d)", api);
+ status = NO_INIT;
+ } else {
BQ_LOGE("disconnect: still connected to another API "
"(cur=%d req=%d)", mCore->mConnectedApi, api);
status = BAD_VALUE;
diff --git a/libs/gui/tests/BufferQueue_test.cpp b/libs/gui/tests/BufferQueue_test.cpp
index 893c0a6..60c1277 100644
--- a/libs/gui/tests/BufferQueue_test.cpp
+++ b/libs/gui/tests/BufferQueue_test.cpp
@@ -1181,4 +1181,21 @@
ASSERT_NE(nullptr, item.mGraphicBuffer.get());
}
+TEST_F(BufferQueueTest, TestProducerConnectDisconnect) {
+ createBufferQueue();
+ sp<DummyConsumer> dc(new DummyConsumer);
+ ASSERT_EQ(OK, mConsumer->consumerConnect(dc, true));
+ IGraphicBufferProducer::QueueBufferOutput output;
+ sp<IProducerListener> dummyListener(new DummyProducerListener);
+ ASSERT_EQ(NO_INIT, mProducer->disconnect(NATIVE_WINDOW_API_CPU));
+ ASSERT_EQ(OK, mProducer->connect(
+ dummyListener, NATIVE_WINDOW_API_CPU, true, &output));
+ ASSERT_EQ(BAD_VALUE, mProducer->connect(
+ dummyListener, NATIVE_WINDOW_API_MEDIA, true, &output));
+
+ ASSERT_EQ(BAD_VALUE, mProducer->disconnect(NATIVE_WINDOW_API_MEDIA));
+ ASSERT_EQ(OK, mProducer->disconnect(NATIVE_WINDOW_API_CPU));
+ ASSERT_EQ(NO_INIT, mProducer->disconnect(NATIVE_WINDOW_API_CPU));
+}
+
} // namespace android
diff --git a/libs/nativewindow/AHardwareBuffer.cpp b/libs/nativewindow/AHardwareBuffer.cpp
index 35b76c7..cf028dd 100644
--- a/libs/nativewindow/AHardwareBuffer.cpp
+++ b/libs/nativewindow/AHardwareBuffer.cpp
@@ -358,8 +358,8 @@
case HAL_PIXEL_FORMAT_RGBX_8888: return AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM;
case HAL_PIXEL_FORMAT_RGB_565: return AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM;
case HAL_PIXEL_FORMAT_RGB_888: return AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM;
- case HAL_PIXEL_FORMAT_RGBA_FP16: return AHARDWAREBUFFER_FORMAT_R16G16B16A16_SFLOAT;
- case HAL_PIXEL_FORMAT_RGBA_1010102: return AHARDWAREBUFFER_FORMAT_A2R10G10B10_UNORM_PACK32;
+ case HAL_PIXEL_FORMAT_RGBA_FP16: return AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT;
+ case HAL_PIXEL_FORMAT_RGBA_1010102: return AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM;
case HAL_PIXEL_FORMAT_BLOB: return AHARDWAREBUFFER_FORMAT_BLOB;
default:ALOGE("Unknown pixel format %u", format);
return 0;
@@ -372,8 +372,8 @@
case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM: return HAL_PIXEL_FORMAT_RGBX_8888;
case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM: return HAL_PIXEL_FORMAT_RGB_565;
case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM: return HAL_PIXEL_FORMAT_RGB_888;
- case AHARDWAREBUFFER_FORMAT_R16G16B16A16_SFLOAT: return HAL_PIXEL_FORMAT_RGBA_FP16;
- case AHARDWAREBUFFER_FORMAT_A2R10G10B10_UNORM_PACK32: return HAL_PIXEL_FORMAT_RGBA_1010102;
+ case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT: return HAL_PIXEL_FORMAT_RGBA_FP16;
+ case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM: return HAL_PIXEL_FORMAT_RGBA_1010102;
case AHARDWAREBUFFER_FORMAT_BLOB: return HAL_PIXEL_FORMAT_BLOB;
default:ALOGE("Unknown AHardwareBuffer format %u", format);
return 0;
diff --git a/libs/nativewindow/include/android/hardware_buffer.h b/libs/nativewindow/include/android/hardware_buffer.h
index 02838d4..f5657ff 100644
--- a/libs/nativewindow/include/android/hardware_buffer.h
+++ b/libs/nativewindow/include/android/hardware_buffer.h
@@ -66,14 +66,14 @@
* Vulkan: VK_FORMAT_R16G16B16A16_SFLOAT
* OpenGL ES: GL_RGBA16F
*/
- AHARDWAREBUFFER_FORMAT_R16G16B16A16_SFLOAT = 0x16,
+ AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT = 0x16,
/**
* Corresponding formats:
- * Vulkan: VK_FORMAT_A2R10G10B10_UNORM_PACK32
+ * Vulkan: VK_FORMAT_A2B10G10R10_UNORM_PACK32
* OpenGL ES: GL_RGB10_A2
*/
- AHARDWAREBUFFER_FORMAT_A2R10G10B10_UNORM_PACK32 = 0x2b,
+ AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM = 0x2b,
/**
* An opaque binary blob format that must have height 1, with width equal to
diff --git a/libs/ui/Android.bp b/libs/ui/Android.bp
index ba37391..5ccf178 100644
--- a/libs/ui/Android.bp
+++ b/libs/ui/Android.bp
@@ -49,8 +49,6 @@
"Fence.cpp",
"FenceTime.cpp",
"FrameStats.cpp",
- "Gralloc1.cpp",
- "Gralloc1On0Adapter.cpp",
"Gralloc2.cpp",
"GraphicBuffer.cpp",
"GraphicBufferAllocator.cpp",
diff --git a/libs/ui/Gralloc1.cpp b/libs/ui/Gralloc1.cpp
deleted file mode 100644
index 64a8b40..0000000
--- a/libs/ui/Gralloc1.cpp
+++ /dev/null
@@ -1,511 +0,0 @@
-/*
- * Copyright 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-//#define LOG_NDEBUG 0
-
-#include <ui/Gralloc1.h>
-#include <ui/GraphicBuffer.h>
-#include <ui/Gralloc1On0Adapter.h>
-
-#include <vector>
-
-#undef LOG_TAG
-#define LOG_TAG GRALLOC1_LOG_TAG
-
-namespace android {
-
-namespace Gralloc1 {
-
-Descriptor::~Descriptor()
-{
- int32_t intError = mShimDevice.mFunctions.destroyDescriptor(
- mShimDevice.mDevice, mDeviceId);
- auto error = static_cast<gralloc1_error_t>(intError);
- if (error != GRALLOC1_ERROR_NONE) {
- ALOGE("destroyDescriptor failed: %d", intError);
- }
-}
-
-gralloc1_error_t Descriptor::setDimensions(uint32_t width, uint32_t height)
-{
- int32_t intError = mShimDevice.mFunctions.setDimensions(mShimDevice.mDevice,
- mDeviceId, width, height);
- auto error = static_cast<gralloc1_error_t>(intError);
- if (error != GRALLOC1_ERROR_NONE) {
- return error;
- }
- mWidth = width;
- mHeight = height;
- return error;
-}
-
-template <typename ApiType>
-struct Setter {
- typedef int32_t (*Type)(gralloc1_device_t*, gralloc1_buffer_descriptor_t,
- ApiType);
-};
-
-template <typename ApiType, typename ValueType>
-static inline gralloc1_error_t setHelper(
- typename Setter<ApiType>::Type setter, gralloc1_device_t* device,
- gralloc1_buffer_descriptor_t id, ValueType newValue,
- ValueType* cacheVariable)
-{
- int32_t intError = setter(device, id, static_cast<ApiType>(newValue));
- auto error = static_cast<gralloc1_error_t>(intError);
- if (error != GRALLOC1_ERROR_NONE) {
- return error;
- }
- *cacheVariable = newValue;
- return error;
-}
-
-gralloc1_error_t Descriptor::setFormat(android_pixel_format_t format)
-{
- return setHelper<int32_t>(mShimDevice.mFunctions.setFormat.pfn,
- mShimDevice.mDevice, mDeviceId, format, &mFormat);
-}
-
-gralloc1_error_t Descriptor::setLayerCount(uint32_t layerCount)
-{
- if (mShimDevice.hasCapability(GRALLOC1_CAPABILITY_LAYERED_BUFFERS)) {
- return setHelper<uint32_t>(mShimDevice.mFunctions.setLayerCount.pfn,
- mShimDevice.mDevice, mDeviceId, layerCount, &mLayerCount);
- } else {
- // Layered buffers are not supported on this device.
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
-}
-
-gralloc1_error_t Descriptor::setProducerUsage(gralloc1_producer_usage_t usage)
-{
- return setHelper<uint64_t>(mShimDevice.mFunctions.setProducerUsage.pfn,
- mShimDevice.mDevice, mDeviceId, usage, &mProducerUsage);
-}
-
-gralloc1_error_t Descriptor::setConsumerUsage(gralloc1_consumer_usage_t usage)
-{
- return setHelper<uint64_t>(mShimDevice.mFunctions.setConsumerUsage.pfn,
- mShimDevice.mDevice, mDeviceId, usage, &mConsumerUsage);
-}
-
-Device::Device(gralloc1_device_t* device)
- : mDevice(device),
- mCapabilities(loadCapabilities()),
- mFunctions()
-{
- if (!loadFunctions()) {
- ALOGE("Failed to load a required function, aborting");
- abort();
- }
-}
-
-bool Device::hasCapability(gralloc1_capability_t capability) const
-{
- return mCapabilities.count(capability) > 0;
-}
-
-std::string Device::dump()
-{
- uint32_t length = 0;
- mFunctions.dump(mDevice, &length, nullptr);
-
- std::vector<char> output;
- output.resize(length);
- mFunctions.dump(mDevice, &length, output.data());
-
- return std::string(output.cbegin(), output.cend());
-}
-
-std::shared_ptr<Descriptor> Device::createDescriptor()
-{
- gralloc1_buffer_descriptor_t descriptorId;
- int32_t intError = mFunctions.createDescriptor(mDevice, &descriptorId);
- auto error = static_cast<gralloc1_error_t>(intError);
- if (error != GRALLOC1_ERROR_NONE) {
- return nullptr;
- }
- auto descriptor = std::make_shared<Descriptor>(*this, descriptorId);
- return descriptor;
-}
-
-static inline bool allocationSucceded(gralloc1_error_t error)
-{
- return error == GRALLOC1_ERROR_NONE || error == GRALLOC1_ERROR_NOT_SHARED;
-}
-
-gralloc1_error_t Device::allocate(
- const std::vector<std::shared_ptr<const Descriptor>>& descriptors,
- std::vector<buffer_handle_t>* outBuffers)
-{
- if (mFunctions.allocate.pfn == nullptr) {
- // Allocation is not supported on this device
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
-
- std::vector<gralloc1_buffer_descriptor_t> deviceIds;
- for (const auto& descriptor : descriptors) {
- deviceIds.emplace_back(descriptor->getDeviceId());
- }
-
- std::vector<buffer_handle_t> buffers(descriptors.size());
- int32_t intError = mFunctions.allocate(mDevice,
- static_cast<uint32_t>(descriptors.size()), deviceIds.data(),
- buffers.data());
- auto error = static_cast<gralloc1_error_t>(intError);
- if (allocationSucceded(error)) {
- *outBuffers = std::move(buffers);
- }
-
- return error;
-}
-
-gralloc1_error_t Device::allocate(
- const std::shared_ptr<const Descriptor>& descriptor,
- gralloc1_backing_store_t id, buffer_handle_t* outBuffer)
-{
- gralloc1_error_t error = GRALLOC1_ERROR_NONE;
-
- if (hasCapability(GRALLOC1_CAPABILITY_ON_ADAPTER)) {
- buffer_handle_t buffer = nullptr;
- int32_t intError = mFunctions.allocateWithId(mDevice,
- descriptor->getDeviceId(), id, &buffer);
- error = static_cast<gralloc1_error_t>(intError);
- if (allocationSucceded(error)) {
- *outBuffer = buffer;
- }
- } else {
- std::vector<std::shared_ptr<const Descriptor>> descriptors;
- descriptors.emplace_back(descriptor);
- std::vector<buffer_handle_t> buffers;
- error = allocate(descriptors, &buffers);
- if (allocationSucceded(error)) {
- *outBuffer = buffers[0];
- }
- }
-
- return error;
-}
-
-gralloc1_error_t Device::retain(buffer_handle_t buffer)
-{
- int32_t intError = mFunctions.retain(mDevice, buffer);
- return static_cast<gralloc1_error_t>(intError);
-}
-
-gralloc1_error_t Device::retain(const GraphicBuffer* buffer)
-{
- if (hasCapability(GRALLOC1_CAPABILITY_ON_ADAPTER)) {
- return mFunctions.retainGraphicBuffer(mDevice, buffer);
- } else {
- return retain(buffer->getNativeBuffer()->handle);
- }
-}
-
-gralloc1_error_t Device::release(buffer_handle_t buffer)
-{
- int32_t intError = mFunctions.release(mDevice, buffer);
- return static_cast<gralloc1_error_t>(intError);
-}
-
-gralloc1_error_t Device::getDimensions(buffer_handle_t buffer,
- uint32_t* outWidth, uint32_t* outHeight)
-{
- uint32_t width = 0;
- uint32_t height = 0;
- int32_t intError = mFunctions.getDimensions(mDevice, buffer, &width,
- &height);
- auto error = static_cast<gralloc1_error_t>(intError);
- if (error == GRALLOC1_ERROR_NONE) {
- *outWidth = width;
- *outHeight = height;
- }
- return error;
-}
-
-gralloc1_error_t Device::getFormat(buffer_handle_t buffer,
- int32_t* outFormat)
-{
- int32_t format = 0;
- int32_t intError = mFunctions.getFormat(mDevice, buffer, &format);
- auto error = static_cast<gralloc1_error_t>(intError);
- if (error == GRALLOC1_ERROR_NONE) {
- *outFormat = format;
- }
- return error;
-}
-
-gralloc1_error_t Device::getLayerCount(buffer_handle_t buffer,
- uint32_t* outLayerCount)
-{
- if (hasCapability(GRALLOC1_CAPABILITY_LAYERED_BUFFERS)) {
- uint32_t layerCount = 0;
- int32_t intError = mFunctions.getLayerCount(mDevice, buffer,
- &layerCount);
- auto error = static_cast<gralloc1_error_t>(intError);
- if (error == GRALLOC1_ERROR_NONE) {
- *outLayerCount = layerCount;
- }
- return error;
- } else {
- // Layered buffers are not supported on this device.
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
-}
-
-gralloc1_error_t Device::getProducerUsage(buffer_handle_t buffer,
- uint64_t* outProducerUsage)
-{
- uint64_t usage = 0;
- int32_t intError = mFunctions.getProducerUsage(mDevice, buffer, &usage);
- auto error = static_cast<gralloc1_error_t>(intError);
- if (error == GRALLOC1_ERROR_NONE) {
- *outProducerUsage = usage;
- }
- return error;
-}
-
-gralloc1_error_t Device::getConsumerUsage(buffer_handle_t buffer,
- uint64_t* outConsumerUsage)
-{
- uint64_t usage = 0;
- int32_t intError = mFunctions.getConsumerUsage(mDevice, buffer, &usage);
- auto error = static_cast<gralloc1_error_t>(intError);
- if (error == GRALLOC1_ERROR_NONE) {
- *outConsumerUsage = usage;
- }
- return error;
-}
-
-gralloc1_error_t Device::getBackingStore(buffer_handle_t buffer,
- uint64_t* outBackingStore)
-{
- uint64_t store = 0;
- int32_t intError = mFunctions.getBackingStore(mDevice, buffer, &store);
- auto error = static_cast<gralloc1_error_t>(intError);
- if (error == GRALLOC1_ERROR_NONE) {
- *outBackingStore = store;
- }
- return error;
-}
-
-gralloc1_error_t Device::getStride(buffer_handle_t buffer,
- uint32_t* outStride)
-{
- uint32_t stride = 0;
- int32_t intError = mFunctions.getStride(mDevice, buffer, &stride);
- auto error = static_cast<gralloc1_error_t>(intError);
- if (error == GRALLOC1_ERROR_NONE) {
- *outStride = stride;
- }
- return error;
-}
-
-gralloc1_error_t Device::getNumFlexPlanes(buffer_handle_t buffer,
- uint32_t* outNumPlanes)
-{
- uint32_t numPlanes = 0;
- int32_t intError = mFunctions.getNumFlexPlanes(mDevice, buffer, &numPlanes);
- auto error = static_cast<gralloc1_error_t>(intError);
- if (error == GRALLOC1_ERROR_NONE) {
- *outNumPlanes = numPlanes;
- }
- return error;
-}
-
-gralloc1_error_t Device::lock(buffer_handle_t buffer,
- gralloc1_producer_usage_t producerUsage,
- gralloc1_consumer_usage_t consumerUsage,
- const gralloc1_rect_t* accessRegion, void** outData,
- const sp<Fence>& acquireFence)
-{
- ALOGV("Calling lock(%p)", buffer);
- return lockHelper(mFunctions.lock, buffer, producerUsage,
- consumerUsage, accessRegion, outData, acquireFence);
-}
-
-gralloc1_error_t Device::lockFlex(buffer_handle_t buffer,
- gralloc1_producer_usage_t producerUsage,
- gralloc1_consumer_usage_t consumerUsage,
- const gralloc1_rect_t* accessRegion,
- struct android_flex_layout* outData,
- const sp<Fence>& acquireFence)
-{
- ALOGV("Calling lockFlex(%p)", buffer);
- return lockHelper(mFunctions.lockFlex, buffer, producerUsage,
- consumerUsage, accessRegion, outData, acquireFence);
-}
-
-gralloc1_error_t Device::lockYCbCr(buffer_handle_t buffer,
- gralloc1_producer_usage_t producerUsage,
- gralloc1_consumer_usage_t consumerUsage,
- const gralloc1_rect_t* accessRegion,
- struct android_ycbcr* outData,
- const sp<Fence>& acquireFence)
-{
- ALOGV("Calling lockYCbCr(%p)", buffer);
- return lockHelper(mFunctions.lockYCbCr, buffer, producerUsage,
- consumerUsage, accessRegion, outData, acquireFence);
-}
-
-gralloc1_error_t Device::unlock(buffer_handle_t buffer, sp<Fence>* outFence)
-{
- int32_t fenceFd = -1;
- int32_t intError = mFunctions.unlock(mDevice, buffer, &fenceFd);
- auto error = static_cast<gralloc1_error_t>(intError);
- if (error == GRALLOC1_ERROR_NONE) {
- *outFence = new Fence(fenceFd);
- }
- return error;
-}
-
-std::unordered_set<gralloc1_capability_t> Device::loadCapabilities()
-{
- std::vector<int32_t> intCapabilities;
- uint32_t numCapabilities = 0;
- mDevice->getCapabilities(mDevice, &numCapabilities, nullptr);
-
- intCapabilities.resize(numCapabilities);
- mDevice->getCapabilities(mDevice, &numCapabilities, intCapabilities.data());
-
- std::unordered_set<gralloc1_capability_t> capabilities;
- for (const auto intCapability : intCapabilities) {
- capabilities.emplace(static_cast<gralloc1_capability_t>(intCapability));
- }
- return capabilities;
-}
-
-bool Device::loadFunctions()
-{
- // Functions which must always be present
- if (!mFunctions.dump.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.createDescriptor.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.destroyDescriptor.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.setConsumerUsage.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.setDimensions.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.setFormat.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.setProducerUsage.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.getBackingStore.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.getConsumerUsage.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.getDimensions.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.getFormat.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.getProducerUsage.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.getStride.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.retain.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.release.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.getNumFlexPlanes.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.lock.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.lockFlex.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.unlock.load(mDevice, true)) {
- return false;
- }
-
- if (hasCapability(GRALLOC1_CAPABILITY_ON_ADAPTER)) {
- // These should always be present on the adapter
- if (!mFunctions.retainGraphicBuffer.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.lockYCbCr.load(mDevice, true)) {
- return false;
- }
-
- // allocateWithId may not be present if we're only able to map in this
- // process
- mFunctions.allocateWithId.load(mDevice, false);
- } else {
- // allocate may not be present if we're only able to map in this process
- mFunctions.allocate.load(mDevice, false);
- }
-
- if (hasCapability(GRALLOC1_CAPABILITY_LAYERED_BUFFERS)) {
- if (!mFunctions.setLayerCount.load(mDevice, true)) {
- return false;
- }
- if (!mFunctions.getLayerCount.load(mDevice, true)) {
- return false;
- }
- }
-
- return true;
-}
-
-std::unique_ptr<Gralloc1On0Adapter> Loader::mAdapter = nullptr;
-
-Loader::Loader()
- : mDevice(nullptr)
-{
- hw_module_t const* module;
- int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
- uint8_t majorVersion = (module->module_api_version >> 8) & 0xFF;
- uint8_t minorVersion = module->module_api_version & 0xFF;
- gralloc1_device_t* device = nullptr;
- if (majorVersion == 1) {
- gralloc1_open(module, &device);
- } else {
- if (!mAdapter) {
- mAdapter = std::make_unique<Gralloc1On0Adapter>(module);
- }
- device = mAdapter->getDevice();
- }
- mDevice = std::make_unique<Gralloc1::Device>(device);
-}
-
-Loader::~Loader() {}
-
-std::unique_ptr<Device> Loader::getDevice()
-{
- return std::move(mDevice);
-}
-
-} // namespace android::Gralloc1
-
-} // namespace android
diff --git a/libs/ui/Gralloc1On0Adapter.cpp b/libs/ui/Gralloc1On0Adapter.cpp
deleted file mode 100644
index 9ee9838..0000000
--- a/libs/ui/Gralloc1On0Adapter.cpp
+++ /dev/null
@@ -1,501 +0,0 @@
-/*
- * Copyright 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#undef LOG_TAG
-#define LOG_TAG "Gralloc1On0Adapter"
-//#define LOG_NDEBUG 0
-
-#include <ui/Gralloc1On0Adapter.h>
-
-#include <algorithm>
-#include <array>
-
-#include <grallocusage/GrallocUsageConversion.h>
-
-#include <hardware/gralloc.h>
-
-#include <ui/GraphicBuffer.h>
-#include <ui/Gralloc1.h>
-
-#include <utils/Log.h>
-
-#include <inttypes.h>
-
-template <typename PFN, typename T>
-static gralloc1_function_pointer_t asFP(T function)
-{
- static_assert(std::is_same<PFN, T>::value, "Incompatible function pointer");
- return reinterpret_cast<gralloc1_function_pointer_t>(function);
-}
-
-namespace android {
-
-Gralloc1On0Adapter::Gralloc1On0Adapter(const hw_module_t* module)
- : mModule(reinterpret_cast<const gralloc_module_t*>(module)),
- mMinorVersion(mModule->common.module_api_version & 0xFF),
- mDevice(nullptr)
-{
- ALOGV("Constructing");
- getCapabilities = getCapabilitiesHook;
- getFunction = getFunctionHook;
- int error = ::gralloc_open(&(mModule->common), &mDevice);
- if (error) {
- ALOGE("Failed to open gralloc0 module: %d", error);
- }
- ALOGV("Opened gralloc0 device %p", mDevice);
-}
-
-Gralloc1On0Adapter::~Gralloc1On0Adapter()
-{
- ALOGV("Destructing");
- if (mDevice) {
- ALOGV("Closing gralloc0 device %p", mDevice);
- ::gralloc_close(mDevice);
- }
-}
-
-void Gralloc1On0Adapter::doGetCapabilities(uint32_t* outCount,
- int32_t* outCapabilities)
-{
- constexpr std::array<int32_t, 2> supportedCapabilities = {{
- GRALLOC1_CAPABILITY_ON_ADAPTER,
- GRALLOC1_CAPABILITY_RELEASE_IMPLY_DELETE,
- }};
-
- if (outCapabilities == nullptr) {
- *outCount = supportedCapabilities.size();
- } else {
- *outCount = std::min(*outCount, static_cast<uint32_t>(
- supportedCapabilities.size()));
- std::copy_n(supportedCapabilities.begin(),
- *outCount, outCapabilities);
- }
-}
-
-gralloc1_function_pointer_t Gralloc1On0Adapter::doGetFunction(
- int32_t intDescriptor)
-{
- constexpr auto lastDescriptor =
- static_cast<int32_t>(GRALLOC1_LAST_ADAPTER_FUNCTION);
- if (intDescriptor < 0 || intDescriptor > lastDescriptor) {
- ALOGE("Invalid function descriptor");
- return nullptr;
- }
-
- auto descriptor =
- static_cast<gralloc1_function_descriptor_t>(intDescriptor);
- switch (descriptor) {
- case GRALLOC1_FUNCTION_DUMP:
- return asFP<GRALLOC1_PFN_DUMP>(dumpHook);
- case GRALLOC1_FUNCTION_CREATE_DESCRIPTOR:
- return asFP<GRALLOC1_PFN_CREATE_DESCRIPTOR>(createDescriptorHook);
- case GRALLOC1_FUNCTION_DESTROY_DESCRIPTOR:
- return asFP<GRALLOC1_PFN_DESTROY_DESCRIPTOR>(destroyDescriptorHook);
- case GRALLOC1_FUNCTION_SET_CONSUMER_USAGE:
- return asFP<GRALLOC1_PFN_SET_CONSUMER_USAGE>(setConsumerUsageHook);
- case GRALLOC1_FUNCTION_SET_DIMENSIONS:
- return asFP<GRALLOC1_PFN_SET_DIMENSIONS>(setDimensionsHook);
- case GRALLOC1_FUNCTION_SET_FORMAT:
- return asFP<GRALLOC1_PFN_SET_FORMAT>(setFormatHook);
- case GRALLOC1_FUNCTION_SET_LAYER_COUNT:
- return asFP<GRALLOC1_PFN_SET_LAYER_COUNT>(setLayerCountHook);
- case GRALLOC1_FUNCTION_SET_PRODUCER_USAGE:
- return asFP<GRALLOC1_PFN_SET_PRODUCER_USAGE>(setProducerUsageHook);
- case GRALLOC1_FUNCTION_GET_BACKING_STORE:
- return asFP<GRALLOC1_PFN_GET_BACKING_STORE>(
- bufferHook<decltype(&Buffer::getBackingStore),
- &Buffer::getBackingStore, gralloc1_backing_store_t*>);
- case GRALLOC1_FUNCTION_GET_CONSUMER_USAGE:
- return asFP<GRALLOC1_PFN_GET_CONSUMER_USAGE>(getConsumerUsageHook);
- case GRALLOC1_FUNCTION_GET_DIMENSIONS:
- return asFP<GRALLOC1_PFN_GET_DIMENSIONS>(
- bufferHook<decltype(&Buffer::getDimensions),
- &Buffer::getDimensions, uint32_t*, uint32_t*>);
- case GRALLOC1_FUNCTION_GET_FORMAT:
- return asFP<GRALLOC1_PFN_GET_FORMAT>(
- bufferHook<decltype(&Buffer::getFormat),
- &Buffer::getFormat, int32_t*>);
- case GRALLOC1_FUNCTION_GET_LAYER_COUNT:
- return asFP<GRALLOC1_PFN_GET_LAYER_COUNT>(
- bufferHook<decltype(&Buffer::getLayerCount),
- &Buffer::getLayerCount, uint32_t*>);
- case GRALLOC1_FUNCTION_GET_PRODUCER_USAGE:
- return asFP<GRALLOC1_PFN_GET_PRODUCER_USAGE>(getProducerUsageHook);
- case GRALLOC1_FUNCTION_GET_STRIDE:
- return asFP<GRALLOC1_PFN_GET_STRIDE>(
- bufferHook<decltype(&Buffer::getStride),
- &Buffer::getStride, uint32_t*>);
- case GRALLOC1_FUNCTION_ALLOCATE:
- // Not provided, since we'll use ALLOCATE_WITH_ID
- return nullptr;
- case GRALLOC1_FUNCTION_ALLOCATE_WITH_ID:
- if (mDevice != nullptr) {
- return asFP<GRALLOC1_PFN_ALLOCATE_WITH_ID>(allocateWithIdHook);
- } else {
- return nullptr;
- }
- case GRALLOC1_FUNCTION_RETAIN:
- return asFP<GRALLOC1_PFN_RETAIN>(
- managementHook<&Gralloc1On0Adapter::retain>);
- case GRALLOC1_FUNCTION_RELEASE:
- return asFP<GRALLOC1_PFN_RELEASE>(
- managementHook<&Gralloc1On0Adapter::release>);
- case GRALLOC1_FUNCTION_RETAIN_GRAPHIC_BUFFER:
- return asFP<GRALLOC1_PFN_RETAIN_GRAPHIC_BUFFER>(
- retainGraphicBufferHook);
- case GRALLOC1_FUNCTION_GET_NUM_FLEX_PLANES:
- return asFP<GRALLOC1_PFN_GET_NUM_FLEX_PLANES>(
- bufferHook<decltype(&Buffer::getNumFlexPlanes),
- &Buffer::getNumFlexPlanes, uint32_t*>);
- case GRALLOC1_FUNCTION_LOCK:
- return asFP<GRALLOC1_PFN_LOCK>(
- lockHook<void*, &Gralloc1On0Adapter::lock>);
- case GRALLOC1_FUNCTION_LOCK_FLEX:
- return asFP<GRALLOC1_PFN_LOCK_FLEX>(
- lockHook<struct android_flex_layout,
- &Gralloc1On0Adapter::lockFlex>);
- case GRALLOC1_FUNCTION_LOCK_YCBCR:
- return asFP<GRALLOC1_PFN_LOCK_YCBCR>(
- lockHook<struct android_ycbcr,
- &Gralloc1On0Adapter::lockYCbCr>);
- case GRALLOC1_FUNCTION_UNLOCK:
- return asFP<GRALLOC1_PFN_UNLOCK>(unlockHook);
- case GRALLOC1_FUNCTION_INVALID:
- ALOGE("Invalid function descriptor");
- return nullptr;
- }
-
- ALOGE("Unknown function descriptor: %d", intDescriptor);
- return nullptr;
-}
-
-void Gralloc1On0Adapter::dump(uint32_t* outSize, char* outBuffer)
-{
- ALOGV("dump(%u (%p), %p", outSize ? *outSize : 0, outSize, outBuffer);
-
- if (!mDevice->dump) {
- // dump is optional on gralloc0 implementations
- *outSize = 0;
- return;
- }
-
- if (!outBuffer) {
- constexpr int32_t BUFFER_LENGTH = 4096;
- char buffer[BUFFER_LENGTH] = {};
- mDevice->dump(mDevice, buffer, BUFFER_LENGTH);
- buffer[BUFFER_LENGTH - 1] = 0; // Ensure the buffer is null-terminated
- size_t actualLength = std::strlen(buffer);
- mCachedDump.resize(actualLength);
- std::copy_n(buffer, actualLength, mCachedDump.begin());
- *outSize = static_cast<uint32_t>(actualLength);
- } else {
- *outSize = std::min(*outSize,
- static_cast<uint32_t>(mCachedDump.size()));
- outBuffer = std::copy_n(mCachedDump.cbegin(), *outSize, outBuffer);
- }
-}
-
-gralloc1_error_t Gralloc1On0Adapter::createDescriptor(
- gralloc1_buffer_descriptor_t* outDescriptor)
-{
- auto descriptorId = sNextBufferDescriptorId++;
- std::lock_guard<std::mutex> lock(mDescriptorMutex);
- mDescriptors.emplace(descriptorId,
- std::make_shared<Descriptor>(this, descriptorId));
-
- ALOGV("Created descriptor %" PRIu64, descriptorId);
-
- *outDescriptor = descriptorId;
- return GRALLOC1_ERROR_NONE;
-}
-
-gralloc1_error_t Gralloc1On0Adapter::destroyDescriptor(
- gralloc1_buffer_descriptor_t descriptor)
-{
- ALOGV("Destroying descriptor %" PRIu64, descriptor);
-
- std::lock_guard<std::mutex> lock(mDescriptorMutex);
- if (mDescriptors.count(descriptor) == 0) {
- return GRALLOC1_ERROR_BAD_DESCRIPTOR;
- }
-
- mDescriptors.erase(descriptor);
- return GRALLOC1_ERROR_NONE;
-}
-
-Gralloc1On0Adapter::Buffer::Buffer(buffer_handle_t handle,
- gralloc1_backing_store_t store, const Descriptor& descriptor,
- uint32_t stride, bool wasAllocated)
- : mHandle(handle),
- mReferenceCount(1),
- mStore(store),
- mDescriptor(descriptor),
- mStride(stride),
- mWasAllocated(wasAllocated) {}
-
-gralloc1_error_t Gralloc1On0Adapter::allocate(
- const std::shared_ptr<Descriptor>& descriptor,
- gralloc1_backing_store_t store,
- buffer_handle_t* outBufferHandle)
-{
- ALOGV("allocate(%" PRIu64 ", %#" PRIx64 ")", descriptor->id, store);
-
- // If this function is being called, it's because we handed out its function
- // pointer, which only occurs when mDevice has been loaded successfully and
- // we are permitted to allocate
-
- int usage = android_convertGralloc1To0Usage(descriptor->producerUsage,
- descriptor->consumerUsage);
- buffer_handle_t handle = nullptr;
- int stride = 0;
- ALOGV("Calling alloc(%p, %u, %u, %i, %u)", mDevice, descriptor->width,
- descriptor->height, descriptor->format, usage);
- auto error = mDevice->alloc(mDevice,
- static_cast<int>(descriptor->width),
- static_cast<int>(descriptor->height), descriptor->format,
- usage, &handle, &stride);
- if (error != 0) {
- ALOGE("gralloc0 allocation failed: %d (%s)", error,
- strerror(-error));
- return GRALLOC1_ERROR_NO_RESOURCES;
- }
-
- *outBufferHandle = handle;
- auto buffer = std::make_shared<Buffer>(handle, store, *descriptor, stride,
- true);
-
- std::lock_guard<std::mutex> lock(mBufferMutex);
- mBuffers.emplace(handle, std::move(buffer));
-
- return GRALLOC1_ERROR_NONE;
-}
-
-gralloc1_error_t Gralloc1On0Adapter::allocateWithIdHook(
- gralloc1_device_t* device, gralloc1_buffer_descriptor_t descriptorId,
- gralloc1_backing_store_t store, buffer_handle_t* outBuffer)
-{
- auto adapter = getAdapter(device);
-
- auto descriptor = adapter->getDescriptor(descriptorId);
- if (!descriptor) {
- return GRALLOC1_ERROR_BAD_DESCRIPTOR;
- }
-
- buffer_handle_t bufferHandle = nullptr;
- auto error = adapter->allocate(descriptor, store, &bufferHandle);
- if (error != GRALLOC1_ERROR_NONE) {
- return error;
- }
-
- *outBuffer = bufferHandle;
- return error;
-}
-
-gralloc1_error_t Gralloc1On0Adapter::retain(
- const std::shared_ptr<Buffer>& buffer)
-{
- std::lock_guard<std::mutex> lock(mBufferMutex);
- buffer->retain();
- return GRALLOC1_ERROR_NONE;
-}
-
-gralloc1_error_t Gralloc1On0Adapter::release(
- const std::shared_ptr<Buffer>& buffer)
-{
- std::lock_guard<std::mutex> lock(mBufferMutex);
- if (!buffer->release()) {
- return GRALLOC1_ERROR_NONE;
- }
-
- buffer_handle_t handle = buffer->getHandle();
- if (buffer->wasAllocated()) {
- ALOGV("Calling free(%p)", handle);
- int result = mDevice->free(mDevice, handle);
- if (result != 0) {
- ALOGE("gralloc0 free failed: %d", result);
- }
- } else {
- ALOGV("Calling unregisterBuffer(%p)", handle);
- int result = mModule->unregisterBuffer(mModule, handle);
- if (result != 0) {
- ALOGE("gralloc0 unregister failed: %d", result);
- }
-
- native_handle_close(handle);
- native_handle_delete(const_cast<native_handle_t*>(handle));
- }
-
- mBuffers.erase(handle);
- return GRALLOC1_ERROR_NONE;
-}
-
-gralloc1_error_t Gralloc1On0Adapter::retain(
- const android::GraphicBuffer* graphicBuffer)
-{
- ALOGV("retainGraphicBuffer(%p, %#" PRIx64 ")",
- graphicBuffer->getNativeBuffer()->handle, graphicBuffer->getId());
-
- buffer_handle_t handle = graphicBuffer->getNativeBuffer()->handle;
- std::lock_guard<std::mutex> lock(mBufferMutex);
- if (mBuffers.count(handle) != 0) {
- mBuffers[handle]->retain();
- return GRALLOC1_ERROR_NONE;
- }
-
- ALOGV("Calling registerBuffer(%p)", handle);
- int result = mModule->registerBuffer(mModule, handle);
- if (result != 0) {
- ALOGE("gralloc0 register failed: %d", result);
- return GRALLOC1_ERROR_NO_RESOURCES;
- }
-
- Descriptor descriptor{this, sNextBufferDescriptorId++};
- descriptor.setDimensions(graphicBuffer->getWidth(),
- graphicBuffer->getHeight());
- descriptor.setFormat(graphicBuffer->getPixelFormat());
- descriptor.setProducerUsage(
- static_cast<gralloc1_producer_usage_t>(graphicBuffer->getUsage()));
- descriptor.setConsumerUsage(
- static_cast<gralloc1_consumer_usage_t>(graphicBuffer->getUsage()));
- auto buffer = std::make_shared<Buffer>(handle,
- static_cast<gralloc1_backing_store_t>(graphicBuffer->getId()),
- descriptor, graphicBuffer->getStride(), false);
- mBuffers.emplace(handle, std::move(buffer));
- return GRALLOC1_ERROR_NONE;
-}
-
-gralloc1_error_t Gralloc1On0Adapter::lock(
- const std::shared_ptr<Buffer>& buffer,
- gralloc1_producer_usage_t producerUsage,
- gralloc1_consumer_usage_t consumerUsage,
- const gralloc1_rect_t& accessRegion, void** outData,
- const sp<Fence>& acquireFence)
-{
- if (mMinorVersion >= 3) {
- int result = mModule->lockAsync(mModule, buffer->getHandle(),
- android_convertGralloc1To0Usage(producerUsage, consumerUsage),
- accessRegion.left, accessRegion.top, accessRegion.width,
- accessRegion.height, outData, acquireFence->dup());
- if (result != 0) {
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
- } else {
- acquireFence->waitForever("Gralloc1On0Adapter::lock");
- int result = mModule->lock(mModule, buffer->getHandle(),
- android_convertGralloc1To0Usage(producerUsage, consumerUsage),
- accessRegion.left, accessRegion.top, accessRegion.width,
- accessRegion.height, outData);
- ALOGV("gralloc0 lock returned %d", result);
- if (result != 0) {
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
- }
- return GRALLOC1_ERROR_NONE;
-}
-
-gralloc1_error_t Gralloc1On0Adapter::lockFlex(
- const std::shared_ptr<Buffer>& /*buffer*/,
- gralloc1_producer_usage_t /*producerUsage*/,
- gralloc1_consumer_usage_t /*consumerUsage*/,
- const gralloc1_rect_t& /*accessRegion*/,
- struct android_flex_layout* /*outData*/,
- const sp<Fence>& /*acquireFence*/)
-{
- // TODO
- return GRALLOC1_ERROR_UNSUPPORTED;
-}
-
-gralloc1_error_t Gralloc1On0Adapter::lockYCbCr(
- const std::shared_ptr<Buffer>& buffer,
- gralloc1_producer_usage_t producerUsage,
- gralloc1_consumer_usage_t consumerUsage,
- const gralloc1_rect_t& accessRegion, struct android_ycbcr* outData,
- const sp<Fence>& acquireFence)
-{
- if (mMinorVersion >= 3 && mModule->lockAsync_ycbcr) {
- int result = mModule->lockAsync_ycbcr(mModule, buffer->getHandle(),
- android_convertGralloc1To0Usage(producerUsage, consumerUsage),
- accessRegion.left, accessRegion.top, accessRegion.width,
- accessRegion.height, outData, acquireFence->dup());
- if (result != 0) {
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
- } else if (mModule->lock_ycbcr) {
- acquireFence->waitForever("Gralloc1On0Adapter::lockYCbCr");
- int result = mModule->lock_ycbcr(mModule, buffer->getHandle(),
- android_convertGralloc1To0Usage(producerUsage, consumerUsage),
- accessRegion.left, accessRegion.top, accessRegion.width,
- accessRegion.height, outData);
- ALOGV("gralloc0 lockYCbCr returned %d", result);
- if (result != 0) {
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
- } else {
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
-
- return GRALLOC1_ERROR_NONE;
-}
-
-gralloc1_error_t Gralloc1On0Adapter::unlock(
- const std::shared_ptr<Buffer>& buffer,
- sp<Fence>* outReleaseFence)
-{
- if (mMinorVersion >= 3) {
- int fenceFd = -1;
- int result = mModule->unlockAsync(mModule, buffer->getHandle(),
- &fenceFd);
- if (result != 0) {
- close(fenceFd);
- ALOGE("gralloc0 unlockAsync failed: %d", result);
- } else {
- *outReleaseFence = new Fence(fenceFd);
- }
- } else {
- int result = mModule->unlock(mModule, buffer->getHandle());
- if (result != 0) {
- ALOGE("gralloc0 unlock failed: %d", result);
- }
- }
- return GRALLOC1_ERROR_NONE;
-}
-
-std::shared_ptr<Gralloc1On0Adapter::Descriptor>
-Gralloc1On0Adapter::getDescriptor(gralloc1_buffer_descriptor_t descriptorId)
-{
- std::lock_guard<std::mutex> lock(mDescriptorMutex);
- if (mDescriptors.count(descriptorId) == 0) {
- return nullptr;
- }
-
- return mDescriptors[descriptorId];
-}
-
-std::shared_ptr<Gralloc1On0Adapter::Buffer> Gralloc1On0Adapter::getBuffer(
- buffer_handle_t bufferHandle)
-{
- std::lock_guard<std::mutex> lock(mBufferMutex);
- if (mBuffers.count(bufferHandle) == 0) {
- return nullptr;
- }
-
- return mBuffers[bufferHandle];
-}
-
-std::atomic<gralloc1_buffer_descriptor_t>
- Gralloc1On0Adapter::sNextBufferDescriptorId(1);
-
-} // namespace android
diff --git a/libs/ui/Gralloc2.cpp b/libs/ui/Gralloc2.cpp
index 75f5686..f8d9401 100644
--- a/libs/ui/Gralloc2.cpp
+++ b/libs/ui/Gralloc2.cpp
@@ -33,7 +33,7 @@
Mapper::Mapper()
{
mMapper = IMapper::getService();
- if (mMapper != nullptr && mMapper->isRemote()) {
+ if (mMapper == nullptr || mMapper->isRemote()) {
LOG_ALWAYS_FATAL("gralloc-mapper must be in passthrough mode");
}
}
@@ -196,8 +196,9 @@
Allocator::Allocator(const Mapper& mapper)
: mMapper(mapper)
{
- if (mMapper.valid()) {
- mAllocator = IAllocator::getService();
+ mAllocator = IAllocator::getService();
+ if (mAllocator == nullptr) {
+ LOG_ALWAYS_FATAL("gralloc-alloc is missing");
}
}
diff --git a/libs/ui/GraphicBuffer.cpp b/libs/ui/GraphicBuffer.cpp
index eb5c7b6..b0cb012 100644
--- a/libs/ui/GraphicBuffer.cpp
+++ b/libs/ui/GraphicBuffer.cpp
@@ -188,18 +188,6 @@
uint64_t producerUsage, uint64_t consumerUsage,
uint32_t stride)
{
- native_handle_t* clone = nullptr;
-
- if (method == CLONE_HANDLE) {
- clone = native_handle_clone(handle);
- if (!clone) {
- return NO_MEMORY;
- }
-
- handle = clone;
- method = TAKE_UNREGISTERED_HANDLE;
- }
-
ANativeWindowBuffer::width = static_cast<int>(width);
ANativeWindowBuffer::height = static_cast<int>(height);
ANativeWindowBuffer::stride = static_cast<int>(stride);
@@ -208,25 +196,28 @@
android_convertGralloc1To0Usage(producerUsage, consumerUsage);
ANativeWindowBuffer::layerCount = layerCount;
- ANativeWindowBuffer::handle = handle;
mOwner = (method == WRAP_HANDLE) ? ownNone : ownHandle;
- if (method == TAKE_UNREGISTERED_HANDLE) {
- status_t err = mBufferMapper.importBuffer(this);
+ if (method == TAKE_UNREGISTERED_HANDLE || method == CLONE_HANDLE) {
+ buffer_handle_t importedHandle;
+ status_t err = mBufferMapper.importBuffer(handle, &importedHandle);
if (err != NO_ERROR) {
- // clean up cloned handle
- if (clone) {
- native_handle_close(clone);
- native_handle_delete(clone);
- }
-
initWithHandle(nullptr, WRAP_HANDLE, 0, 0, 0, 0, 0, 0, 0);
return err;
}
+
+ if (method == TAKE_UNREGISTERED_HANDLE) {
+ native_handle_close(handle);
+ native_handle_delete(const_cast<native_handle_t*>(handle));
+ }
+
+ handle = importedHandle;
}
+ ANativeWindowBuffer::handle = handle;
+
return NO_ERROR;
}
@@ -447,7 +438,8 @@
mOwner = ownHandle;
if (handle != 0) {
- status_t err = mBufferMapper.importBuffer(this);
+ buffer_handle_t importedHandle;
+ status_t err = mBufferMapper.importBuffer(handle, &importedHandle);
if (err != NO_ERROR) {
width = height = stride = format = layerCount = usage = 0;
handle = NULL;
@@ -455,6 +447,10 @@
strerror(-err), err);
return err;
}
+
+ native_handle_close(handle);
+ native_handle_delete(const_cast<native_handle_t*>(handle));
+ handle = importedHandle;
}
buffer = static_cast<void const*>(static_cast<uint8_t const*>(buffer) + sizeNeeded);
diff --git a/libs/ui/GraphicBufferAllocator.cpp b/libs/ui/GraphicBufferAllocator.cpp
index 1f6c537..11f0250 100644
--- a/libs/ui/GraphicBufferAllocator.cpp
+++ b/libs/ui/GraphicBufferAllocator.cpp
@@ -46,10 +46,6 @@
mAllocator(std::make_unique<Gralloc2::Allocator>(
mMapper.getGrallocMapper()))
{
- if (!mAllocator->valid()) {
- mLoader = std::make_unique<Gralloc1::Loader>();
- mDevice = mLoader->getDevice();
- }
}
GraphicBufferAllocator::~GraphicBufferAllocator() {}
@@ -87,13 +83,7 @@
snprintf(buffer, SIZE, "Total allocated (estimate): %.2f KB\n", total/1024.0);
result.append(buffer);
- std::string deviceDump;
- if (mAllocator->valid()) {
- deviceDump = mAllocator->dumpDebugInfo();
- } else {
- deviceDump = mDevice->dump();
- }
-
+ std::string deviceDump = mAllocator->dumpDebugInfo();
result.append(deviceDump.c_str(), deviceDump.size());
}
@@ -107,7 +97,7 @@
status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height,
PixelFormat format, uint32_t layerCount, uint64_t producerUsage,
uint64_t consumerUsage, buffer_handle_t* handle, uint32_t* stride,
- uint64_t graphicBufferId, std::string requestorName)
+ uint64_t /*graphicBufferId*/, std::string requestorName)
{
ATRACE_CALL();
@@ -120,76 +110,16 @@
if (layerCount < 1)
layerCount = 1;
- gralloc1_error_t error;
- if (mAllocator->valid()) {
- Gralloc2::IMapper::BufferDescriptorInfo info = {};
- info.width = width;
- info.height = height;
- info.layerCount = layerCount;
- info.format = static_cast<Gralloc2::PixelFormat>(format);
- info.usage = static_cast<uint64_t>(android_convertGralloc1To0Usage(
+ Gralloc2::IMapper::BufferDescriptorInfo info = {};
+ info.width = width;
+ info.height = height;
+ info.layerCount = layerCount;
+ info.format = static_cast<Gralloc2::PixelFormat>(format);
+ info.usage = static_cast<uint64_t>(android_convertGralloc1To0Usage(
producerUsage, consumerUsage));
- error = static_cast<gralloc1_error_t>(mAllocator->allocate(info,
- stride, handle));
- if (error != GRALLOC1_ERROR_NONE) {
- return NO_MEMORY;
- }
- } else {
- auto descriptor = mDevice->createDescriptor();
- error = descriptor->setDimensions(width, height);
- if (error != GRALLOC1_ERROR_NONE) {
- ALOGE("Failed to set dimensions to (%u, %u): %d",
- width, height, error);
- return BAD_VALUE;
- }
- error = descriptor->setFormat(
- static_cast<android_pixel_format_t>(format));
- if (error != GRALLOC1_ERROR_NONE) {
- ALOGE("Failed to set format to %d: %d", format, error);
- return BAD_VALUE;
- }
- if (mDevice->hasCapability(GRALLOC1_CAPABILITY_LAYERED_BUFFERS)) {
- error = descriptor->setLayerCount(layerCount);
- if (error != GRALLOC1_ERROR_NONE) {
- ALOGE("Failed to set layer count to %u: %d", layerCount, error);
- return BAD_VALUE;
- }
- } else if (layerCount > 1) {
- ALOGE("Failed to set layer count to %u: capability unsupported",
- layerCount);
- return BAD_VALUE;
- }
- error = descriptor->setProducerUsage(
- static_cast<gralloc1_producer_usage_t>(producerUsage));
- if (error != GRALLOC1_ERROR_NONE) {
- ALOGE("Failed to set producer usage to %" PRIx64 ": %d",
- producerUsage, error);
- return BAD_VALUE;
- }
- error = descriptor->setConsumerUsage(
- static_cast<gralloc1_consumer_usage_t>(consumerUsage));
- if (error != GRALLOC1_ERROR_NONE) {
- ALOGE("Failed to set consumer usage to %" PRIx64 ": %d",
- consumerUsage, error);
- return BAD_VALUE;
- }
- error = mDevice->allocate(descriptor, graphicBufferId, handle);
- if (error != GRALLOC1_ERROR_NONE) {
- ALOGE("Failed to allocate (%u x %u) layerCount %u format %d "
- "producerUsage %" PRIx64 " consumerUsage %" PRIx64 ": %d",
- width, height, layerCount, format, producerUsage,
- consumerUsage, error);
- return NO_MEMORY;
- }
-
- error = mDevice->getStride(*handle, stride);
- if (error != GRALLOC1_ERROR_NONE) {
- ALOGW("Failed to get stride from buffer: %d", error);
- }
- }
-
- if (error == NO_ERROR) {
+ Gralloc2::Error error = mAllocator->allocate(info, stride, handle);
+ if (error == Gralloc2::Error::NONE) {
Mutex::Autolock _l(sLock);
KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList);
uint32_t bpp = bytesPerPixel(format);
@@ -204,25 +134,24 @@
rec.size = static_cast<size_t>(height * (*stride) * bpp);
rec.requestorName = std::move(requestorName);
list.add(*handle, rec);
- }
- return NO_ERROR;
+ return NO_ERROR;
+ } else {
+ ALOGE("Failed to allocate (%u x %u) layerCount %u format %d "
+ "producerUsage %" PRIx64 " consumerUsage %" PRIx64 ": %d",
+ width, height, layerCount, format, producerUsage,
+ consumerUsage, error);
+ return NO_MEMORY;
+ }
}
status_t GraphicBufferAllocator::free(buffer_handle_t handle)
{
ATRACE_CALL();
- gralloc1_error_t error;
- if (mAllocator->valid()) {
- error = static_cast<gralloc1_error_t>(mMapper.freeBuffer(handle));
- } else {
- error = mDevice->release(handle);
- }
-
- if (error != GRALLOC1_ERROR_NONE) {
- ALOGE("Failed to free buffer: %d", error);
- }
+ // We allocated a buffer from the allocator and imported it into the
+ // mapper to get the handle. We just need to free the handle now.
+ mMapper.freeBuffer(handle);
Mutex::Autolock _l(sLock);
KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList);
diff --git a/libs/ui/GraphicBufferMapper.cpp b/libs/ui/GraphicBufferMapper.cpp
index 87519bf..b9fa640 100644
--- a/libs/ui/GraphicBufferMapper.cpp
+++ b/libs/ui/GraphicBufferMapper.cpp
@@ -45,10 +45,6 @@
GraphicBufferMapper::GraphicBufferMapper()
: mMapper(std::make_unique<const Gralloc2::Mapper>())
{
- if (!mMapper->valid()) {
- mLoader = std::make_unique<Gralloc1::Loader>();
- mDevice = mLoader->getDevice();
- }
}
status_t GraphicBufferMapper::importBuffer(buffer_handle_t rawHandle,
@@ -56,13 +52,8 @@
{
ATRACE_CALL();
- Gralloc2::Error error;
- if (mMapper->valid()) {
- error = mMapper->importBuffer(hardware::hidl_handle(rawHandle),
- outHandle);
- } else {
- error = Gralloc2::Error::UNSUPPORTED;
- }
+ Gralloc2::Error error = mMapper->importBuffer(
+ hardware::hidl_handle(rawHandle), outHandle);
ALOGW_IF(error != Gralloc2::Error::NONE, "importBuffer(%p) failed: %d",
rawHandle, error);
@@ -70,77 +61,13 @@
return static_cast<status_t>(error);
}
-status_t GraphicBufferMapper::importBuffer(const GraphicBuffer* buffer)
-{
- ATRACE_CALL();
-
- ANativeWindowBuffer* nativeBuffer = buffer->getNativeBuffer();
- buffer_handle_t rawHandle = nativeBuffer->handle;
-
- gralloc1_error_t error;
- if (mMapper->valid()) {
- buffer_handle_t importedHandle;
- error = static_cast<gralloc1_error_t>(mMapper->importBuffer(
- hardware::hidl_handle(rawHandle), &importedHandle));
- if (error == GRALLOC1_ERROR_NONE) {
- nativeBuffer->handle = importedHandle;
- }
- } else {
- native_handle_t* clonedHandle = native_handle_clone(rawHandle);
- if (clonedHandle) {
- nativeBuffer->handle = clonedHandle;
- error = mDevice->retain(buffer);
- if (error != GRALLOC1_ERROR_NONE) {
- nativeBuffer->handle = rawHandle;
- native_handle_close(clonedHandle);
- native_handle_delete(clonedHandle);
- }
- } else {
- error = GRALLOC1_ERROR_NO_RESOURCES;
- }
- }
-
- // the raw handle is owned by GraphicBuffer and is now replaced
- if (error == GRALLOC1_ERROR_NONE) {
- native_handle_close(rawHandle);
- native_handle_delete(const_cast<native_handle_t*>(rawHandle));
- }
-
- ALOGW_IF(error != GRALLOC1_ERROR_NONE, "importBuffer(%p) failed: %d",
- rawHandle, error);
-
- return error;
-}
-
status_t GraphicBufferMapper::freeBuffer(buffer_handle_t handle)
{
ATRACE_CALL();
- gralloc1_error_t error;
- if (mMapper->valid()) {
- mMapper->freeBuffer(handle);
- error = GRALLOC1_ERROR_NONE;
- } else {
- error = mDevice->release(handle);
- if (!mDevice->hasCapability(GRALLOC1_CAPABILITY_RELEASE_IMPLY_DELETE)) {
- native_handle_close(handle);
- native_handle_delete(const_cast<native_handle_t*>(handle));
- }
- }
+ mMapper->freeBuffer(handle);
- ALOGW_IF(error != GRALLOC1_ERROR_NONE, "freeBuffer(%p): failed %d",
- handle, error);
-
- return error;
-}
-
-static inline gralloc1_rect_t asGralloc1Rect(const Rect& rect) {
- gralloc1_rect_t outRect{};
- outRect.left = rect.left;
- outRect.top = rect.top;
- outRect.width = rect.width();
- outRect.height = rect.height();
- return outRect;
+ return NO_ERROR;
}
static inline Gralloc2::IMapper::Rect asGralloc2Rect(const Rect& rect) {
@@ -187,26 +114,15 @@
{
ATRACE_CALL();
- gralloc1_error_t error;
- if (mMapper->valid()) {
- const uint64_t usage =
- static_cast<uint64_t>(android_convertGralloc1To0Usage(
- producerUsage, consumerUsage));
- error = static_cast<gralloc1_error_t>(mMapper->lock(handle,
- usage, asGralloc2Rect(bounds), fenceFd, vaddr));
- } else {
- gralloc1_rect_t accessRegion = asGralloc1Rect(bounds);
- sp<Fence> fence = new Fence(fenceFd);
- error = mDevice->lock(handle,
- static_cast<gralloc1_producer_usage_t>(producerUsage),
- static_cast<gralloc1_consumer_usage_t>(consumerUsage),
- &accessRegion, vaddr, fence);
- }
+ const uint64_t usage = static_cast<uint64_t>(
+ android_convertGralloc1To0Usage(producerUsage, consumerUsage));
+ Gralloc2::Error error = mMapper->lock(handle, usage,
+ asGralloc2Rect(bounds), fenceFd, vaddr);
- ALOGW_IF(error != GRALLOC1_ERROR_NONE, "lock(%p, ...) failed: %d", handle,
- error);
+ ALOGW_IF(error != Gralloc2::Error::NONE, "lock(%p, ...) failed: %d",
+ handle, error);
- return error;
+ return static_cast<status_t>(error);
}
static inline bool isValidYCbCrPlane(const android_flex_plane_t& plane) {
@@ -237,160 +153,28 @@
{
ATRACE_CALL();
- gralloc1_rect_t accessRegion = asGralloc1Rect(bounds);
-
- std::vector<android_flex_plane_t> planes;
- android_flex_layout_t flexLayout{};
- gralloc1_error_t error;
-
- if (mMapper->valid()) {
- Gralloc2::YCbCrLayout layout;
- error = static_cast<gralloc1_error_t>(mMapper->lock(handle, usage,
- asGralloc2Rect(bounds), fenceFd, &layout));
- if (error == GRALLOC1_ERROR_NONE) {
- ycbcr->y = layout.y;
- ycbcr->cb = layout.cb;
- ycbcr->cr = layout.cr;
- ycbcr->ystride = static_cast<size_t>(layout.yStride);
- ycbcr->cstride = static_cast<size_t>(layout.cStride);
- ycbcr->chroma_step = static_cast<size_t>(layout.chromaStep);
- }
-
- return error;
- } else {
- sp<Fence> fence = new Fence(fenceFd);
-
- if (mDevice->hasCapability(GRALLOC1_CAPABILITY_ON_ADAPTER)) {
- error = mDevice->lockYCbCr(handle,
- static_cast<gralloc1_producer_usage_t>(usage),
- static_cast<gralloc1_consumer_usage_t>(usage),
- &accessRegion, ycbcr, fence);
- ALOGW_IF(error != GRALLOC1_ERROR_NONE,
- "lockYCbCr(%p, ...) failed: %d", handle, error);
- return error;
- }
-
- uint32_t numPlanes = 0;
- error = mDevice->getNumFlexPlanes(handle, &numPlanes);
-
- if (error != GRALLOC1_ERROR_NONE) {
- ALOGV("Failed to retrieve number of flex planes: %d", error);
- return error;
- }
- if (numPlanes < 3) {
- ALOGV("Not enough planes for YCbCr (%u found)", numPlanes);
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
-
- planes.resize(numPlanes);
- flexLayout.num_planes = numPlanes;
- flexLayout.planes = planes.data();
-
- error = mDevice->lockFlex(handle,
- static_cast<gralloc1_producer_usage_t>(usage),
- static_cast<gralloc1_consumer_usage_t>(usage),
- &accessRegion, &flexLayout, fence);
+ Gralloc2::YCbCrLayout layout;
+ Gralloc2::Error error = mMapper->lock(handle, usage,
+ asGralloc2Rect(bounds), fenceFd, &layout);
+ if (error == Gralloc2::Error::NONE) {
+ ycbcr->y = layout.y;
+ ycbcr->cb = layout.cb;
+ ycbcr->cr = layout.cr;
+ ycbcr->ystride = static_cast<size_t>(layout.yStride);
+ ycbcr->cstride = static_cast<size_t>(layout.cStride);
+ ycbcr->chroma_step = static_cast<size_t>(layout.chromaStep);
}
- if (error != GRALLOC1_ERROR_NONE) {
- ALOGW("lockFlex(%p, ...) failed: %d", handle, error);
- return error;
- }
- if (flexLayout.format != FLEX_FORMAT_YCbCr) {
- ALOGV("Unable to convert flex-format buffer to YCbCr");
- unlock(handle);
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
-
- // Find planes
- auto yPlane = planes.cend();
- auto cbPlane = planes.cend();
- auto crPlane = planes.cend();
- for (auto planeIter = planes.cbegin(); planeIter != planes.cend();
- ++planeIter) {
- if (planeIter->component == FLEX_COMPONENT_Y) {
- yPlane = planeIter;
- } else if (planeIter->component == FLEX_COMPONENT_Cb) {
- cbPlane = planeIter;
- } else if (planeIter->component == FLEX_COMPONENT_Cr) {
- crPlane = planeIter;
- }
- }
- if (yPlane == planes.cend()) {
- ALOGV("Unable to find Y plane");
- unlock(handle);
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
- if (cbPlane == planes.cend()) {
- ALOGV("Unable to find Cb plane");
- unlock(handle);
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
- if (crPlane == planes.cend()) {
- ALOGV("Unable to find Cr plane");
- unlock(handle);
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
-
- // Validate planes
- if (!isValidYCbCrPlane(*yPlane)) {
- ALOGV("Y plane is invalid");
- unlock(handle);
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
- if (!isValidYCbCrPlane(*cbPlane)) {
- ALOGV("Cb plane is invalid");
- unlock(handle);
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
- if (!isValidYCbCrPlane(*crPlane)) {
- ALOGV("Cr plane is invalid");
- unlock(handle);
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
- if (cbPlane->v_increment != crPlane->v_increment) {
- ALOGV("Cb and Cr planes have different step (%d vs. %d)",
- cbPlane->v_increment, crPlane->v_increment);
- unlock(handle);
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
- if (cbPlane->h_increment != crPlane->h_increment) {
- ALOGV("Cb and Cr planes have different stride (%d vs. %d)",
- cbPlane->h_increment, crPlane->h_increment);
- unlock(handle);
- return GRALLOC1_ERROR_UNSUPPORTED;
- }
-
- // Pack plane data into android_ycbcr struct
- ycbcr->y = yPlane->top_left;
- ycbcr->cb = cbPlane->top_left;
- ycbcr->cr = crPlane->top_left;
- ycbcr->ystride = static_cast<size_t>(yPlane->v_increment);
- ycbcr->cstride = static_cast<size_t>(cbPlane->v_increment);
- ycbcr->chroma_step = static_cast<size_t>(cbPlane->h_increment);
-
- return error;
+ return static_cast<status_t>(error);
}
status_t GraphicBufferMapper::unlockAsync(buffer_handle_t handle, int *fenceFd)
{
ATRACE_CALL();
- gralloc1_error_t error;
- if (mMapper->valid()) {
- *fenceFd = mMapper->unlock(handle);
- error = GRALLOC1_ERROR_NONE;
- } else {
- sp<Fence> fence = Fence::NO_FENCE;
- error = mDevice->unlock(handle, &fence);
- if (error != GRALLOC1_ERROR_NONE) {
- ALOGE("unlock(%p) failed: %d", handle, error);
- return error;
- }
+ *fenceFd = mMapper->unlock(handle);
- *fenceFd = fence->dup();
- }
- return error;
+ return NO_ERROR;
}
// ---------------------------------------------------------------------------
diff --git a/libs/vr/libbufferhubqueue/buffer_hub_queue_producer.cpp b/libs/vr/libbufferhubqueue/buffer_hub_queue_producer.cpp
index ebd7da0..e236c31 100644
--- a/libs/vr/libbufferhubqueue/buffer_hub_queue_producer.cpp
+++ b/libs/vr/libbufferhubqueue/buffer_hub_queue_producer.cpp
@@ -450,7 +450,9 @@
std::unique_lock<std::mutex> lock(core_->mutex_);
- if (api != core_->connected_api_) {
+ if (BufferHubQueueCore::kNoConnectedApi == core_->connected_api_) {
+ return NO_INIT;
+ } else if (api != core_->connected_api_) {
return BAD_VALUE;
}
diff --git a/libs/vr/libdisplay/include/private/dvr/late_latch.h b/libs/vr/libdisplay/include/private/dvr/late_latch.h
index d0eff51..b7c5e4f 100644
--- a/libs/vr/libdisplay/include/private/dvr/late_latch.h
+++ b/libs/vr/libdisplay/include/private/dvr/late_latch.h
@@ -178,6 +178,9 @@
LateLatchOutput* eds_late_latch_output_;
DvrPose* pose_client_;
+
+ pdx::LocalHandle surface_metadata_fd_;
+ pdx::LocalHandle pose_buffer_fd_;
};
} // namespace dvr
diff --git a/libs/vr/libdisplay/late_latch.cpp b/libs/vr/libdisplay/late_latch.cpp
index b1a1589..e67f009 100644
--- a/libs/vr/libdisplay/late_latch.cpp
+++ b/libs/vr/libdisplay/late_latch.cpp
@@ -252,7 +252,8 @@
LocalHandle&& surface_metadata_fd)
: is_app_late_latch_(is_app_late_latch),
app_late_latch_output_(NULL),
- eds_late_latch_output_(NULL) {
+ eds_late_latch_output_(NULL),
+ surface_metadata_fd_(std::move(surface_metadata_fd)) {
CHECK_GL();
glGenBuffers(1, &input_buffer_id_);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, input_buffer_id_);
@@ -264,12 +265,11 @@
GL_DYNAMIC_COPY);
CHECK_GL();
- LocalHandle pose_buffer_fd;
pose_client_ = dvrPoseCreate();
if (!pose_client_) {
ALOGE("LateLatch Error: failed to create pose client");
} else {
- int ret = privateDvrPoseGetRingBufferFd(pose_client_, &pose_buffer_fd);
+ int ret = privateDvrPoseGetRingBufferFd(pose_client_, &pose_buffer_fd_);
if (ret < 0) {
ALOGE("LateLatch Error: failed to get pose ring buffer");
}
@@ -280,20 +280,20 @@
if (!glBindSharedBufferQCOM) {
ALOGE("Error: Missing gralloc buffer extension, no pose data");
} else {
- if (pose_buffer_fd) {
+ if (pose_buffer_fd_) {
glBindBuffer(GL_SHADER_STORAGE_BUFFER, pose_buffer_object_);
glBindSharedBufferQCOM(GL_SHADER_STORAGE_BUFFER,
kPoseAsyncBufferTotalCount * sizeof(DvrPoseAsync),
- pose_buffer_fd.Release());
+ pose_buffer_fd_.Get());
}
CHECK_GL();
}
glBindBuffer(GL_SHADER_STORAGE_BUFFER, metadata_buffer_id_);
- if (surface_metadata_fd && glBindSharedBufferQCOM) {
+ if (surface_metadata_fd_ && glBindSharedBufferQCOM) {
glBindSharedBufferQCOM(GL_SHADER_STORAGE_BUFFER,
sizeof(DisplaySurfaceMetadata),
- surface_metadata_fd.Release());
+ surface_metadata_fd_.Get());
} else {
// Fall back on internal metadata buffer when none provided, for example
// when distortion is done in the application process.
diff --git a/libs/vr/libdvr/display_manager_client.cpp b/libs/vr/libdvr/display_manager_client.cpp
index 8d84f7b..64c7f16 100644
--- a/libs/vr/libdvr/display_manager_client.cpp
+++ b/libs/vr/libdvr/display_manager_client.cpp
@@ -1,6 +1,7 @@
#include "include/dvr/display_manager_client.h"
#include <dvr/dvr_buffer.h>
+#include <private/android/AHardwareBufferHelpers.h>
#include <private/dvr/buffer_hub_client.h>
#include <private/dvr/display_manager_client_impl.h>
@@ -44,10 +45,11 @@
DvrBuffer* dvrDisplayManagerSetupNamedBuffer(DvrDisplayManagerClient* client,
const char* name, size_t size,
- uint64_t producer_usage,
- uint64_t consumer_usage) {
- // TODO(hendrikw): When we move to gralloc1, pass both producer_usage and
- // consumer_usage down.
+ uint64_t usage0, uint64_t usage1) {
+ uint64_t producer_usage = 0;
+ uint64_t consumer_usage = 0;
+ android::AHardwareBuffer_convertToGrallocUsageBits(
+ &producer_usage, &consumer_usage, usage0, usage1);
auto ion_buffer = client->client->SetupNamedBuffer(name, size, producer_usage,
consumer_usage);
if (ion_buffer) {
diff --git a/libs/vr/libdvr/dvr_api.cpp b/libs/vr/libdvr/dvr_api.cpp
index 5dc4a1b..c4634b1 100644
--- a/libs/vr/libdvr/dvr_api.cpp
+++ b/libs/vr/libdvr/dvr_api.cpp
@@ -53,14 +53,18 @@
dvr_api->write_buffer_post = dvrWriteBufferPost;
dvr_api->write_buffer_gain = dvrWriteBufferGain;
dvr_api->write_buffer_gain_async = dvrWriteBufferGainAsync;
+ dvr_api->write_buffer_get_native_handle = dvrWriteBufferGetNativeHandle;
dvr_api->read_buffer_destroy = dvrReadBufferDestroy;
dvr_api->read_buffer_get_ahardwarebuffer = dvrReadBufferGetAHardwareBuffer;
dvr_api->read_buffer_acquire = dvrReadBufferAcquire;
dvr_api->read_buffer_release = dvrReadBufferRelease;
dvr_api->read_buffer_release_async = dvrReadBufferReleaseAsync;
+ dvr_api->read_buffer_get_native_handle = dvrReadBufferGetNativeHandle;
+
dvr_api->buffer_destroy = dvrBufferDestroy;
dvr_api->buffer_get_ahardwarebuffer = dvrBufferGetAHardwareBuffer;
+ dvr_api->buffer_get_native_handle = dvrBufferGetNativeHandle;
// dvr_buffer_queue.h
dvr_api->write_buffer_queue_destroy = dvrWriteBufferQueueDestroy;
diff --git a/libs/vr/libdvr/dvr_buffer.cpp b/libs/vr/libdvr/dvr_buffer.cpp
index 0942b3d..28820e7 100644
--- a/libs/vr/libdvr/dvr_buffer.cpp
+++ b/libs/vr/libdvr/dvr_buffer.cpp
@@ -1,5 +1,6 @@
#include "include/dvr/dvr_buffer.h"
+#include <android/hardware_buffer.h>
#include <private/dvr/buffer_hub_client.h>
#include <ui/GraphicBuffer.h>
@@ -54,6 +55,16 @@
false /* keep ownership */));
}
+int ConvertToAHardwareBuffer(GraphicBuffer* graphic_buffer,
+ AHardwareBuffer** hardware_buffer) {
+ if (!hardware_buffer || !graphic_buffer) {
+ return -EINVAL;
+ }
+ *hardware_buffer = reinterpret_cast<AHardwareBuffer*>(graphic_buffer);
+ AHardwareBuffer_acquire(*hardware_buffer);
+ return 0;
+}
+
} // anonymous namespace
extern "C" {
@@ -68,9 +79,8 @@
int dvrWriteBufferGetAHardwareBuffer(DvrWriteBuffer* write_buffer,
AHardwareBuffer** hardware_buffer) {
- *hardware_buffer = reinterpret_cast<AHardwareBuffer*>(
- write_buffer->write_buffer->buffer()->buffer().get());
- return 0;
+ return ConvertToAHardwareBuffer(
+ write_buffer->write_buffer->buffer()->buffer().get(), hardware_buffer);
}
int dvrWriteBufferPost(DvrWriteBuffer* write_buffer, int ready_fence_fd,
@@ -99,9 +109,8 @@
int dvrReadBufferGetAHardwareBuffer(DvrReadBuffer* read_buffer,
AHardwareBuffer** hardware_buffer) {
- *hardware_buffer = reinterpret_cast<AHardwareBuffer*>(
- read_buffer->read_buffer->buffer()->buffer().get());
- return 0;
+ return ConvertToAHardwareBuffer(
+ read_buffer->read_buffer->buffer()->buffer().get(), hardware_buffer);
}
int dvrReadBufferAcquire(DvrReadBuffer* read_buffer, int* ready_fence_fd,
@@ -127,13 +136,22 @@
int dvrBufferGetAHardwareBuffer(DvrBuffer* buffer,
AHardwareBuffer** hardware_buffer) {
- if (!hardware_buffer) {
- return -EINVAL;
- }
+ return ConvertToAHardwareBuffer(buffer->buffer->buffer().get(),
+ hardware_buffer);
+}
- *hardware_buffer =
- reinterpret_cast<AHardwareBuffer*>(buffer->buffer->buffer().get());
- return 0;
+const struct native_handle* dvrWriteBufferGetNativeHandle(
+ DvrWriteBuffer* write_buffer) {
+ return write_buffer->write_buffer->native_handle();
+}
+
+const struct native_handle* dvrReadBufferGetNativeHandle(
+ DvrReadBuffer* read_buffer) {
+ return read_buffer->read_buffer->native_handle();
+}
+
+const struct native_handle* dvrBufferGetNativeHandle(DvrBuffer* buffer) {
+ return buffer->buffer->handle();
}
} // extern "C"
diff --git a/libs/vr/libdvr/include/dvr/display_manager_client.h b/libs/vr/libdvr/include/dvr/display_manager_client.h
index 4e1f227..8cd948c 100644
--- a/libs/vr/libdvr/include/dvr/display_manager_client.h
+++ b/libs/vr/libdvr/include/dvr/display_manager_client.h
@@ -22,8 +22,7 @@
DvrBuffer* dvrDisplayManagerSetupNamedBuffer(DvrDisplayManagerClient* client,
const char* name, size_t size,
- uint64_t producer_usage,
- uint64_t consumer_usage);
+ uint64_t usage0, uint64_t usage1);
// Return an event fd for checking if there was an event on the server
// Note that the only event which will be flagged is POLLIN. You must use
diff --git a/libs/vr/libdvr/include/dvr/dvr_api.h b/libs/vr/libdvr/include/dvr/dvr_api.h
index a69433d..56f937b 100644
--- a/libs/vr/libdvr/include/dvr/dvr_api.h
+++ b/libs/vr/libdvr/include/dvr/dvr_api.h
@@ -38,6 +38,8 @@
typedef struct DvrSurface DvrSurface;
+struct native_handle;
+
// display_manager_client.h
typedef int (*DvrDisplayManagerClientGetSurfaceListPtr)(
DvrDisplayManagerClient* client,
@@ -46,7 +48,7 @@
DvrDisplayManagerClientSurfaceList* surface_list);
typedef DvrBuffer* (*DvrDisplayManagerSetupNamedBufferPtr)(
DvrDisplayManagerClient* client, const char* name, size_t size,
- uint64_t producer_usage, uint64_t consumer_usage);
+ uint64_t usage0, uint64_t usage1);
typedef size_t (*DvrDisplayManagerClientSurfaceListGetSizePtr)(
DvrDisplayManagerClientSurfaceList* surface_list);
typedef int (*DvrDisplayManagerClientSurfaceListGetSurfaceIdPtr)(
@@ -70,6 +72,8 @@
typedef int (*DvrWriteBufferGainPtr)(DvrWriteBuffer* client,
int* release_fence_fd);
typedef int (*DvrWriteBufferGainAsyncPtr)(DvrWriteBuffer* client);
+typedef const struct native_handle* (*DvrWriteBufferGetNativeHandle)(
+ DvrWriteBuffer* write_buffer);
typedef void (*DvrReadBufferDestroyPtr)(DvrReadBuffer* client);
typedef int (*DvrReadBufferGetAHardwareBufferPtr)(
@@ -80,9 +84,14 @@
typedef int (*DvrReadBufferReleasePtr)(DvrReadBuffer* client,
int release_fence_fd);
typedef int (*DvrReadBufferReleaseAsyncPtr)(DvrReadBuffer* client);
+typedef const struct native_handle* (*DvrReadBufferGetNativeHandle)(
+ DvrReadBuffer* read_buffer);
+
typedef void (*DvrBufferDestroy)(DvrBuffer* buffer);
typedef int (*DvrBufferGetAHardwareBuffer)(DvrBuffer* buffer,
AHardwareBuffer** hardware_buffer);
+typedef const struct native_handle* (*DvrBufferGetNativeHandle)(
+ DvrBuffer* buffer);
// dvr_buffer_queue.h
typedef void (*DvrWriteBufferQueueDestroyPtr)(DvrWriteBufferQueue* write_queue);
@@ -238,6 +247,7 @@
DvrWriteBufferPostPtr write_buffer_post;
DvrWriteBufferGainPtr write_buffer_gain;
DvrWriteBufferGainAsyncPtr write_buffer_gain_async;
+ DvrWriteBufferGetNativeHandle write_buffer_get_native_handle;
// Read buffer
DvrReadBufferDestroyPtr read_buffer_destroy;
@@ -245,8 +255,12 @@
DvrReadBufferAcquirePtr read_buffer_acquire;
DvrReadBufferReleasePtr read_buffer_release;
DvrReadBufferReleaseAsyncPtr read_buffer_release_async;
+ DvrReadBufferGetNativeHandle read_buffer_get_native_handle;
+
+ // Buffer
DvrBufferDestroy buffer_destroy;
DvrBufferGetAHardwareBuffer buffer_get_ahardwarebuffer;
+ DvrBufferGetNativeHandle buffer_get_native_handle;
// Write buffer queue
DvrWriteBufferQueueDestroyPtr write_buffer_queue_destroy;
diff --git a/libs/vr/libdvr/include/dvr/dvr_buffer.h b/libs/vr/libdvr/include/dvr/dvr_buffer.h
index 6c9c4d3..3e8357c 100644
--- a/libs/vr/libdvr/include/dvr/dvr_buffer.h
+++ b/libs/vr/libdvr/include/dvr/dvr_buffer.h
@@ -13,31 +13,40 @@
typedef struct DvrReadBuffer DvrReadBuffer;
typedef struct DvrBuffer DvrBuffer;
typedef struct AHardwareBuffer AHardwareBuffer;
+struct native_handle;
// Write buffer
void dvrWriteBufferDestroy(DvrWriteBuffer* write_buffer);
int dvrWriteBufferGetId(DvrWriteBuffer* write_buffer);
+// Caller must call AHardwareBuffer_release on hardware_buffer.
int dvrWriteBufferGetAHardwareBuffer(DvrWriteBuffer* write_buffer,
AHardwareBuffer** hardware_buffer);
int dvrWriteBufferPost(DvrWriteBuffer* write_buffer, int ready_fence_fd,
const void* meta, size_t meta_size_bytes);
int dvrWriteBufferGain(DvrWriteBuffer* write_buffer, int* release_fence_fd);
int dvrWriteBufferGainAsync(DvrWriteBuffer* write_buffer);
+const struct native_handle* dvrWriteBufferGetNativeHandle(
+ DvrWriteBuffer* write_buffer);
// Read buffer
void dvrReadBufferDestroy(DvrReadBuffer* read_buffer);
int dvrReadBufferGetId(DvrReadBuffer* read_buffer);
+// Caller must call AHardwareBuffer_release on hardware_buffer.
int dvrReadBufferGetAHardwareBuffer(DvrReadBuffer* read_buffer,
AHardwareBuffer** hardware_buffer);
int dvrReadBufferAcquire(DvrReadBuffer* read_buffer, int* ready_fence_fd,
void* meta, size_t meta_size_bytes);
int dvrReadBufferRelease(DvrReadBuffer* read_buffer, int release_fence_fd);
int dvrReadBufferReleaseAsync(DvrReadBuffer* read_buffer);
+const struct native_handle* dvrReadBufferGetNativeHandle(
+ DvrReadBuffer* read_buffer);
// Buffer
void dvrBufferDestroy(DvrBuffer* buffer);
+// Caller must call AHardwareBuffer_release on hardware_buffer.
int dvrBufferGetAHardwareBuffer(DvrBuffer* buffer,
AHardwareBuffer** hardware_buffer);
+const struct native_handle* dvrBufferGetNativeHandle(DvrBuffer* buffer);
#ifdef __cplusplus
} // extern "C"
diff --git a/libs/vr/libdvr/tests/dvr_named_buffer-test.cpp b/libs/vr/libdvr/tests/dvr_named_buffer-test.cpp
index cd3285f..2866f47 100644
--- a/libs/vr/libdvr/tests/dvr_named_buffer-test.cpp
+++ b/libs/vr/libdvr/tests/dvr_named_buffer-test.cpp
@@ -42,11 +42,12 @@
AHardwareBuffer* hardware_buffer1 = nullptr;
int e1 = dvrBufferGetAHardwareBuffer(buffer1, &hardware_buffer1);
ASSERT_EQ(0, e1);
+ ASSERT_NE(nullptr, hardware_buffer1);
AHardwareBuffer* hardware_buffer2 = nullptr;
int e2 = dvrBufferGetAHardwareBuffer(buffer2, &hardware_buffer2);
ASSERT_EQ(0, e2);
- ASSERT_NE(nullptr, hardware_buffer1);
+ ASSERT_NE(nullptr, hardware_buffer2);
AHardwareBuffer_Desc desc1 = {};
AHardwareBuffer_describe(hardware_buffer1, &desc1);
@@ -88,6 +89,10 @@
ASSERT_EQ(desc3.usage1, 0u);
dvrBufferDestroy(buffer3);
+
+ AHardwareBuffer_release(hardware_buffer1);
+ AHardwareBuffer_release(hardware_buffer2);
+ AHardwareBuffer_release(hardware_buffer3);
}
TEST_F(DvrNamedBufferTest, TestMultipleNamedBuffers) {
@@ -116,6 +121,35 @@
dvrBufferDestroy(buffer2);
}
+TEST_F(DvrNamedBufferTest, TestNamedBufferUsage) {
+ const char* buffer_name = "buffer_usage";
+
+ // Set usage0 to AHARDWAREBUFFER_USAGE0_VIDEO_ENCODE. We use this because
+ // internally AHARDWAREBUFFER_USAGE0_VIDEO_ENCODE is converted to
+ // GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER, and these two values are different.
+ // If all is good, when we get the AHardwareBuffer, it should be converted
+ // back to AHARDWAREBUFFER_USAGE0_VIDEO_ENCODE.
+ const int64_t usage0 = AHARDWAREBUFFER_USAGE0_VIDEO_ENCODE;
+
+ DvrBuffer* setup_buffer =
+ dvrDisplayManagerSetupNamedBuffer(client_, buffer_name, 10, usage0, 0);
+ ASSERT_NE(nullptr, setup_buffer);
+
+ AHardwareBuffer* hardware_buffer = nullptr;
+ int e2 = dvrBufferGetAHardwareBuffer(setup_buffer, &hardware_buffer);
+ ASSERT_EQ(0, e2);
+ ASSERT_NE(nullptr, hardware_buffer);
+
+ AHardwareBuffer_Desc desc = {};
+ AHardwareBuffer_describe(hardware_buffer, &desc);
+
+ ASSERT_EQ(desc.usage0, AHARDWAREBUFFER_USAGE0_VIDEO_ENCODE);
+
+ dvrBufferDestroy(setup_buffer);
+ AHardwareBuffer_release(hardware_buffer);
+}
+
+
} // namespace
} // namespace dvr
diff --git a/libs/vr/libdvrgraphics/gpu_profiler.cpp b/libs/vr/libdvrgraphics/gpu_profiler.cpp
index 49c515f..c8c978d 100644
--- a/libs/vr/libdvrgraphics/gpu_profiler.cpp
+++ b/libs/vr/libdvrgraphics/gpu_profiler.cpp
@@ -7,6 +7,12 @@
namespace android {
namespace dvr {
+namespace {
+
+constexpr int kMaxPendingQueries = 32;
+
+} // anonynmous namespace
+
static int64_t AdjustTimerQueryToNs(int64_t gpu_time) { return gpu_time; }
void GpuProfiler::TimerData::reset() {
@@ -21,6 +27,7 @@
// Enter a scope, records the timestamp for later matching with leave.
void GpuProfiler::TimerData::enter(int64_t timestamp_ns) {
+ entered = true;
enter_timestamp_ns = timestamp_ns;
}
@@ -28,6 +35,15 @@
void GpuProfiler::TimerData::leave(int64_t timestamp_ns, const char* name,
std::weak_ptr<int64_t> duration_ns,
int print_period) {
+ if (!entered) {
+ // We got the leave event but are missing the enter. This can happen if
+ // OnPendingQueryOverflow() is called, or if the calls to enter()/leave()
+ // aren't properly balanced. Ignore the call but print a warning.
+ ALOGW("Ignoring GpuProfiler::TimerData::leave event with no enter event");
+ return;
+ }
+ entered = false;
+
int64_t elapsed = timestamp_ns - enter_timestamp_ns;
if (elapsed > 1000 * 1000 * 1000) {
// More than one second, drop it as invalid data.
@@ -50,12 +66,12 @@
GpuProfiler::GpuProfiler()
: enable_gpu_tracing_(true),
+ has_gl_context_(false),
sync_with_cpu_time_(false),
gl_timer_offset_ns_(0) {
- SyncGlTimebase();
}
-GpuProfiler::~GpuProfiler() {}
+GpuProfiler::~GpuProfiler() { Clear(); }
bool GpuProfiler::IsGpuProfilingSupported() const {
// TODO(jbates) check for GL_EXT_disjoint_timer_query
@@ -63,6 +79,9 @@
}
GLuint GpuProfiler::TryAllocateGlQueryId() {
+ if (pending_gpu_queries_.size() >= kMaxPendingQueries)
+ OnPendingQueryOverflow();
+
GLuint query_id = 0;
if (gl_timer_query_id_pool_.empty()) {
glGenQueries(1, &query_id);
@@ -95,6 +114,35 @@
}
}
+void GpuProfiler::OnGlContextCreated() {
+ has_gl_context_ = true;
+ gl_timer_offset_ns_ = 0;
+ SyncGlTimebase();
+}
+
+void GpuProfiler::OnGlContextDestroyed() {
+ has_gl_context_ = false;
+ Clear();
+}
+
+void GpuProfiler::Clear() {
+ events_.clear();
+ for (auto& query : pending_gpu_queries_)
+ glDeleteQueries(1, &query.query_id);
+ pending_gpu_queries_.clear();
+ while (!gl_timer_query_id_pool_.empty()) {
+ GLuint id = gl_timer_query_id_pool_.top();
+ gl_timer_query_id_pool_.pop();
+ glDeleteQueries(1, &id);
+ }
+}
+
+void GpuProfiler::OnPendingQueryOverflow() {
+ ALOGW("Reached limit of %d pending queries in GpuProfiler."
+ " Clearing all queries.", kMaxPendingQueries);
+ Clear();
+}
+
void GpuProfiler::SyncGlTimebase() {
if (!sync_with_cpu_time_) {
return;
diff --git a/libs/vr/libdvrgraphics/include/private/dvr/graphics/gpu_profiler.h b/libs/vr/libdvrgraphics/include/private/dvr/graphics/gpu_profiler.h
index 2905d00..c6e752b 100644
--- a/libs/vr/libdvrgraphics/include/private/dvr/graphics/gpu_profiler.h
+++ b/libs/vr/libdvrgraphics/include/private/dvr/graphics/gpu_profiler.h
@@ -38,7 +38,7 @@
// one of the TRACE_GPU* macros defined below.
void SetEnableGpuTracing(bool enabled) { enable_gpu_tracing_ = enabled; }
- bool enabled() const { return enable_gpu_tracing_; }
+ bool enabled() const { return enable_gpu_tracing_ && has_gl_context_; }
// Attempt to keep the GPU times in sync with CPU times.
void SetEnableSyncCpuTime(bool enabled) { sync_with_cpu_time_ = enabled; }
@@ -62,6 +62,14 @@
void LeaveGlScope(const char* scope_name, std::weak_ptr<int64_t> duration_ns,
int print_period);
+ // Must be called when the GL context is created. The GpuProfiler will be
+ // inactive until this is called.
+ void OnGlContextCreated();
+
+ // Must be called before the GL context is destroyed. The GpuProfiler will be
+ // inactive until a call to OnGlContextCreated().
+ void OnGlContextDestroyed();
+
private:
// Data to queue the pending GPU timer queries that need to be polled
// for completion.
@@ -105,11 +113,20 @@
void leave(int64_t timestamp_ns, const char* name,
std::weak_ptr<int64_t> duration_ns, int print_period);
+ bool entered = false;
int64_t total_elapsed_ns = 0;
int64_t enter_timestamp_ns = 0;
int num_events = 0;
};
+ // Clear out events and free GL resources.
+ void Clear();
+
+ // Called when we detect that we've overflowed the pending query queue. This
+ // shouldn't occur in practice, and probably indicates some internal
+ // mismanagement of the gl query objects.
+ void OnPendingQueryOverflow();
+
// Synchronises the GL timebase with the CallTraceManager timebase.
void SyncGlTimebase();
@@ -119,6 +136,10 @@
// Setting for enabling GPU tracing.
bool enable_gpu_tracing_;
+ // True if we have a GL context, false otherwise. When the GpuProfiler is
+ // first created we assume no GL context.
+ bool has_gl_context_;
+
// Setting for synchronizing GPU timestamps with CPU time.
bool sync_with_cpu_time_;
diff --git a/libs/vr/libeds/Android.bp b/libs/vr/libeds/Android.bp
index 85e43cc..a149853 100644
--- a/libs/vr/libeds/Android.bp
+++ b/libs/vr/libeds/Android.bp
@@ -19,7 +19,6 @@
"display_metrics.cpp",
"distortion_renderer.cpp",
"device_metrics.cpp",
- "lookup_radial_distortion.cpp",
"polynomial_radial_distortion.cpp",
]
diff --git a/libs/vr/libeds/device_metrics.cpp b/libs/vr/libeds/device_metrics.cpp
index 50c3e54..68ee186 100644
--- a/libs/vr/libeds/device_metrics.cpp
+++ b/libs/vr/libeds/device_metrics.cpp
@@ -3,14 +3,12 @@
#include <cutils/properties.h>
#include <private/dvr/head_mount_metrics.h>
#include <private/dvr/identity_distortion.h>
-#include <private/dvr/lookup_radial_distortion.h>
#include <private/dvr/polynomial_radial_distortion.h>
#include <private/dvr/types.h>
#include "include/private/dvr/display_metrics.h"
namespace {
-static constexpr char kRGBPolynomialOffset[] = "persist.dvr.rgb_poly_offset";
static constexpr char kRPolynomial[] = "persist.dvr.r_poly";
static constexpr char kGPolynomial[] = "persist.dvr.g_poly";
static constexpr char kBPolynomial[] = "persist.dvr.b_poly";
@@ -68,7 +66,9 @@
float GetDisplayGap() { return GetProperty(kDisplayGap, 0.0f); }
-float GetVEyeToDisplay() { return GetProperty(kVEyeToDisplay, 0.035f); }
+float GetTrayToLensDistance() { return 0.035f; }
+
+float GetVEyeToDisplay() { return GetProperty(kVEyeToDisplay, 0.042f); }
android::dvr::vec2 GetDisplaySize() {
static const std::vector<float> default_size = {0.0742177f, 0.131943f};
@@ -110,33 +110,23 @@
HeadMountMetrics CreateHeadMountMetrics(const FieldOfView& l_fov,
const FieldOfView& r_fov) {
static const std::vector<float> default_r = {
- -4.08519004f, 34.70282075f, -67.37781249f, 56.97304235f,
- -23.35768685f, 4.7199597f, 0.63198082f};
+ 0.00103f, 2.63917f, -7.14427f, 8.98036f, -4.10586f, 0.83705f, 0.00130f};
static const std::vector<float> default_g = {
- 4.43078318f, 3.47806617f, -20.58017398f, 20.85880414f,
- -8.4046504f, 1.61284685f, 0.8881761f};
+ 0.08944f, 2.26005f, -6.30924f, 7.94561f, -3.22788f, 0.45577f, 0.07300f};
static const std::vector<float> default_b = {
- 12.04141265f, -21.98112491f, 14.06758389f, -3.15245629f,
- 0.36549102f, 0.05252705f, 0.99844279f};
- static const std::vector<float> default_offsets = {
- 0.20971645238f, 0.15189450000f, 1.00096958278f};
-
- std::vector<float> poly_offsets =
- GetProperty(kRGBPolynomialOffset, default_offsets);
+ 0.16364f, 1.94083f, -5.55033f, 6.89578f, -2.19053f, -0.04050f, 0.17380f};
std::vector<float> poly_r = GetProperty(kRPolynomial, default_r);
std::vector<float> poly_g = GetProperty(kGPolynomial, default_g);
std::vector<float> poly_b = GetProperty(kBPolynomial, default_b);
- if (poly_offsets.size() != 3)
- poly_offsets = default_offsets;
std::shared_ptr<ColorChannelDistortion> distortion_r(
- new PolynomialRadialDistortion(poly_offsets[0], poly_r));
+ new PolynomialRadialDistortion(poly_r));
std::shared_ptr<ColorChannelDistortion> distortion_g(
- new PolynomialRadialDistortion(poly_offsets[1], poly_g));
+ new PolynomialRadialDistortion(poly_g));
std::shared_ptr<ColorChannelDistortion> distortion_b(
- new PolynomialRadialDistortion(poly_offsets[2], poly_b));
+ new PolynomialRadialDistortion(poly_b));
- return HeadMountMetrics(GetInterLensDistance(), GetVEyeToDisplay(),
+ return HeadMountMetrics(GetInterLensDistance(), GetTrayToLensDistance(),
GetVEyeToDisplay(), kDefaultVerticalAlignment, l_fov,
r_fov, distortion_r, distortion_g, distortion_b,
HeadMountMetrics::EyeOrientation::kCCW0Degrees,
diff --git a/libs/vr/libeds/include/private/dvr/lookup_radial_distortion.h b/libs/vr/libeds/include/private/dvr/lookup_radial_distortion.h
deleted file mode 100644
index 56fc5db..0000000
--- a/libs/vr/libeds/include/private/dvr/lookup_radial_distortion.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef ANDROID_DVR_LOOKUP_RADIAL_DISTORTION_H_
-#define ANDROID_DVR_LOOKUP_RADIAL_DISTORTION_H_
-
-#include <vector>
-
-#include <private/dvr/color_channel_distortion.h>
-
-namespace android {
-namespace dvr {
-
-// LookupRadialDistortion implements a radial distortion based using using a
-// vector of tan(angle) -> multipliers. This can use measured data directly.
-class LookupRadialDistortion : public ColorChannelDistortion {
- public:
- // lookup.x = tan(angle), lookup.y = distance from center multiplier.
- explicit LookupRadialDistortion(const vec2* lookup, size_t count);
-
- vec2 Distort(vec2 p) const override;
- vec2 DistortInverse(vec2 p) const override;
-
- private:
- float DistortionFactor(float r) const;
- float DistortRadius(float r) const;
-
- std::vector<vec2> lookup_;
-};
-
-} // namespace dvr
-} // namespace android
-
-#endif // ANDROID_DVR_LOOKUP_RADIAL_DISTORTION_H_
diff --git a/libs/vr/libeds/include/private/dvr/polynomial_radial_distortion.h b/libs/vr/libeds/include/private/dvr/polynomial_radial_distortion.h
index c1f1ce9..8f080aa 100644
--- a/libs/vr/libeds/include/private/dvr/polynomial_radial_distortion.h
+++ b/libs/vr/libeds/include/private/dvr/polynomial_radial_distortion.h
@@ -28,8 +28,7 @@
// in the distortion equation: coefficients[0] is K1, coefficients[1] is K2,
// etc. Thus the polynomial used for distortion has degree
// (2 * coefficients.size()).
- explicit PolynomialRadialDistortion(float polynomial_offset,
- const std::vector<float>& coefficients);
+ explicit PolynomialRadialDistortion(const std::vector<float>& coefficients);
// Given a radius (measuring distance from the optical axis of the lens),
// returns the distortion factor for that radius.
@@ -52,10 +51,6 @@
const std::vector<float>& GetCoefficients() const;
private:
- // This is makes the polynomial work nicer with a specific lens that doesn't
- // fit nicely to a lower order polynomial. It's basically piecewise
- // line->poly.
- float polynomial_offset_;
std::vector<float> coefficients_;
};
diff --git a/libs/vr/libeds/lookup_radial_distortion.cpp b/libs/vr/libeds/lookup_radial_distortion.cpp
deleted file mode 100644
index 2cee863..0000000
--- a/libs/vr/libeds/lookup_radial_distortion.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#include "include/private/dvr/lookup_radial_distortion.h"
-
-namespace android {
-namespace dvr {
-
-LookupRadialDistortion::LookupRadialDistortion(const vec2* lookup, size_t count)
- : lookup_(lookup, lookup + count) {}
-
-float LookupRadialDistortion::DistortionFactor(float r) const {
- for (size_t i = 1; i < lookup_.size(); ++i) {
- if (lookup_[i].x() > r) {
- float t =
- (r - lookup_[i - 1].x()) / (lookup_[i].x() - lookup_[i - 1].x());
- return lookup_[i - 1].y() + t * (lookup_[i].y() - lookup_[i - 1].y());
- }
- }
- return lookup_.back().y();
-}
-
-float LookupRadialDistortion::DistortRadius(float r) const {
- return r * DistortionFactor(r);
-}
-
-vec2 LookupRadialDistortion::Distort(vec2 p) const {
- return p * DistortionFactor(p.norm());
-}
-
-vec2 LookupRadialDistortion::DistortInverse(vec2 p) const {
- // Secant method.
- const float radius = p.norm();
- float r0 = radius / 0.9f;
- float r1 = radius * 0.9f;
- float r2;
- float dr0 = radius - DistortRadius(r0);
- float dr1;
- while (fabsf(r1 - r0) > 0.0001f /** 0.1mm */) {
- dr1 = radius - DistortRadius(r1);
- r2 = r1 - dr1 * ((r1 - r0) / (dr1 - dr0));
- r0 = r1;
- r1 = r2;
- dr0 = dr1;
- }
- return (r1 / radius) * p;
-}
-
-} // namespace dvr
-} // namespace android
diff --git a/libs/vr/libeds/polynomial_radial_distortion.cpp b/libs/vr/libeds/polynomial_radial_distortion.cpp
index a0c6ea3..fa01bb4 100644
--- a/libs/vr/libeds/polynomial_radial_distortion.cpp
+++ b/libs/vr/libeds/polynomial_radial_distortion.cpp
@@ -4,13 +4,10 @@
namespace dvr {
PolynomialRadialDistortion::PolynomialRadialDistortion(
- float polynomial_offset, const std::vector<float>& coefficients)
- : polynomial_offset_(polynomial_offset), coefficients_(coefficients) {}
+ const std::vector<float>& coefficients)
+ : coefficients_(coefficients) {}
float PolynomialRadialDistortion::DistortionFactor(float r_squared) const {
- if (r_squared < polynomial_offset_)
- return 1.0f;
-
float r_factor = 1.0f;
float distortion_factor = 1.0f;
diff --git a/libs/vr/libpdx_default_transport/pdx_benchmarks.cpp b/libs/vr/libpdx_default_transport/pdx_benchmarks.cpp
index 0b658fb..fa0adf0 100644
--- a/libs/vr/libpdx_default_transport/pdx_benchmarks.cpp
+++ b/libs/vr/libpdx_default_transport/pdx_benchmarks.cpp
@@ -516,9 +516,8 @@
std::cerr << "Starting service instance " << service_id_counter
<< std::endl;
auto service = BenchmarkService::Create(
- android::pdx::default_transport::Endpoint::Create(
+ android::pdx::default_transport::Endpoint::CreateAndBindSocket(
GetServicePath(path, service_id_counter),
- android::pdx::default_transport::Endpoint::kDefaultMode,
android::pdx::default_transport::Endpoint::kBlocking));
if (!service) {
std::cerr << "Failed to create service instance!!" << std::endl;
diff --git a/libs/vr/libpdx_uds/Android.bp b/libs/vr/libpdx_uds/Android.bp
index a73ba34..cfc2022 100644
--- a/libs/vr/libpdx_uds/Android.bp
+++ b/libs/vr/libpdx_uds/Android.bp
@@ -35,10 +35,13 @@
"-Werror",
],
srcs: [
+ "client_channel_tests.cpp",
+ "ipc_helper_tests.cpp",
"remote_method_tests.cpp",
"service_framework_tests.cpp",
],
static_libs: [
+ "libgmock",
"libpdx_uds",
"libpdx",
],
diff --git a/libs/vr/libpdx_uds/client_channel.cpp b/libs/vr/libpdx_uds/client_channel.cpp
index 924335f..9d91617 100644
--- a/libs/vr/libpdx_uds/client_channel.cpp
+++ b/libs/vr/libpdx_uds/client_channel.cpp
@@ -156,6 +156,7 @@
Status<void> ClientChannel::SendImpulse(int opcode, const void* buffer,
size_t length) {
+ std::unique_lock<std::mutex> lock(socket_mutex_);
Status<void> status;
android::pdx::uds::RequestHeader<BorrowedHandle> request;
if (length > request.impulse_payload.size() ||
@@ -174,6 +175,7 @@
size_t send_count,
const iovec* receive_vector,
size_t receive_count) {
+ std::unique_lock<std::mutex> lock(socket_mutex_);
Status<int> result;
if ((send_vector == nullptr && send_count != 0) ||
(receive_vector == nullptr && receive_count != 0)) {
diff --git a/libs/vr/libpdx_uds/client_channel_factory.cpp b/libs/vr/libpdx_uds/client_channel_factory.cpp
index 9202cd5..850c6d3 100644
--- a/libs/vr/libpdx_uds/client_channel_factory.cpp
+++ b/libs/vr/libpdx_uds/client_channel_factory.cpp
@@ -39,32 +39,42 @@
ClientChannelFactory::ClientChannelFactory(const std::string& endpoint_path)
: endpoint_path_{GetEndpointPath(endpoint_path)} {}
+ClientChannelFactory::ClientChannelFactory(LocalHandle socket)
+ : socket_{std::move(socket)} {}
+
std::unique_ptr<pdx::ClientChannelFactory> ClientChannelFactory::Create(
const std::string& endpoint_path) {
return std::unique_ptr<pdx::ClientChannelFactory>{
new ClientChannelFactory{endpoint_path}};
}
+std::unique_ptr<pdx::ClientChannelFactory> ClientChannelFactory::Create(
+ LocalHandle socket) {
+ return std::unique_ptr<pdx::ClientChannelFactory>{
+ new ClientChannelFactory{std::move(socket)}};
+}
+
Status<std::unique_ptr<pdx::ClientChannel>> ClientChannelFactory::Connect(
int64_t timeout_ms) const {
Status<void> status;
- LocalHandle socket_fd{socket(AF_UNIX, SOCK_STREAM, 0)};
- if (!socket_fd) {
+ bool connected = socket_.IsValid();
+ if (!connected) {
+ socket_.Reset(socket(AF_UNIX, SOCK_STREAM, 0));
+ LOG_ALWAYS_FATAL_IF(
+ endpoint_path_.empty(),
+ "ClientChannelFactory::Connect: unspecified socket path");
+ }
+
+ if (!socket_) {
ALOGE("ClientChannelFactory::Connect: socket error: %s", strerror(errno));
return ErrorStatus(errno);
}
- sockaddr_un remote;
- remote.sun_family = AF_UNIX;
- strncpy(remote.sun_path, endpoint_path_.c_str(), sizeof(remote.sun_path));
- remote.sun_path[sizeof(remote.sun_path) - 1] = '\0';
-
bool use_timeout = (timeout_ms >= 0);
auto now = steady_clock::now();
auto time_end = now + std::chrono::milliseconds{timeout_ms};
- bool connected = false;
int max_eaccess = 5; // Max number of times to retry when EACCES returned.
while (!connected) {
int64_t timeout = -1;
@@ -74,6 +84,10 @@
if (timeout < 0)
return ErrorStatus(ETIMEDOUT);
}
+ sockaddr_un remote;
+ remote.sun_family = AF_UNIX;
+ strncpy(remote.sun_path, endpoint_path_.c_str(), sizeof(remote.sun_path));
+ remote.sun_path[sizeof(remote.sun_path) - 1] = '\0';
ALOGD("ClientChannelFactory: Waiting for endpoint at %s", remote.sun_path);
status = WaitForEndpoint(endpoint_path_, timeout);
if (!status)
@@ -81,7 +95,7 @@
ALOGD("ClientChannelFactory: Connecting to %s", remote.sun_path);
int ret = RETRY_EINTR(connect(
- socket_fd.Get(), reinterpret_cast<sockaddr*>(&remote), sizeof(remote)));
+ socket_.Get(), reinterpret_cast<sockaddr*>(&remote), sizeof(remote)));
if (ret == -1) {
ALOGD("ClientChannelFactory: Connect error %d: %s", errno,
strerror(errno));
@@ -107,20 +121,20 @@
}
} else {
connected = true;
+ ALOGD("ClientChannelFactory: Connected successfully to %s...",
+ remote.sun_path);
}
if (use_timeout)
now = steady_clock::now();
} // while (!connected)
- ALOGD("ClientChannelFactory: Connected successfully to %s...",
- remote.sun_path);
RequestHeader<BorrowedHandle> request;
InitRequest(&request, opcodes::CHANNEL_OPEN, 0, 0, false);
- status = SendData(socket_fd.Borrow(), request);
+ status = SendData(socket_.Borrow(), request);
if (!status)
return ErrorStatus(status.error());
ResponseHeader<LocalHandle> response;
- status = ReceiveData(socket_fd.Borrow(), &response);
+ status = ReceiveData(socket_.Borrow(), &response);
if (!status)
return ErrorStatus(status.error());
int ref = response.ret_code;
@@ -129,7 +143,7 @@
LocalHandle event_fd = std::move(response.file_descriptors[ref]);
return ClientChannel::Create(ChannelManager::Get().CreateHandle(
- std::move(socket_fd), std::move(event_fd)));
+ std::move(socket_), std::move(event_fd)));
}
} // namespace uds
diff --git a/libs/vr/libpdx_uds/client_channel_tests.cpp b/libs/vr/libpdx_uds/client_channel_tests.cpp
new file mode 100644
index 0000000..7c3c68a
--- /dev/null
+++ b/libs/vr/libpdx_uds/client_channel_tests.cpp
@@ -0,0 +1,162 @@
+#include <uds/client_channel.h>
+
+#include <sys/socket.h>
+
+#include <algorithm>
+#include <limits>
+#include <random>
+#include <thread>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <pdx/client.h>
+#include <pdx/rpc/remote_method.h>
+#include <pdx/service.h>
+
+#include <uds/client_channel_factory.h>
+#include <uds/service_endpoint.h>
+
+using testing::Return;
+using testing::_;
+
+using android::pdx::ClientBase;
+using android::pdx::LocalChannelHandle;
+using android::pdx::LocalHandle;
+using android::pdx::Message;
+using android::pdx::ServiceBase;
+using android::pdx::ServiceDispatcher;
+using android::pdx::Status;
+using android::pdx::rpc::DispatchRemoteMethod;
+using android::pdx::uds::ClientChannel;
+using android::pdx::uds::ClientChannelFactory;
+using android::pdx::uds::Endpoint;
+
+namespace {
+
+struct TestProtocol {
+ using DataType = int8_t;
+ enum {
+ kOpSum = 0,
+ };
+ PDX_REMOTE_METHOD(Sum, kOpSum, int64_t(const std::vector<DataType>&));
+};
+
+class TestService : public ServiceBase<TestService> {
+ public:
+ TestService(std::unique_ptr<Endpoint> endpoint)
+ : ServiceBase{"TestService", std::move(endpoint)} {}
+
+ Status<void> HandleMessage(Message& message) override {
+ switch (message.GetOp()) {
+ case TestProtocol::kOpSum:
+ DispatchRemoteMethod<TestProtocol::Sum>(*this, &TestService::OnSum,
+ message);
+ return {};
+
+ default:
+ return Service::HandleMessage(message);
+ }
+ }
+
+ int64_t OnSum(Message& /*message*/,
+ const std::vector<TestProtocol::DataType>& data) {
+ return std::accumulate(data.begin(), data.end(), int64_t{0});
+ }
+};
+
+class TestClient : public ClientBase<TestClient> {
+ public:
+ using ClientBase::ClientBase;
+
+ int64_t Sum(const std::vector<TestProtocol::DataType>& data) {
+ auto status = InvokeRemoteMethod<TestProtocol::Sum>(data);
+ return status ? status.get() : -1;
+ }
+};
+
+class TestServiceRunner {
+ public:
+ TestServiceRunner(LocalHandle channel_socket) {
+ auto endpoint = Endpoint::CreateFromSocketFd(LocalHandle{});
+ endpoint->RegisterNewChannelForTests(std::move(channel_socket));
+ service_ = TestService::Create(std::move(endpoint));
+ dispatcher_ = android::pdx::uds::ServiceDispatcher::Create();
+ dispatcher_->AddService(service_);
+ dispatch_thread_ = std::thread(
+ std::bind(&ServiceDispatcher::EnterDispatchLoop, dispatcher_.get()));
+ }
+
+ ~TestServiceRunner() {
+ dispatcher_->SetCanceled(true);
+ dispatch_thread_.join();
+ dispatcher_->RemoveService(service_);
+ }
+
+ private:
+ std::shared_ptr<TestService> service_;
+ std::unique_ptr<ServiceDispatcher> dispatcher_;
+ std::thread dispatch_thread_;
+};
+
+class ClientChannelTest : public testing::Test {
+ public:
+ void SetUp() override {
+ int channel_sockets[2] = {};
+ ASSERT_EQ(
+ 0, socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, channel_sockets));
+ LocalHandle service_channel{channel_sockets[0]};
+ LocalHandle client_channel{channel_sockets[1]};
+
+ service_runner_.reset(new TestServiceRunner{std::move(service_channel)});
+ auto factory = ClientChannelFactory::Create(std::move(client_channel));
+ auto status = factory->Connect(android::pdx::Client::kInfiniteTimeout);
+ ASSERT_TRUE(status);
+ client_ = TestClient::Create(status.take());
+ }
+
+ void TearDown() override {
+ service_runner_.reset();
+ client_.reset();
+ }
+
+ protected:
+ std::unique_ptr<TestServiceRunner> service_runner_;
+ std::shared_ptr<TestClient> client_;
+};
+
+TEST_F(ClientChannelTest, MultithreadedClient) {
+ constexpr int kNumTestThreads = 8;
+ constexpr size_t kDataSize = 1000; // Try to keep RPC buffer size below 4K.
+
+ std::random_device rd;
+ std::mt19937 gen{rd()};
+ std::uniform_int_distribution<TestProtocol::DataType> dist{
+ std::numeric_limits<TestProtocol::DataType>::min(),
+ std::numeric_limits<TestProtocol::DataType>::max()};
+
+ auto worker = [](std::shared_ptr<TestClient> client,
+ std::vector<TestProtocol::DataType> data) {
+ constexpr int kMaxIterations = 500;
+ int64_t expected = std::accumulate(data.begin(), data.end(), int64_t{0});
+ for (int i = 0; i < kMaxIterations; i++) {
+ ASSERT_EQ(expected, client->Sum(data));
+ }
+ };
+
+ // Start client threads.
+ std::vector<TestProtocol::DataType> data;
+ data.resize(kDataSize);
+ std::vector<std::thread> threads;
+ for (int i = 0; i < kNumTestThreads; i++) {
+ std::generate(data.begin(), data.end(),
+ [&dist, &gen]() { return dist(gen); });
+ threads.emplace_back(worker, client_, data);
+ }
+
+ // Wait for threads to finish.
+ for (auto& thread : threads)
+ thread.join();
+}
+
+} // namespace
diff --git a/libs/vr/libpdx_uds/ipc_helper.cpp b/libs/vr/libpdx_uds/ipc_helper.cpp
index d604f62..d75ce86 100644
--- a/libs/vr/libpdx_uds/ipc_helper.cpp
+++ b/libs/vr/libpdx_uds/ipc_helper.cpp
@@ -18,6 +18,150 @@
namespace pdx {
namespace uds {
+namespace {
+
+// Default implementations of Send/Receive interfaces to use standard socket
+// send/sendmsg/recv/recvmsg functions.
+class SocketSender : public SendInterface {
+ public:
+ ssize_t Send(int socket_fd, const void* data, size_t size,
+ int flags) override {
+ return send(socket_fd, data, size, flags);
+ }
+ ssize_t SendMessage(int socket_fd, const msghdr* msg, int flags) override {
+ return sendmsg(socket_fd, msg, flags);
+ }
+} g_socket_sender;
+
+class SocketReceiver : public RecvInterface {
+ public:
+ ssize_t Receive(int socket_fd, void* data, size_t size, int flags) override {
+ return recv(socket_fd, data, size, flags);
+ }
+ ssize_t ReceiveMessage(int socket_fd, msghdr* msg, int flags) override {
+ return recvmsg(socket_fd, msg, flags);
+ }
+} g_socket_receiver;
+
+} // anonymous namespace
+
+// Helper wrappers around send()/sendmsg() which repeat send() calls on data
+// that was not sent with the initial call to send/sendmsg. This is important to
+// handle transmissions interrupted by signals.
+Status<void> SendAll(SendInterface* sender, const BorrowedHandle& socket_fd,
+ const void* data, size_t size) {
+ Status<void> ret;
+ const uint8_t* ptr = static_cast<const uint8_t*>(data);
+ while (size > 0) {
+ ssize_t size_written =
+ RETRY_EINTR(sender->Send(socket_fd.Get(), ptr, size, MSG_NOSIGNAL));
+ if (size_written < 0) {
+ ret.SetError(errno);
+ ALOGE("SendAll: Failed to send data over socket: %s",
+ ret.GetErrorMessage().c_str());
+ break;
+ }
+ size -= size_written;
+ ptr += size_written;
+ }
+ return ret;
+}
+
+Status<void> SendMsgAll(SendInterface* sender, const BorrowedHandle& socket_fd,
+ const msghdr* msg) {
+ Status<void> ret;
+ ssize_t sent_size =
+ RETRY_EINTR(sender->SendMessage(socket_fd.Get(), msg, MSG_NOSIGNAL));
+ if (sent_size < 0) {
+ ret.SetError(errno);
+ ALOGE("SendMsgAll: Failed to send data over socket: %s",
+ ret.GetErrorMessage().c_str());
+ return ret;
+ }
+
+ ssize_t chunk_start_offset = 0;
+ for (size_t i = 0; i < msg->msg_iovlen; i++) {
+ ssize_t chunk_end_offset = chunk_start_offset + msg->msg_iov[i].iov_len;
+ if (sent_size < chunk_end_offset) {
+ size_t offset_within_chunk = sent_size - chunk_start_offset;
+ size_t data_size = msg->msg_iov[i].iov_len - offset_within_chunk;
+ const uint8_t* chunk_base =
+ static_cast<const uint8_t*>(msg->msg_iov[i].iov_base);
+ ret = SendAll(sender, socket_fd, chunk_base + offset_within_chunk,
+ data_size);
+ if (!ret)
+ break;
+ sent_size += data_size;
+ }
+ chunk_start_offset = chunk_end_offset;
+ }
+ return ret;
+}
+
+// Helper wrappers around recv()/recvmsg() which repeat recv() calls on data
+// that was not received with the initial call to recvmsg(). This is important
+// to handle transmissions interrupted by signals as well as the case when
+// initial data did not arrive in a single chunk over the socket (e.g. socket
+// buffer was full at the time of transmission, and only portion of initial
+// message was sent and the rest was blocked until the buffer was cleared by the
+// receiving side).
+Status<void> RecvMsgAll(RecvInterface* receiver,
+ const BorrowedHandle& socket_fd, msghdr* msg) {
+ Status<void> ret;
+ ssize_t size_read = RETRY_EINTR(receiver->ReceiveMessage(
+ socket_fd.Get(), msg, MSG_WAITALL | MSG_CMSG_CLOEXEC));
+ if (size_read < 0) {
+ ret.SetError(errno);
+ ALOGE("RecvMsgAll: Failed to receive data from socket: %s",
+ ret.GetErrorMessage().c_str());
+ return ret;
+ } else if (size_read == 0) {
+ ret.SetError(ESHUTDOWN);
+ ALOGW("RecvMsgAll: Socket has been shut down");
+ return ret;
+ }
+
+ ssize_t chunk_start_offset = 0;
+ for (size_t i = 0; i < msg->msg_iovlen; i++) {
+ ssize_t chunk_end_offset = chunk_start_offset + msg->msg_iov[i].iov_len;
+ if (size_read < chunk_end_offset) {
+ size_t offset_within_chunk = size_read - chunk_start_offset;
+ size_t data_size = msg->msg_iov[i].iov_len - offset_within_chunk;
+ uint8_t* chunk_base = static_cast<uint8_t*>(msg->msg_iov[i].iov_base);
+ ret = RecvAll(receiver, socket_fd, chunk_base + offset_within_chunk,
+ data_size);
+ if (!ret)
+ break;
+ size_read += data_size;
+ }
+ chunk_start_offset = chunk_end_offset;
+ }
+ return ret;
+}
+
+Status<void> RecvAll(RecvInterface* receiver, const BorrowedHandle& socket_fd,
+ void* data, size_t size) {
+ Status<void> ret;
+ uint8_t* ptr = static_cast<uint8_t*>(data);
+ while (size > 0) {
+ ssize_t size_read = RETRY_EINTR(receiver->Receive(
+ socket_fd.Get(), ptr, size, MSG_WAITALL | MSG_CMSG_CLOEXEC));
+ if (size_read < 0) {
+ ret.SetError(errno);
+ ALOGE("RecvAll: Failed to receive data from socket: %s",
+ ret.GetErrorMessage().c_str());
+ break;
+ } else if (size_read == 0) {
+ ret.SetError(ESHUTDOWN);
+ ALOGW("RecvAll: Socket has been shut down");
+ break;
+ }
+ size -= size_read;
+ ptr += size_read;
+ }
+ return ret;
+}
+
uint32_t kMagicPreamble = 0x7564736d; // 'udsm'.
struct MessagePreamble {
@@ -32,17 +176,14 @@
Status<void> SendPayload::Send(const BorrowedHandle& socket_fd,
const ucred* cred) {
+ SendInterface* sender = sender_ ? sender_ : &g_socket_sender;
MessagePreamble preamble;
preamble.magic = kMagicPreamble;
preamble.data_size = buffer_.size();
preamble.fd_count = file_handles_.size();
-
- ssize_t ret = RETRY_EINTR(
- send(socket_fd.Get(), &preamble, sizeof(preamble), MSG_NOSIGNAL));
- if (ret < 0)
- return ErrorStatus(errno);
- if (ret != sizeof(preamble))
- return ErrorStatus(EIO);
+ Status<void> ret = SendAll(sender, socket_fd, &preamble, sizeof(preamble));
+ if (!ret)
+ return ret;
msghdr msg = {};
iovec recv_vect = {buffer_.data(), buffer_.size()};
@@ -72,12 +213,7 @@
}
}
- ret = RETRY_EINTR(sendmsg(socket_fd.Get(), &msg, MSG_NOSIGNAL));
- if (ret < 0)
- return ErrorStatus(errno);
- if (static_cast<size_t>(ret) != buffer_.size())
- return ErrorStatus(EIO);
- return {};
+ return SendMsgAll(sender, socket_fd, &msg);
}
// MessageWriter
@@ -132,15 +268,17 @@
Status<void> ReceivePayload::Receive(const BorrowedHandle& socket_fd,
ucred* cred) {
+ RecvInterface* receiver = receiver_ ? receiver_ : &g_socket_receiver;
MessagePreamble preamble;
- ssize_t ret = RETRY_EINTR(
- recv(socket_fd.Get(), &preamble, sizeof(preamble), MSG_WAITALL));
- if (ret < 0)
- return ErrorStatus(errno);
- else if (ret == 0)
- return ErrorStatus(ESHUTDOWN);
- else if (ret != sizeof(preamble) || preamble.magic != kMagicPreamble)
- return ErrorStatus(EIO);
+ Status<void> ret = RecvAll(receiver, socket_fd, &preamble, sizeof(preamble));
+ if (!ret)
+ return ret;
+
+ if (preamble.magic != kMagicPreamble) {
+ ALOGE("ReceivePayload::Receive: Message header is invalid");
+ ret.SetError(EIO);
+ return ret;
+ }
buffer_.resize(preamble.data_size);
file_handles_.clear();
@@ -159,13 +297,9 @@
msg.msg_control = alloca(msg.msg_controllen);
}
- ret = RETRY_EINTR(recvmsg(socket_fd.Get(), &msg, MSG_WAITALL));
- if (ret < 0)
- return ErrorStatus(errno);
- else if (ret == 0)
- return ErrorStatus(ESHUTDOWN);
- else if (static_cast<uint32_t>(ret) != preamble.data_size)
- return ErrorStatus(EIO);
+ ret = RecvMsgAll(receiver, socket_fd, &msg);
+ if (!ret)
+ return ret;
bool cred_available = false;
file_handles_.reserve(preamble.fd_count);
@@ -187,10 +321,11 @@
}
if (cred && !cred_available) {
- return ErrorStatus(EIO);
+ ALOGE("ReceivePayload::Receive: Failed to obtain message credentials");
+ ret.SetError(EIO);
}
- return {};
+ return ret;
}
// MessageReader
@@ -223,13 +358,7 @@
Status<void> SendData(const BorrowedHandle& socket_fd, const void* data,
size_t size) {
- ssize_t size_written =
- RETRY_EINTR(send(socket_fd.Get(), data, size, MSG_NOSIGNAL));
- if (size_written < 0)
- return ErrorStatus(errno);
- if (static_cast<size_t>(size_written) != size)
- return ErrorStatus(EIO);
- return {};
+ return SendAll(&g_socket_sender, socket_fd, data, size);
}
Status<void> SendDataVector(const BorrowedHandle& socket_fd, const iovec* data,
@@ -237,26 +366,12 @@
msghdr msg = {};
msg.msg_iov = const_cast<iovec*>(data);
msg.msg_iovlen = count;
- ssize_t size_written =
- RETRY_EINTR(sendmsg(socket_fd.Get(), &msg, MSG_NOSIGNAL));
- if (size_written < 0)
- return ErrorStatus(errno);
- if (static_cast<size_t>(size_written) != CountVectorSize(data, count))
- return ErrorStatus(EIO);
- return {};
+ return SendMsgAll(&g_socket_sender, socket_fd, &msg);
}
Status<void> ReceiveData(const BorrowedHandle& socket_fd, void* data,
size_t size) {
- ssize_t size_read =
- RETRY_EINTR(recv(socket_fd.Get(), data, size, MSG_WAITALL));
- if (size_read < 0)
- return ErrorStatus(errno);
- else if (size_read == 0)
- return ErrorStatus(ESHUTDOWN);
- else if (static_cast<size_t>(size_read) != size)
- return ErrorStatus(EIO);
- return {};
+ return RecvAll(&g_socket_receiver, socket_fd, data, size);
}
Status<void> ReceiveDataVector(const BorrowedHandle& socket_fd,
@@ -264,14 +379,7 @@
msghdr msg = {};
msg.msg_iov = const_cast<iovec*>(data);
msg.msg_iovlen = count;
- ssize_t size_read = RETRY_EINTR(recvmsg(socket_fd.Get(), &msg, MSG_WAITALL));
- if (size_read < 0)
- return ErrorStatus(errno);
- else if (size_read == 0)
- return ErrorStatus(ESHUTDOWN);
- else if (static_cast<size_t>(size_read) != CountVectorSize(data, count))
- return ErrorStatus(EIO);
- return {};
+ return RecvMsgAll(&g_socket_receiver, socket_fd, &msg);
}
size_t CountVectorSize(const iovec* vector, size_t count) {
diff --git a/libs/vr/libpdx_uds/ipc_helper_tests.cpp b/libs/vr/libpdx_uds/ipc_helper_tests.cpp
new file mode 100644
index 0000000..bfa827e
--- /dev/null
+++ b/libs/vr/libpdx_uds/ipc_helper_tests.cpp
@@ -0,0 +1,365 @@
+#include "uds/ipc_helper.h"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+using testing::Return;
+using testing::SetErrnoAndReturn;
+using testing::_;
+
+using android::pdx::BorrowedHandle;
+using android::pdx::uds::SendInterface;
+using android::pdx::uds::RecvInterface;
+using android::pdx::uds::SendAll;
+using android::pdx::uds::SendMsgAll;
+using android::pdx::uds::RecvAll;
+using android::pdx::uds::RecvMsgAll;
+
+namespace {
+
+// Useful constants for tests.
+static constexpr intptr_t kPtr = 1234;
+static constexpr int kSocketFd = 5678;
+static const BorrowedHandle kSocket{kSocketFd};
+
+// Helper functions to construct test data pointer values.
+void* IntToPtr(intptr_t value) { return reinterpret_cast<void*>(value); }
+const void* IntToConstPtr(intptr_t value) {
+ return reinterpret_cast<const void*>(value);
+}
+
+// Mock classes for SendInterface/RecvInterface.
+class MockSender : public SendInterface {
+ public:
+ MOCK_METHOD4(Send, ssize_t(int socket_fd, const void* data, size_t size,
+ int flags));
+ MOCK_METHOD3(SendMessage,
+ ssize_t(int socket_fd, const msghdr* msg, int flags));
+};
+
+class MockReceiver : public RecvInterface {
+ public:
+ MOCK_METHOD4(Receive,
+ ssize_t(int socket_fd, void* data, size_t size, int flags));
+ MOCK_METHOD3(ReceiveMessage, ssize_t(int socket_fd, msghdr* msg, int flags));
+};
+
+// Test case classes.
+class SendTest : public testing::Test {
+ public:
+ SendTest() {
+ ON_CALL(sender_, Send(_, _, _, _))
+ .WillByDefault(SetErrnoAndReturn(EIO, -1));
+ ON_CALL(sender_, SendMessage(_, _, _))
+ .WillByDefault(SetErrnoAndReturn(EIO, -1));
+ }
+
+ protected:
+ MockSender sender_;
+};
+
+class RecvTest : public testing::Test {
+ public:
+ RecvTest() {
+ ON_CALL(receiver_, Receive(_, _, _, _))
+ .WillByDefault(SetErrnoAndReturn(EIO, -1));
+ ON_CALL(receiver_, ReceiveMessage(_, _, _))
+ .WillByDefault(SetErrnoAndReturn(EIO, -1));
+ }
+
+ protected:
+ MockReceiver receiver_;
+};
+
+class MessageTestBase : public testing::Test {
+ public:
+ MessageTestBase() {
+ memset(&msg_, 0, sizeof(msg_));
+ msg_.msg_iovlen = data_.size();
+ msg_.msg_iov = data_.data();
+ }
+
+ protected:
+ static constexpr intptr_t kPtr1 = kPtr;
+ static constexpr intptr_t kPtr2 = kPtr + 200;
+ static constexpr intptr_t kPtr3 = kPtr + 1000;
+
+ MockSender sender_;
+ msghdr msg_;
+ std::vector<iovec> data_{
+ {IntToPtr(kPtr1), 100}, {IntToPtr(kPtr2), 200}, {IntToPtr(kPtr3), 300}};
+};
+
+class SendMessageTest : public MessageTestBase {
+ public:
+ SendMessageTest() {
+ ON_CALL(sender_, Send(_, _, _, _))
+ .WillByDefault(SetErrnoAndReturn(EIO, -1));
+ ON_CALL(sender_, SendMessage(_, _, _))
+ .WillByDefault(SetErrnoAndReturn(EIO, -1));
+ }
+
+ protected:
+ MockSender sender_;
+};
+
+class RecvMessageTest : public MessageTestBase {
+ public:
+ RecvMessageTest() {
+ ON_CALL(receiver_, Receive(_, _, _, _))
+ .WillByDefault(SetErrnoAndReturn(EIO, -1));
+ ON_CALL(receiver_, ReceiveMessage(_, _, _))
+ .WillByDefault(SetErrnoAndReturn(EIO, -1));
+ }
+
+ protected:
+ MockReceiver receiver_;
+};
+
+// Actual tests.
+
+// SendAll
+TEST_F(SendTest, Complete) {
+ EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr), 100, MSG_NOSIGNAL))
+ .WillOnce(Return(100));
+
+ auto status = SendAll(&sender_, kSocket, IntToConstPtr(kPtr), 100);
+ EXPECT_TRUE(status);
+}
+
+TEST_F(SendTest, Signal) {
+ EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr), 100, MSG_NOSIGNAL))
+ .WillOnce(Return(20));
+ EXPECT_CALL(sender_,
+ Send(kSocketFd, IntToConstPtr(kPtr + 20), 80, MSG_NOSIGNAL))
+ .WillOnce(Return(40));
+ EXPECT_CALL(sender_,
+ Send(kSocketFd, IntToConstPtr(kPtr + 60), 40, MSG_NOSIGNAL))
+ .WillOnce(Return(40));
+
+ auto status = SendAll(&sender_, kSocket, IntToConstPtr(kPtr), 100);
+ EXPECT_TRUE(status);
+}
+
+TEST_F(SendTest, Eintr) {
+ EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr), 100, MSG_NOSIGNAL))
+ .WillOnce(SetErrnoAndReturn(EINTR, -1))
+ .WillOnce(Return(100));
+
+ auto status = SendAll(&sender_, kSocket, IntToConstPtr(kPtr), 100);
+ EXPECT_TRUE(status);
+}
+
+TEST_F(SendTest, Error) {
+ EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr), 100, MSG_NOSIGNAL))
+ .WillOnce(SetErrnoAndReturn(EIO, -1));
+
+ auto status = SendAll(&sender_, kSocket, IntToConstPtr(kPtr), 100);
+ ASSERT_FALSE(status);
+ EXPECT_EQ(EIO, status.error());
+}
+
+TEST_F(SendTest, Error2) {
+ EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr), 100, MSG_NOSIGNAL))
+ .WillOnce(Return(50));
+ EXPECT_CALL(sender_,
+ Send(kSocketFd, IntToConstPtr(kPtr + 50), 50, MSG_NOSIGNAL))
+ .WillOnce(SetErrnoAndReturn(EIO, -1));
+
+ auto status = SendAll(&sender_, kSocket, IntToConstPtr(kPtr), 100);
+ ASSERT_FALSE(status);
+ EXPECT_EQ(EIO, status.error());
+}
+
+// RecvAll
+TEST_F(RecvTest, Complete) {
+ EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr), 100,
+ MSG_WAITALL | MSG_CMSG_CLOEXEC))
+ .WillOnce(Return(100));
+
+ auto status = RecvAll(&receiver_, kSocket, IntToPtr(kPtr), 100);
+ EXPECT_TRUE(status);
+}
+
+TEST_F(RecvTest, Signal) {
+ EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr), 100, _))
+ .WillOnce(Return(20));
+ EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr + 20), 80, _))
+ .WillOnce(Return(40));
+ EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr + 60), 40, _))
+ .WillOnce(Return(40));
+
+ auto status = RecvAll(&receiver_, kSocket, IntToPtr(kPtr), 100);
+ EXPECT_TRUE(status);
+}
+
+TEST_F(RecvTest, Eintr) {
+ EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr), 100, _))
+ .WillOnce(SetErrnoAndReturn(EINTR, -1))
+ .WillOnce(Return(100));
+
+ auto status = RecvAll(&receiver_, kSocket, IntToPtr(kPtr), 100);
+ EXPECT_TRUE(status);
+}
+
+TEST_F(RecvTest, Error) {
+ EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr), 100, _))
+ .WillOnce(SetErrnoAndReturn(EIO, -1));
+
+ auto status = RecvAll(&receiver_, kSocket, IntToPtr(kPtr), 100);
+ ASSERT_FALSE(status);
+ EXPECT_EQ(EIO, status.error());
+}
+
+TEST_F(RecvTest, Error2) {
+ EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr), 100, _))
+ .WillOnce(Return(30));
+ EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr + 30), 70, _))
+ .WillOnce(SetErrnoAndReturn(EIO, -1));
+
+ auto status = RecvAll(&receiver_, kSocket, IntToPtr(kPtr), 100);
+ ASSERT_FALSE(status);
+ EXPECT_EQ(EIO, status.error());
+}
+
+// SendMsgAll
+TEST_F(SendMessageTest, Complete) {
+ EXPECT_CALL(sender_, SendMessage(kSocketFd, &msg_, MSG_NOSIGNAL))
+ .WillOnce(Return(600));
+
+ auto status = SendMsgAll(&sender_, kSocket, &msg_);
+ EXPECT_TRUE(status);
+}
+
+TEST_F(SendMessageTest, Partial) {
+ EXPECT_CALL(sender_, SendMessage(kSocketFd, &msg_, _)).WillOnce(Return(70));
+ EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr1 + 70), 30, _))
+ .WillOnce(Return(30));
+ EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr2), 200, _))
+ .WillOnce(Return(190));
+ EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr2 + 190), 10, _))
+ .WillOnce(Return(10));
+ EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr3), 300, _))
+ .WillOnce(Return(300));
+
+ auto status = SendMsgAll(&sender_, kSocket, &msg_);
+ EXPECT_TRUE(status);
+}
+
+TEST_F(SendMessageTest, Partial2) {
+ EXPECT_CALL(sender_, SendMessage(kSocketFd, &msg_, _)).WillOnce(Return(310));
+ EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr3 + 10), 290, _))
+ .WillOnce(Return(290));
+
+ auto status = SendMsgAll(&sender_, kSocket, &msg_);
+ EXPECT_TRUE(status);
+}
+
+TEST_F(SendMessageTest, Eintr) {
+ EXPECT_CALL(sender_, SendMessage(kSocketFd, &msg_, _))
+ .WillOnce(SetErrnoAndReturn(EINTR, -1))
+ .WillOnce(Return(70));
+ EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr1 + 70), 30, _))
+ .WillOnce(SetErrnoAndReturn(EINTR, -1))
+ .WillOnce(Return(30));
+ EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr2), 200, _))
+ .WillOnce(Return(200));
+ EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr3), 300, _))
+ .WillOnce(Return(300));
+
+ auto status = SendMsgAll(&sender_, kSocket, &msg_);
+ EXPECT_TRUE(status);
+}
+
+TEST_F(SendMessageTest, Error) {
+ EXPECT_CALL(sender_, SendMessage(kSocketFd, &msg_, _))
+ .WillOnce(SetErrnoAndReturn(EBADF, -1));
+
+ auto status = SendMsgAll(&sender_, kSocket, &msg_);
+ ASSERT_FALSE(status);
+ EXPECT_EQ(EBADF, status.error());
+}
+
+TEST_F(SendMessageTest, Error2) {
+ EXPECT_CALL(sender_, SendMessage(kSocketFd, &msg_, _)).WillOnce(Return(20));
+ EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr1 + 20), 80, _))
+ .WillOnce(SetErrnoAndReturn(EBADF, -1));
+
+ auto status = SendMsgAll(&sender_, kSocket, &msg_);
+ ASSERT_FALSE(status);
+ EXPECT_EQ(EBADF, status.error());
+}
+
+// RecvMsgAll
+TEST_F(RecvMessageTest, Complete) {
+ EXPECT_CALL(receiver_,
+ ReceiveMessage(kSocketFd, &msg_, MSG_WAITALL | MSG_CMSG_CLOEXEC))
+ .WillOnce(Return(600));
+
+ auto status = RecvMsgAll(&receiver_, kSocket, &msg_);
+ EXPECT_TRUE(status);
+}
+
+TEST_F(RecvMessageTest, Partial) {
+ EXPECT_CALL(receiver_, ReceiveMessage(kSocketFd, &msg_, _))
+ .WillOnce(Return(70));
+ EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr1 + 70), 30, _))
+ .WillOnce(Return(30));
+ EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr2), 200, _))
+ .WillOnce(Return(190));
+ EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr2 + 190), 10, _))
+ .WillOnce(Return(10));
+ EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr3), 300, _))
+ .WillOnce(Return(300));
+
+ auto status = RecvMsgAll(&receiver_, kSocket, &msg_);
+ EXPECT_TRUE(status);
+}
+
+TEST_F(RecvMessageTest, Partial2) {
+ EXPECT_CALL(receiver_, ReceiveMessage(kSocketFd, &msg_, _))
+ .WillOnce(Return(310));
+ EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr3 + 10), 290, _))
+ .WillOnce(Return(290));
+
+ auto status = RecvMsgAll(&receiver_, kSocket, &msg_);
+ EXPECT_TRUE(status);
+}
+
+TEST_F(RecvMessageTest, Eintr) {
+ EXPECT_CALL(receiver_, ReceiveMessage(kSocketFd, &msg_, _))
+ .WillOnce(SetErrnoAndReturn(EINTR, -1))
+ .WillOnce(Return(70));
+ EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr1 + 70), 30, _))
+ .WillOnce(SetErrnoAndReturn(EINTR, -1))
+ .WillOnce(Return(30));
+ EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr2), 200, _))
+ .WillOnce(Return(200));
+ EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr3), 300, _))
+ .WillOnce(Return(300));
+
+ auto status = RecvMsgAll(&receiver_, kSocket, &msg_);
+ EXPECT_TRUE(status);
+}
+
+TEST_F(RecvMessageTest, Error) {
+ EXPECT_CALL(receiver_, ReceiveMessage(kSocketFd, &msg_, _))
+ .WillOnce(SetErrnoAndReturn(EBADF, -1));
+
+ auto status = RecvMsgAll(&receiver_, kSocket, &msg_);
+ ASSERT_FALSE(status);
+ EXPECT_EQ(EBADF, status.error());
+}
+
+TEST_F(RecvMessageTest, Error2) {
+ EXPECT_CALL(receiver_, ReceiveMessage(kSocketFd, &msg_, _))
+ .WillOnce(Return(20));
+ EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr1 + 20), 80, _))
+ .WillOnce(SetErrnoAndReturn(EBADF, -1));
+
+ auto status = RecvMsgAll(&receiver_, kSocket, &msg_);
+ ASSERT_FALSE(status);
+ EXPECT_EQ(EBADF, status.error());
+}
+
+} // namespace
diff --git a/libs/vr/libpdx_uds/private/uds/client_channel.h b/libs/vr/libpdx_uds/private/uds/client_channel.h
index 45f6473..8f607f5 100644
--- a/libs/vr/libpdx_uds/private/uds/client_channel.h
+++ b/libs/vr/libpdx_uds/private/uds/client_channel.h
@@ -3,6 +3,8 @@
#include <pdx/client_channel.h>
+#include <mutex>
+
#include <uds/channel_event_set.h>
#include <uds/channel_manager.h>
#include <uds/service_endpoint.h>
@@ -73,6 +75,7 @@
LocalChannelHandle channel_handle_;
ChannelManager::ChannelData* channel_data_;
+ std::mutex socket_mutex_;
};
} // namespace uds
diff --git a/libs/vr/libpdx_uds/private/uds/client_channel_factory.h b/libs/vr/libpdx_uds/private/uds/client_channel_factory.h
index 6f80d31..c43c5c7 100644
--- a/libs/vr/libpdx_uds/private/uds/client_channel_factory.h
+++ b/libs/vr/libpdx_uds/private/uds/client_channel_factory.h
@@ -13,6 +13,7 @@
public:
static std::unique_ptr<pdx::ClientChannelFactory> Create(
const std::string& endpoint_path);
+ static std::unique_ptr<pdx::ClientChannelFactory> Create(LocalHandle socket);
Status<std::unique_ptr<pdx::ClientChannel>> Connect(
int64_t timeout_ms) const override;
@@ -22,7 +23,9 @@
private:
explicit ClientChannelFactory(const std::string& endpoint_path);
+ explicit ClientChannelFactory(LocalHandle socket);
+ mutable LocalHandle socket_;
std::string endpoint_path_;
};
diff --git a/libs/vr/libpdx_uds/private/uds/ipc_helper.h b/libs/vr/libpdx_uds/private/uds/ipc_helper.h
index 82950a2..5b7e5ff 100644
--- a/libs/vr/libpdx_uds/private/uds/ipc_helper.h
+++ b/libs/vr/libpdx_uds/private/uds/ipc_helper.h
@@ -14,6 +14,38 @@
namespace pdx {
namespace uds {
+// Test interfaces used for unit-testing payload sending/receiving over sockets.
+class SendInterface {
+ public:
+ virtual ssize_t Send(int socket_fd, const void* data, size_t size,
+ int flags) = 0;
+ virtual ssize_t SendMessage(int socket_fd, const msghdr* msg, int flags) = 0;
+
+ protected:
+ virtual ~SendInterface() = default;
+};
+
+class RecvInterface {
+ public:
+ virtual ssize_t Receive(int socket_fd, void* data, size_t size,
+ int flags) = 0;
+ virtual ssize_t ReceiveMessage(int socket_fd, msghdr* msg, int flags) = 0;
+
+ protected:
+ virtual ~RecvInterface() = default;
+};
+
+// Helper methods that allow to send/receive data through abstract interfaces.
+// Useful for mocking out the underlying socket I/O.
+Status<void> SendAll(SendInterface* sender, const BorrowedHandle& socket_fd,
+ const void* data, size_t size);
+Status<void> SendMsgAll(SendInterface* sender, const BorrowedHandle& socket_fd,
+ const msghdr* msg);
+Status<void> RecvAll(RecvInterface* receiver, const BorrowedHandle& socket_fd,
+ void* data, size_t size);
+Status<void> RecvMsgAll(RecvInterface* receiver,
+ const BorrowedHandle& socket_fd, msghdr* msg);
+
#define RETRY_EINTR(fnc_call) \
([&]() -> decltype(fnc_call) { \
decltype(fnc_call) result; \
@@ -25,6 +57,7 @@
class SendPayload : public MessageWriter, public OutputResourceMapper {
public:
+ SendPayload(SendInterface* sender = nullptr) : sender_{sender} {}
Status<void> Send(const BorrowedHandle& socket_fd);
Status<void> Send(const BorrowedHandle& socket_fd, const ucred* cred);
@@ -44,12 +77,14 @@
const RemoteChannelHandle& handle) override;
private:
+ SendInterface* sender_;
ByteBuffer buffer_;
std::vector<int> file_handles_;
};
class ReceivePayload : public MessageReader, public InputResourceMapper {
public:
+ ReceivePayload(RecvInterface* receiver = nullptr) : receiver_{receiver} {}
Status<void> Receive(const BorrowedHandle& socket_fd);
Status<void> Receive(const BorrowedHandle& socket_fd, ucred* cred);
@@ -64,6 +99,7 @@
LocalChannelHandle* handle) override;
private:
+ RecvInterface* receiver_;
ByteBuffer buffer_;
std::vector<LocalHandle> file_handles_;
size_t read_pos_{0};
diff --git a/libs/vr/libpdx_uds/private/uds/service_endpoint.h b/libs/vr/libpdx_uds/private/uds/service_endpoint.h
index f747abc..eb87827 100644
--- a/libs/vr/libpdx_uds/private/uds/service_endpoint.h
+++ b/libs/vr/libpdx_uds/private/uds/service_endpoint.h
@@ -97,6 +97,14 @@
static std::unique_ptr<Endpoint> CreateAndBindSocket(
const std::string& endpoint_path, bool blocking = kDefaultBlocking);
+ // Helper method to create an endpoint from an existing socket FD.
+ // Mostly helpful for tests.
+ static std::unique_ptr<Endpoint> CreateFromSocketFd(LocalHandle socket_fd);
+
+ // Test helper method to register a new channel identified by |channel_fd|
+ // socket file descriptor.
+ Status<void> RegisterNewChannelForTests(LocalHandle channel_fd);
+
int epoll_fd() const { return epoll_fd_.Get(); }
private:
@@ -109,6 +117,9 @@
// This class must be instantiated using Create() static methods above.
Endpoint(const std::string& endpoint_path, bool blocking,
bool use_init_socket_fd = true);
+ Endpoint(LocalHandle socket_fd);
+
+ void Init(LocalHandle socket_fd);
Endpoint(const Endpoint&) = delete;
void operator=(const Endpoint&) = delete;
diff --git a/libs/vr/libpdx_uds/service_endpoint.cpp b/libs/vr/libpdx_uds/service_endpoint.cpp
index 65fd59f..6c92259 100644
--- a/libs/vr/libpdx_uds/service_endpoint.cpp
+++ b/libs/vr/libpdx_uds/service_endpoint.cpp
@@ -161,9 +161,16 @@
bind(fd.Get(), reinterpret_cast<sockaddr*>(&local), sizeof(local));
CHECK_EQ(ret, 0) << "Endpoint::Endpoint: bind error: " << strerror(errno);
}
- CHECK_EQ(listen(fd.Get(), kMaxBackLogForSocketListen), 0)
- << "Endpoint::Endpoint: listen error: " << strerror(errno);
+ Init(std::move(fd));
+}
+Endpoint::Endpoint(LocalHandle socket_fd) { Init(std::move(socket_fd)); }
+
+void Endpoint::Init(LocalHandle socket_fd) {
+ if (socket_fd) {
+ CHECK_EQ(listen(socket_fd.Get(), kMaxBackLogForSocketListen), 0)
+ << "Endpoint::Endpoint: listen error: " << strerror(errno);
+ }
cancel_event_fd_.Reset(eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK));
CHECK(cancel_event_fd_.IsValid())
<< "Endpoint::Endpoint: Failed to create event fd: " << strerror(errno);
@@ -172,24 +179,27 @@
CHECK(epoll_fd_.IsValid())
<< "Endpoint::Endpoint: Failed to create epoll fd: " << strerror(errno);
- epoll_event socket_event;
- socket_event.events = EPOLLIN | EPOLLRDHUP | EPOLLONESHOT;
- socket_event.data.fd = fd.Get();
+ if (socket_fd) {
+ epoll_event socket_event;
+ socket_event.events = EPOLLIN | EPOLLRDHUP | EPOLLONESHOT;
+ socket_event.data.fd = socket_fd.Get();
+ int ret = epoll_ctl(epoll_fd_.Get(), EPOLL_CTL_ADD, socket_fd.Get(),
+ &socket_event);
+ CHECK_EQ(ret, 0)
+ << "Endpoint::Endpoint: Failed to add socket fd to epoll fd: "
+ << strerror(errno);
+ }
epoll_event cancel_event;
cancel_event.events = EPOLLIN;
cancel_event.data.fd = cancel_event_fd_.Get();
- int ret = epoll_ctl(epoll_fd_.Get(), EPOLL_CTL_ADD, fd.Get(), &socket_event);
- CHECK_EQ(ret, 0)
- << "Endpoint::Endpoint: Failed to add socket fd to epoll fd: "
- << strerror(errno);
- ret = epoll_ctl(epoll_fd_.Get(), EPOLL_CTL_ADD, cancel_event_fd_.Get(),
- &cancel_event);
+ int ret = epoll_ctl(epoll_fd_.Get(), EPOLL_CTL_ADD, cancel_event_fd_.Get(),
+ &cancel_event);
CHECK_EQ(ret, 0)
<< "Endpoint::Endpoint: Failed to add cancel event fd to epoll fd: "
<< strerror(errno);
- socket_fd_ = std::move(fd);
+ socket_fd_ = std::move(socket_fd);
}
void* Endpoint::AllocateMessageState() { return new MessageState; }
@@ -199,6 +209,9 @@
}
Status<void> Endpoint::AcceptConnection(Message* message) {
+ if (!socket_fd_)
+ return ErrorStatus(EBADF);
+
sockaddr_un remote;
socklen_t addrlen = sizeof(remote);
LocalHandle channel_fd{accept4(socket_fd_.Get(),
@@ -515,7 +528,7 @@
return ErrorStatus{ESHUTDOWN};
}
- if (event.data.fd == socket_fd_.Get()) {
+ if (socket_fd_ && event.data.fd == socket_fd_.Get()) {
auto status = AcceptConnection(message);
if (!status)
return status;
@@ -680,6 +693,23 @@
new Endpoint(endpoint_path, blocking, false));
}
+std::unique_ptr<Endpoint> Endpoint::CreateFromSocketFd(LocalHandle socket_fd) {
+ return std::unique_ptr<Endpoint>(new Endpoint(std::move(socket_fd)));
+}
+
+Status<void> Endpoint::RegisterNewChannelForTests(LocalHandle channel_fd) {
+ int optval = 1;
+ if (setsockopt(channel_fd.Get(), SOL_SOCKET, SO_PASSCRED, &optval,
+ sizeof(optval)) == -1) {
+ ALOGE(
+ "Endpoint::RegisterNewChannelForTests: Failed to enable the receiving"
+ "of the credentials for channel %d: %s",
+ channel_fd.Get(), strerror(errno));
+ return ErrorStatus(errno);
+ }
+ return OnNewChannel(std::move(channel_fd));
+}
+
} // namespace uds
} // namespace pdx
} // namespace android
diff --git a/libs/vr/libvrflinger/compositor.cpp b/libs/vr/libvrflinger/compositor.cpp
index aa01f22..239ef75 100644
--- a/libs/vr/libvrflinger/compositor.cpp
+++ b/libs/vr/libvrflinger/compositor.cpp
@@ -246,16 +246,17 @@
class Compositor::RenderPoseBufferObject {
public:
- RenderPoseBufferObject(LocalHandle&& render_pose_buffer_fd) {
+ RenderPoseBufferObject(LocalHandle&& render_pose_buffer_fd) :
+ fd_(std::move(render_pose_buffer_fd)) {
// Create new pose tracking buffer for this surface.
glGenBuffers(1, &render_pose_buffer_object_);
glBindBuffer(GL_UNIFORM_BUFFER, render_pose_buffer_object_);
- if (render_pose_buffer_fd) {
+ if (fd_) {
LOG_ALWAYS_FATAL_IF(!glBindSharedBufferQCOM);
if (glBindSharedBufferQCOM)
glBindSharedBufferQCOM(GL_UNIFORM_BUFFER,
sizeof(DisplaySurfaceMetadata),
- render_pose_buffer_fd.Get());
+ fd_.Get());
else
ALOGE("Error: Missing gralloc buffer extension");
CHECK_GL();
@@ -271,6 +272,7 @@
// Render pose buffer object. This contains an array of poses that corresponds
// with the surface buffers.
GLuint render_pose_buffer_object_;
+ LocalHandle fd_;
RenderPoseBufferObject(const RenderPoseBufferObject&) = delete;
void operator=(const RenderPoseBufferObject&) = delete;
@@ -403,6 +405,7 @@
}
load_gl_extensions();
+ GpuProfiler::Get()->OnGlContextCreated();
glEnable(BINNING_CONTROL_HINT_QCOM);
glHint(BINNING_CONTROL_HINT_QCOM, RENDER_DIRECT_TO_FRAMEBUFFER_QCOM);
@@ -428,6 +431,7 @@
}
void Compositor::Shutdown() {
+ glFinish();
render_target_[0].Destroy();
render_target_[1].Destroy();
layers_.clear();
@@ -438,6 +442,7 @@
eds_renderer_.reset();
if (context_) {
+ GpuProfiler::Get()->OnGlContextDestroyed();
eglDestroyContext(display_, context_);
context_ = 0;
}
diff --git a/libs/vr/libvrflinger/display_service.cpp b/libs/vr/libvrflinger/display_service.cpp
index 5cdb3bb..d3d50d0 100644
--- a/libs/vr/libvrflinger/display_service.cpp
+++ b/libs/vr/libvrflinger/display_service.cpp
@@ -208,16 +208,16 @@
// We should always have a red distortion.
LOG_FATAL_IF(view_params.distortion_coefficients_r.empty());
- red_distortion = std::make_shared<PolynomialRadialDistortion>(0.0f,
+ red_distortion = std::make_shared<PolynomialRadialDistortion>(
view_params.distortion_coefficients_r);
if (!view_params.distortion_coefficients_g.empty()) {
- green_distortion = std::make_shared<PolynomialRadialDistortion>(0.0f,
+ green_distortion = std::make_shared<PolynomialRadialDistortion>(
view_params.distortion_coefficients_g);
}
if (!view_params.distortion_coefficients_b.empty()) {
- blue_distortion = std::make_shared<PolynomialRadialDistortion>(0.0f,
+ blue_distortion = std::make_shared<PolynomialRadialDistortion>(
view_params.distortion_coefficients_b);
}
@@ -331,11 +331,9 @@
int consumer_usage) {
auto named_buffer = named_buffers_.find(name);
if (named_buffer == named_buffers_.end()) {
- // TODO(hendrikw): Update BufferProducer to take producer_usage and
- // consumer_usage flags.
auto ion_buffer = std::make_unique<IonBuffer>(
- static_cast<int>(size), 1, HAL_PIXEL_FORMAT_BLOB,
- producer_usage | consumer_usage);
+ static_cast<int>(size), 1, HAL_PIXEL_FORMAT_BLOB, producer_usage,
+ consumer_usage);
named_buffer =
named_buffers_.insert(std::make_pair(name, std::move(ion_buffer)))
.first;
diff --git a/opengl/libs/EGL/eglApi.cpp b/opengl/libs/EGL/eglApi.cpp
index 0807d1f..9de15d0 100644
--- a/opengl/libs/EGL/eglApi.cpp
+++ b/opengl/libs/EGL/eglApi.cpp
@@ -223,6 +223,10 @@
(__eglMustCastToProperFunctionPointerType)&eglGetFrameTimestampsANDROID },
{ "eglGetFrameTimestampSupportedANDROID",
(__eglMustCastToProperFunctionPointerType)&eglGetFrameTimestampSupportedANDROID },
+
+ // EGL_ANDROID_native_fence_sync
+ { "eglDupNativeFenceFDANDROID",
+ (__eglMustCastToProperFunctionPointerType)&eglDupNativeFenceFDANDROID },
};
/*
@@ -232,8 +236,7 @@
#define FILTER_EXTENSIONS(procname) \
(!strcmp((procname), "eglSetBlobCacheFuncsANDROID") || \
!strcmp((procname), "eglHibernateProcessIMG") || \
- !strcmp((procname), "eglAwakenProcessIMG") || \
- !strcmp((procname), "eglDupNativeFenceFDANDROID"))
+ !strcmp((procname), "eglAwakenProcessIMG"))
diff --git a/services/sensorservice/SensorDevice.cpp b/services/sensorservice/SensorDevice.cpp
index 080c02b..986c268 100644
--- a/services/sensorservice/SensorDevice.cpp
+++ b/services/sensorservice/SensorDevice.cpp
@@ -31,6 +31,7 @@
using namespace android::hardware::sensors::V1_0;
using namespace android::hardware::sensors::V1_0::implementation;
+
namespace android {
// ---------------------------------------------------------------------------
@@ -138,20 +139,19 @@
result.append("sampling_period(ms) = {");
for (size_t j = 0; j < info.batchParams.size(); j++) {
- const BatchParams& params = info.batchParams.valueAt(j);
- result.appendFormat("%.1f%s", params.batchDelay / 1e6f,
+ const BatchParams& params = info.batchParams[j];
+ result.appendFormat("%.1f%s", params.mTSample / 1e6f,
j < info.batchParams.size() - 1 ? ", " : "");
}
- result.appendFormat("}, selected = %.1f ms; ", info.bestBatchParams.batchDelay / 1e6f);
+ result.appendFormat("}, selected = %.2f ms; ", info.bestBatchParams.mTSample / 1e6f);
result.append("batching_period(ms) = {");
for (size_t j = 0; j < info.batchParams.size(); j++) {
- BatchParams params = info.batchParams.valueAt(j);
-
- result.appendFormat("%.1f%s", params.batchTimeout / 1e6f,
+ const BatchParams& params = info.batchParams[j];
+ result.appendFormat("%.1f%s", params.mTBatch / 1e6f,
j < info.batchParams.size() - 1 ? ", " : "");
}
- result.appendFormat("}, selected = %.1f ms\n", info.bestBatchParams.batchTimeout / 1e6f);
+ result.appendFormat("}, selected = %.2f ms\n", info.bestBatchParams.mTBatch / 1e6f);
}
return result.string();
@@ -270,13 +270,10 @@
// batch_rate and timeout. One of the apps has unregistered for sensor
// events, and the best effort batch parameters might have changed.
ALOGD_IF(DEBUG_CONNECTIONS,
- "\t>>> actuating h/w batch %d %d %" PRId64 " %" PRId64, handle,
- info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
- info.bestBatchParams.batchTimeout);
+ "\t>>> actuating h/w batch 0x%08x %" PRId64 " %" PRId64, handle,
+ info.bestBatchParams.mTSample, info.bestBatchParams.mTBatch);
checkReturn(mSensors->batch(
- handle,
- info.bestBatchParams.batchDelay,
- info.bestBatchParams.batchTimeout));
+ handle, info.bestBatchParams.mTSample, info.bestBatchParams.mTBatch));
}
} else {
// sensor wasn't enabled for this ident
@@ -314,6 +311,9 @@
if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {
samplingPeriodNs = MINIMUM_EVENTS_PERIOD;
}
+ if (maxBatchReportLatencyNs < 0) {
+ maxBatchReportLatencyNs = 0;
+ }
ALOGD_IF(DEBUG_CONNECTIONS,
"SensorDevice::batch: ident=%p, handle=0x%08x, flags=%d, period_ns=%" PRId64 " timeout=%" PRId64,
@@ -323,7 +323,7 @@
Info& info(mActivationCount.editValueFor(handle));
if (info.batchParams.indexOfKey(ident) < 0) {
- BatchParams params(flags, samplingPeriodNs, maxBatchReportLatencyNs);
+ BatchParams params(samplingPeriodNs, maxBatchReportLatencyNs);
info.batchParams.add(ident, params);
} else {
// A batch has already been called with this ident. Update the batch parameters.
@@ -337,25 +337,21 @@
ALOGD_IF(DEBUG_CONNECTIONS,
"\t>>> curr_period=%" PRId64 " min_period=%" PRId64
" curr_timeout=%" PRId64 " min_timeout=%" PRId64,
- prevBestBatchParams.batchDelay, info.bestBatchParams.batchDelay,
- prevBestBatchParams.batchTimeout, info.bestBatchParams.batchTimeout);
+ prevBestBatchParams.mTSample, info.bestBatchParams.mTSample,
+ prevBestBatchParams.mTBatch, info.bestBatchParams.mTBatch);
status_t err(NO_ERROR);
// If the min period or min timeout has changed since the last batch call, call batch.
if (prevBestBatchParams != info.bestBatchParams) {
- ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w BATCH %d %d %" PRId64 " %" PRId64, handle,
- info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
- info.bestBatchParams.batchTimeout);
+ ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w BATCH 0x%08x %" PRId64 " %" PRId64, handle,
+ info.bestBatchParams.mTSample, info.bestBatchParams.mTBatch);
err = StatusFromResult(
checkReturn(mSensors->batch(
- handle,
- info.bestBatchParams.batchDelay,
- info.bestBatchParams.batchTimeout)));
+ handle, info.bestBatchParams.mTSample, info.bestBatchParams.mTBatch)));
if (err != NO_ERROR) {
- ALOGE("sensor batch failed %p %d %d %" PRId64 " %" PRId64 " err=%s",
- mSensors.get(), handle,
- info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
- info.bestBatchParams.batchTimeout, strerror(-err));
+ ALOGE("sensor batch failed %p 0x%08x %" PRId64 " %" PRId64 " err=%s",
+ mSensors.get(), handle, info.bestBatchParams.mTSample,
+ info.bestBatchParams.mTBatch, strerror(-err));
info.removeBatchParamsForIdent(ident);
}
}
@@ -363,28 +359,7 @@
}
status_t SensorDevice::setDelay(void* ident, int handle, int64_t samplingPeriodNs) {
- if (mSensors == nullptr) return NO_INIT;
- if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {
- samplingPeriodNs = MINIMUM_EVENTS_PERIOD;
- }
- Mutex::Autolock _l(mLock);
- if (isClientDisabledLocked(ident)) return INVALID_OPERATION;
- Info& info( mActivationCount.editValueFor(handle) );
- // If the underlying sensor is NOT in continuous mode, setDelay() should return an error.
- // Calling setDelay() in batch mode is an invalid operation.
- if (info.bestBatchParams.batchTimeout != 0) {
- return INVALID_OPERATION;
- }
- ssize_t index = info.batchParams.indexOfKey(ident);
- if (index < 0) {
- return BAD_INDEX;
- }
- BatchParams& params = info.batchParams.editValueAt(index);
- params.batchDelay = samplingPeriodNs;
- info.selectBatchParams();
-
- return StatusFromResult(
- checkReturn(mSensors->batch(handle, info.bestBatchParams.batchDelay, 0)));
+ return batch(ident, handle, 0, samplingPeriodNs, 0);
}
int SensorDevice::getHalDeviceVersion() const {
@@ -423,8 +398,8 @@
status_t err = StatusFromResult(
checkReturn(mSensors->batch(
sensor_handle,
- info.bestBatchParams.batchDelay,
- info.bestBatchParams.batchTimeout)));
+ info.bestBatchParams.mTSample,
+ info.bestBatchParams.mTBatch)));
ALOGE_IF(err, "Error calling batch on sensor %d (%s)", sensor_handle, strerror(-err));
if (err == NO_ERROR) {
@@ -581,35 +556,35 @@
return num;
}
-status_t SensorDevice::Info::setBatchParamsForIdent(void* ident, int flags,
+status_t SensorDevice::Info::setBatchParamsForIdent(void* ident, int,
int64_t samplingPeriodNs,
int64_t maxBatchReportLatencyNs) {
ssize_t index = batchParams.indexOfKey(ident);
if (index < 0) {
- ALOGE("Info::setBatchParamsForIdent(ident=%p, period_ns=%" PRId64 " timeout=%" PRId64 ") failed (%s)",
+ ALOGE("Info::setBatchParamsForIdent(ident=%p, period_ns=%" PRId64
+ " timeout=%" PRId64 ") failed (%s)",
ident, samplingPeriodNs, maxBatchReportLatencyNs, strerror(-index));
return BAD_INDEX;
}
BatchParams& params = batchParams.editValueAt(index);
- params.flags = flags;
- params.batchDelay = samplingPeriodNs;
- params.batchTimeout = maxBatchReportLatencyNs;
+ params.mTSample = samplingPeriodNs;
+ params.mTBatch = maxBatchReportLatencyNs;
return NO_ERROR;
}
void SensorDevice::Info::selectBatchParams() {
- BatchParams bestParams(0, -1, -1);
+ BatchParams bestParams; // default to max Tsample and max Tbatch
SensorDevice& device(SensorDevice::getInstance());
for (size_t i = 0; i < batchParams.size(); ++i) {
- if (device.isClientDisabledLocked(batchParams.keyAt(i))) continue;
- BatchParams params = batchParams.valueAt(i);
- if (bestParams.batchDelay == -1 || params.batchDelay < bestParams.batchDelay) {
- bestParams.batchDelay = params.batchDelay;
+ if (device.isClientDisabledLocked(batchParams.keyAt(i))) {
+ continue;
}
- if (bestParams.batchTimeout == -1 || params.batchTimeout < bestParams.batchTimeout) {
- bestParams.batchTimeout = params.batchTimeout;
- }
+ bestParams.merge(batchParams[i]);
+ }
+ // if mTBatch <= mTSample, it is in streaming mode. set mTbatch to 0 to demand this explicitly.
+ if (bestParams.mTBatch <= bestParams.mTSample) {
+ bestParams.mTBatch = 0;
}
bestBatchParams = bestParams;
}
diff --git a/services/sensorservice/SensorDevice.h b/services/sensorservice/SensorDevice.h
index 2520a81..fd6cee6 100644
--- a/services/sensorservice/SensorDevice.h
+++ b/services/sensorservice/SensorDevice.h
@@ -27,7 +27,8 @@
#include <utils/String8.h>
#include <string>
-#include <map>
+#include <unordered_map>
+#include <algorithm> //std::max std::min
#include "android/hardware/sensors/1.0/ISensors.h"
@@ -106,7 +107,7 @@
sp<android::hardware::sensors::V1_0::ISensors> mSensors;
Vector<sensor_t> mSensorList;
- std::map<int32_t, sensor_t*> mConnectedDynamicSensors;
+ std::unordered_map<int32_t, sensor_t*> mConnectedDynamicSensors;
static const nsecs_t MINIMUM_EVENTS_PERIOD = 1000000; // 1000 Hz
mutable Mutex mLock; // protect mActivationCount[].batchParams
@@ -115,15 +116,18 @@
// Struct to store all the parameters(samplingPeriod, maxBatchReportLatency and flags) from
// batch call. For continous mode clients, maxBatchReportLatency is set to zero.
struct BatchParams {
- // TODO: Get rid of flags parameter everywhere.
- int flags;
- nsecs_t batchDelay, batchTimeout;
- BatchParams() : flags(0), batchDelay(0), batchTimeout(0) {}
- BatchParams(int flag, nsecs_t delay, nsecs_t timeout): flags(flag), batchDelay(delay),
- batchTimeout(timeout) { }
+ nsecs_t mTSample, mTBatch;
+ BatchParams() : mTSample(INT64_MAX), mTBatch(INT64_MAX) {}
+ BatchParams(nsecs_t tSample, nsecs_t tBatch): mTSample(tSample), mTBatch(tBatch) {}
bool operator != (const BatchParams& other) {
- return other.batchDelay != batchDelay || other.batchTimeout != batchTimeout ||
- other.flags != flags;
+ return !(mTSample == other.mTSample && mTBatch == other.mTBatch);
+ }
+ // Merge another parameter with this one. The updated mTSample will be the min of the two.
+ // The update mTBatch will be the min of original mTBatch and the apparent batch period
+ // of the other. the apparent batch is the maximum of mTBatch and mTSample,
+ void merge(const BatchParams &other) {
+ mTSample = std::min(mTSample, other.mTSample);
+ mTBatch = std::min(mTBatch, std::max(other.mTBatch, other.mTSample));
}
};
@@ -139,7 +143,6 @@
// requested by the client.
KeyedVector<void*, BatchParams> batchParams;
- Info() : bestBatchParams(0, -1, -1) {}
// Sets batch parameters for this ident. Returns error if this ident is not already present
// in the KeyedVector above.
status_t setBatchParamsForIdent(void* ident, int flags, int64_t samplingPeriodNs,
diff --git a/services/sensorservice/hidl/EventQueue.cpp b/services/sensorservice/hidl/EventQueue.cpp
index c0365e5..ff20066 100644
--- a/services/sensorservice/hidl/EventQueue.cpp
+++ b/services/sensorservice/hidl/EventQueue.cpp
@@ -27,7 +27,8 @@
class EventQueueLooperCallback : public ::android::LooperCallback {
public:
- EventQueueLooperCallback(sp<EventQueue> queue, sp<IEventQueueCallback> callback)
+ EventQueueLooperCallback(sp<::android::SensorEventQueue> queue,
+ sp<IEventQueueCallback> callback)
: mQueue(queue), mCallback(callback) {
}
@@ -35,7 +36,11 @@
ASensorEvent event;
ssize_t actual;
- const sp<::android::SensorEventQueue>& internalQueue = mQueue->mInternalQueue;
+
+ auto internalQueue = mQueue.promote();
+ if (internalQueue == nullptr) {
+ return 1;
+ }
while ((actual = internalQueue->read(&event, 1 /* count */)) > 0) {
internalQueue->sendAck(&event, actual);
@@ -47,7 +52,7 @@
}
private:
- sp<EventQueue> mQueue;
+ wp<::android::SensorEventQueue> mQueue;
sp<IEventQueueCallback> mCallback;
};
@@ -58,18 +63,18 @@
: mLooper(looper),
mInternalQueue(internalQueue) {
- mLooper->addFd(mInternalQueue->getFd(), ALOOPER_POLL_CALLBACK, ALOOPER_EVENT_INPUT,
- new EventQueueLooperCallback(this, callback), NULL /* data */);
+ mLooper->addFd(internalQueue->getFd(), ALOOPER_POLL_CALLBACK, ALOOPER_EVENT_INPUT,
+ new EventQueueLooperCallback(internalQueue, callback), NULL /* data */);
}
-EventQueue::~EventQueue() {
+void EventQueue::onLastStrongRef(const void *id) {
+ IEventQueue::onLastStrongRef(id);
mLooper->removeFd(mInternalQueue->getFd());
}
// Methods from ::android::frameworks::sensorservice::V1_0::IEventQueue follow.
Return<Result> EventQueue::enableSensor(int32_t sensorHandle, int32_t samplingPeriodUs,
int64_t maxBatchReportLatencyUs) {
- // TODO implement
return convertResult(mInternalQueue->enableSensor(sensorHandle, samplingPeriodUs,
maxBatchReportLatencyUs, 0 /* reserved flags */));
}
diff --git a/services/sensorservice/hidl/EventQueue.h b/services/sensorservice/hidl/EventQueue.h
index 87c614b..6be03b7 100644
--- a/services/sensorservice/hidl/EventQueue.h
+++ b/services/sensorservice/hidl/EventQueue.h
@@ -42,7 +42,7 @@
sp<IEventQueueCallback> callback,
sp<::android::Looper> looper,
sp<::android::SensorEventQueue> internalQueue);
- ~EventQueue();
+ void onLastStrongRef(const void *) override;
// Methods from ::android::frameworks::sensorservice::V1_0::IEventQueue follow.
Return<Result> enableSensor(int32_t sensorHandle, int32_t samplingPeriodUs, int64_t maxBatchReportLatencyUs) override;
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index 5e5efb7..d044f37 100644
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -2617,6 +2617,21 @@
const auto& p = getParent();
if (p != nullptr) {
t = p->getTransform();
+
+ // If the parent is not using NATIVE_WINDOW_SCALING_MODE_FREEZE (e.g.
+ // it isFixedSize) then there may be additional scaling not accounted
+ // for in the transform. We need to mirror this scaling in child surfaces
+ // or we will break the contract where WM can treat child surfaces as
+ // pixels in the parent surface.
+ if (p->isFixedSize()) {
+ float sx = p->getDrawingState().active.w /
+ static_cast<float>(p->mActiveBuffer->getWidth());
+ float sy = p->getDrawingState().active.h /
+ static_cast<float>(p->mActiveBuffer->getHeight());
+ Transform extraParentScaling;
+ extraParentScaling.set(sx, 0, 0, sy);
+ t = t * extraParentScaling;
+ }
}
return t * getDrawingState().active.transform;
}
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index 746d3d9..9cd1214 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -2371,6 +2371,7 @@
bool visibleRegions = false;
bool frameQueued = false;
+ bool newDataLatched = false;
// Store the set of layers that need updates. This set must not change as
// buffers are being latched, as this could result in a deadlock.
@@ -2398,6 +2399,9 @@
const Region dirty(layer->latchBuffer(visibleRegions, latchTime));
layer->useSurfaceDamage();
invalidateLayerStack(layer->getLayerStack(), dirty);
+ if (!dirty.isEmpty()) {
+ newDataLatched = true;
+ }
}
mVisibleRegionsDirty |= visibleRegions;
@@ -2410,7 +2414,7 @@
}
// Only continue with the refresh if there is actually new work to do
- return !mLayersWithQueuedFrames.empty();
+ return !mLayersWithQueuedFrames.empty() && newDataLatched;
}
void SurfaceFlinger::invalidateHwcGeometry()
diff --git a/services/surfaceflinger/tests/Transaction_test.cpp b/services/surfaceflinger/tests/Transaction_test.cpp
index 441fc7e..7a8b4ab 100644
--- a/services/surfaceflinger/tests/Transaction_test.cpp
+++ b/services/surfaceflinger/tests/Transaction_test.cpp
@@ -909,4 +909,36 @@
}
}
+TEST_F(ChildLayerTest, ChildrenInheritNonTransformScalingFromParent) {
+ SurfaceComposerClient::openGlobalTransaction();
+ mChild->show();
+ mChild->setPosition(0, 0);
+ mFGSurfaceControl->setPosition(0, 0);
+ SurfaceComposerClient::closeGlobalTransaction(true);
+
+ {
+ ScreenCapture::captureScreen(&mCapture);
+ // We've positioned the child in the top left.
+ mCapture->expectChildColor(0, 0);
+ // But it's only 10x10.
+ mCapture->expectFGColor(10, 10);
+ }
+
+ SurfaceComposerClient::openGlobalTransaction();
+ mFGSurfaceControl->setOverrideScalingMode(NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
+ // We cause scaling by 2.
+ mFGSurfaceControl->setSize(128, 128);
+ SurfaceComposerClient::closeGlobalTransaction();
+
+ {
+ ScreenCapture::captureScreen(&mCapture);
+ // We've positioned the child in the top left.
+ mCapture->expectChildColor(0, 0);
+ mCapture->expectChildColor(10, 10);
+ mCapture->expectChildColor(19, 19);
+ // And now it should be scaled all the way to 20x20
+ mCapture->expectFGColor(20, 20);
+ }
+}
+
}
diff --git a/services/vr/hardware_composer/Android.bp b/services/vr/hardware_composer/Android.bp
index b94d333..25bb30b 100644
--- a/services/vr/hardware_composer/Android.bp
+++ b/services/vr/hardware_composer/Android.bp
@@ -1,3 +1,51 @@
+cc_library_shared {
+ name: "libvr_hwc-hal",
+
+ srcs: [
+ "impl/vr_hwc.cpp",
+ "impl/vr_composer_client.cpp",
+ ],
+
+ static_libs: [
+ "libhwcomposer-client",
+ "libdisplay",
+ "libbufferhubqueue",
+ "libbufferhub",
+ "libpdx_default_transport",
+ ],
+
+ shared_libs: [
+ "android.frameworks.vr.composer@1.0",
+ "android.hardware.graphics.composer@2.1",
+ "libbase",
+ "libcutils",
+ "libfmq",
+ "libhardware",
+ "libhidlbase",
+ "libhidltransport",
+ "liblog",
+ "libsync",
+ "libui",
+ "libutils",
+ ],
+
+ export_static_lib_headers: [
+ "libhwcomposer-client",
+ ],
+
+ export_shared_lib_headers: [
+ "android.frameworks.vr.composer@1.0",
+ "android.hardware.graphics.composer@2.1",
+ ],
+
+ export_include_dirs: ["."],
+
+ cflags: [
+ "-DLOG_TAG=\"vr_hwc\"",
+ ],
+
+}
+
cc_library_static {
name: "libvr_hwc-binder",
srcs: [
@@ -12,11 +60,12 @@
export_aidl_headers: true,
},
export_include_dirs: ["aidl"],
+
shared_libs: [
"libbinder",
"libui",
"libutils",
- "libvrhwc",
+ "libvr_hwc-hal",
],
}
@@ -34,10 +83,10 @@
"liblog",
"libui",
"libutils",
- "libvrhwc",
+ "libvr_hwc-hal",
],
export_shared_lib_headers: [
- "libvrhwc",
+ "libvr_hwc-hal",
],
cflags: [
"-DLOG_TAG=\"vr_hwc\"",
@@ -65,7 +114,7 @@
"libhwbinder",
"libui",
"libutils",
- "libvrhwc",
+ "libvr_hwc-hal",
],
cflags: [
"-DLOG_TAG=\"vr_hwc\"",
diff --git a/services/vr/vr_window_manager/composer/impl/vr_composer_client.cpp b/services/vr/hardware_composer/impl/vr_composer_client.cpp
similarity index 97%
rename from services/vr/vr_window_manager/composer/impl/vr_composer_client.cpp
rename to services/vr/hardware_composer/impl/vr_composer_client.cpp
index e0bdf1c..ae54e56 100644
--- a/services/vr/vr_window_manager/composer/impl/vr_composer_client.cpp
+++ b/services/vr/hardware_composer/impl/vr_composer_client.cpp
@@ -19,8 +19,8 @@
#include <hardware/gralloc1.h>
#include <log/log.h>
-#include "vr_hwc.h"
-#include "vr_composer_client.h"
+#include "impl/vr_hwc.h"
+#include "impl/vr_composer_client.h"
namespace android {
namespace dvr {
diff --git a/services/vr/vr_window_manager/composer/impl/vr_composer_client.h b/services/vr/hardware_composer/impl/vr_composer_client.h
similarity index 90%
rename from services/vr/vr_window_manager/composer/impl/vr_composer_client.h
rename to services/vr/hardware_composer/impl/vr_composer_client.h
index 8d601ab..1236be9 100644
--- a/services/vr/vr_window_manager/composer/impl/vr_composer_client.h
+++ b/services/vr/hardware_composer/impl/vr_composer_client.h
@@ -14,8 +14,8 @@
* limitations under the License.
*/
-#ifndef VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_CLIENT_H_
-#define VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_CLIENT_H_
+#ifndef ANDROID_DVR_HARDWARE_COMPOSER_IMPL_VR_COMPOSER_CLIENT_H
+#define ANDROID_DVR_HARDWARE_COMPOSER_IMPL_VR_COMPOSER_CLIENT_H
#include <android/frameworks/vr/composer/1.0/IVrComposerClient.h>
#include <ComposerClient.h>
@@ -68,4 +68,4 @@
} // namespace dvr
} // namespace android
-#endif // VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_CLIENT_H_
+#endif // ANDROID_DVR_HARDWARE_COMPOSER_IMPL_VR_COMPOSER_CLIENT_H
diff --git a/services/vr/vr_window_manager/composer/impl/vr_hwc.cpp b/services/vr/hardware_composer/impl/vr_hwc.cpp
similarity index 99%
rename from services/vr/vr_window_manager/composer/impl/vr_hwc.cpp
rename to services/vr/hardware_composer/impl/vr_hwc.cpp
index f5d88f2..29983a7 100644
--- a/services/vr/vr_window_manager/composer/impl/vr_hwc.cpp
+++ b/services/vr/hardware_composer/impl/vr_hwc.cpp
@@ -13,14 +13,13 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-#include "vr_hwc.h"
+#include "impl/vr_hwc.h"
+#include <private/dvr/display_client.h>
#include <ui/Fence.h>
#include <mutex>
-#include <private/dvr/display_client.h>
-
#include "vr_composer_client.h"
using namespace android::hardware::graphics::common::V1_0;
diff --git a/services/vr/vr_window_manager/composer/impl/vr_hwc.h b/services/vr/hardware_composer/impl/vr_hwc.h
similarity index 98%
rename from services/vr/vr_window_manager/composer/impl/vr_hwc.h
rename to services/vr/hardware_composer/impl/vr_hwc.h
index 609d925..df04208 100644
--- a/services/vr/vr_window_manager/composer/impl/vr_hwc.h
+++ b/services/vr/hardware_composer/impl/vr_hwc.h
@@ -13,8 +13,8 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-#ifndef VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_HWC_H_
-#define VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_HWC_H_
+#ifndef ANDROID_DVR_HARDWARE_COMPOSER_IMPL_VR_HWC_H
+#define ANDROID_DVR_HARDWARE_COMPOSER_IMPL_VR_HWC_H
#include <android-base/unique_fd.h>
#include <android/frameworks/vr/composer/1.0/IVrComposerClient.h>
@@ -319,4 +319,4 @@
} // namespace dvr
} // namespace android
-#endif // VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_HWC_H_
+#endif // ANDROID_DVR_HARDWARE_COMPOSER_IMPL_VR_HWC_H
diff --git a/services/vr/sensord/pose_service.cpp b/services/vr/sensord/pose_service.cpp
index e3f8171..b40f244 100644
--- a/services/vr/sensord/pose_service.cpp
+++ b/services/vr/sensord/pose_service.cpp
@@ -467,7 +467,10 @@
-kDefaultNeckHorizontalOffset);
// Update the current latency model.
- sensor_latency_.AddLatency(GetSystemClockNs() - pose_state.timestamp_ns);
+ if (pose_state.timestamp_ns != 0) {
+ sensor_latency_.AddLatency(GetSystemClockNs() -
+ pose_state.timestamp_ns);
+ }
// Update the timestamp with the expected latency.
WriteAsyncPoses(
diff --git a/services/vr/vr_window_manager/Android.bp b/services/vr/vr_window_manager/Android.bp
index 669426b..d7ddba1 100644
--- a/services/vr/vr_window_manager/Android.bp
+++ b/services/vr/vr_window_manager/Android.bp
@@ -12,8 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-subdirs = [ "composer", ]
-
native_src = [
"application.cpp",
"controller_mesh.cpp",
@@ -49,7 +47,6 @@
shared_libs = [
"android.frameworks.vr.composer@1.0",
"android.hardware.graphics.composer@2.1",
- "libvrhwc",
"libbase",
"libbinder",
"libinput",
@@ -66,6 +63,7 @@
"libhidlbase",
"libhidltransport",
"liblog",
+ "libvr_hwc-hal",
]
cc_binary {
diff --git a/services/vr/vr_window_manager/composer/Android.bp b/services/vr/vr_window_manager/composer/Android.bp
deleted file mode 100644
index 1998749..0000000
--- a/services/vr/vr_window_manager/composer/Android.bp
+++ /dev/null
@@ -1,47 +0,0 @@
-cc_library_shared {
- name: "libvrhwc",
-
- srcs: [
- "impl/vr_composer_view.cpp",
- "impl/vr_hwc.cpp",
- "impl/vr_composer_client.cpp",
- ],
-
- static_libs: [
- "libhwcomposer-client",
- "libdisplay",
- "libbufferhubqueue",
- "libbufferhub",
- "libpdx_default_transport",
- ],
-
- shared_libs: [
- "android.frameworks.vr.composer@1.0",
- "android.hardware.graphics.composer@2.1",
- "libbase",
- "libcutils",
- "libfmq",
- "libhardware",
- "libhidlbase",
- "libhidltransport",
- "liblog",
- "libsync",
- "libui",
- "libutils",
- ],
-
- export_static_lib_headers: [
- "libhwcomposer-client",
- ],
-
- export_shared_lib_headers: [
- "android.frameworks.vr.composer@1.0",
- "android.hardware.graphics.composer@2.1",
- ],
-
- export_include_dirs: ["."],
-
- cflags: [
- "-DLOG_TAG=\"vrhwc\"",
- ],
-}
diff --git a/services/vr/vr_window_manager/composer/impl/vr_composer_view.cpp b/services/vr/vr_window_manager/composer/impl/vr_composer_view.cpp
deleted file mode 100644
index 299e8f1..0000000
--- a/services/vr/vr_window_manager/composer/impl/vr_composer_view.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#include "vr_composer_view.h"
-
-namespace android {
-namespace dvr {
-
-VrComposerView::VrComposerView(
- std::unique_ptr<VrComposerView::Callback> callback)
- : composer_view_(nullptr), callback_(std::move(callback)) {}
-
-VrComposerView::~VrComposerView() {
- composer_view_->UnregisterObserver(this);
-}
-
-void VrComposerView::Initialize(ComposerView* composer_view) {
- composer_view_ = composer_view;
- composer_view_->RegisterObserver(this);
-}
-
-base::unique_fd VrComposerView::OnNewFrame(const ComposerView::Frame& frame) {
- std::lock_guard<std::mutex> guard(mutex_);
- if (!callback_.get())
- return base::unique_fd();
-
- return callback_->OnNewFrame(frame);
-}
-
-} // namespace dvr
-} // namespace android
diff --git a/services/vr/vr_window_manager/composer/impl/vr_composer_view.h b/services/vr/vr_window_manager/composer/impl/vr_composer_view.h
deleted file mode 100644
index 8c5ee1f..0000000
--- a/services/vr/vr_window_manager/composer/impl/vr_composer_view.h
+++ /dev/null
@@ -1,36 +0,0 @@
-#ifndef VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_VIEW_H_
-#define VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_VIEW_H_
-
-#include <memory>
-
-#include "vr_hwc.h"
-
-namespace android {
-namespace dvr {
-
-class VrComposerView : public ComposerView::Observer {
- public:
- class Callback {
- public:
- virtual ~Callback() = default;
- virtual base::unique_fd OnNewFrame(const ComposerView::Frame& frame) = 0;
- };
-
- VrComposerView(std::unique_ptr<Callback> callback);
- ~VrComposerView() override;
-
- void Initialize(ComposerView* composer_view);
-
- // ComposerView::Observer
- base::unique_fd OnNewFrame(const ComposerView::Frame& frame) override;
-
- private:
- ComposerView* composer_view_;
- std::unique_ptr<Callback> callback_;
- std::mutex mutex_;
-};
-
-} // namespace dvr
-} // namespace android
-
-#endif // VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_VIEW_H_
diff --git a/services/vr/vr_window_manager/composer_view/Android.bp_disable b/services/vr/vr_window_manager/composer_view/Android.bp_disable
deleted file mode 100644
index 1658154..0000000
--- a/services/vr/vr_window_manager/composer_view/Android.bp_disable
+++ /dev/null
@@ -1,29 +0,0 @@
-cc_binary {
- name: "vr_composer_view",
-
- srcs: ["vr_composer_view.cpp"],
-
- static_libs: [
- "libhwcomposer-client",
- ],
-
- shared_libs: [
- "android.dvr.composer@1.0",
- "android.hardware.graphics.composer@2.1",
- "libbase",
- "libbinder",
- "libhardware",
- "libhwbinder",
- "liblog",
- "libutils",
- "libvrhwc",
- ],
-
- cflags: [
- "-DLOG_TAG=\"vr_composer_view\"",
- ],
-
- init_rc: [
- "vr_composer_view.rc",
- ],
-}
diff --git a/services/vr/vr_window_manager/composer_view/vr_composer_view.cpp b/services/vr/vr_window_manager/composer_view/vr_composer_view.cpp
deleted file mode 100644
index 54dff3d..0000000
--- a/services/vr/vr_window_manager/composer_view/vr_composer_view.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright 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.
- */
-#include <binder/ProcessState.h>
-#include <hwbinder/IPCThreadState.h>
-#include <impl/vr_composer_view.h>
-#include <impl/vr_hwc.h>
-
-using namespace android;
-using namespace android::dvr;
-
-int main(int, char**) {
- android::ProcessState::self()->startThreadPool();
-
- const char instance[] = "vr_hwcomposer";
- sp<IComposer> service = HIDL_FETCH_IComposer(instance);
- LOG_ALWAYS_FATAL_IF(!service.get(), "Failed to get service");
- LOG_ALWAYS_FATAL_IF(service->isRemote(), "Service is remote");
-
- LOG_ALWAYS_FATAL_IF(service->registerAsService(instance) != ::android::OK,
- "Failed to register service");
-
- sp<IVrComposerView> composer_view = HIDL_FETCH_IVrComposerView(
- "DaydreamDisplay");
- LOG_ALWAYS_FATAL_IF(!composer_view.get(),
- "Failed to get vr_composer_view service");
- LOG_ALWAYS_FATAL_IF(composer_view->isRemote(),
- "vr_composer_view service is remote");
-
- composer_view->registerAsService("DaydreamDisplay");
-
- GetVrComposerViewFromIVrComposerView(composer_view.get())->Initialize(
- GetComposerViewFromIComposer(service.get()));
-
- android::hardware::ProcessState::self()->startThreadPool();
- android::hardware::IPCThreadState::self()->joinThreadPool();
-
- return 0;
-}
diff --git a/services/vr/vr_window_manager/composer_view/vr_composer_view.rc b/services/vr/vr_window_manager/composer_view/vr_composer_view.rc
deleted file mode 100644
index bd9982b..0000000
--- a/services/vr/vr_window_manager/composer_view/vr_composer_view.rc
+++ /dev/null
@@ -1,5 +0,0 @@
-service vr_composer_view /system/bin/vr_composer_view
- class core
- user system
- group system graphics
- writepid /dev/cpuset/system/tasks
diff --git a/services/vr/vr_window_manager/hwc_callback.h b/services/vr/vr_window_manager/hwc_callback.h
index 4269430..259c4ac 100644
--- a/services/vr/vr_window_manager/hwc_callback.h
+++ b/services/vr/vr_window_manager/hwc_callback.h
@@ -3,15 +3,13 @@
#include <android/dvr/BnVrComposerCallback.h>
#include <android-base/unique_fd.h>
+#include <impl/vr_hwc.h>
#include <deque>
#include <functional>
#include <mutex>
#include <vector>
-#include "impl/vr_composer_view.h"
-#include "impl/vr_hwc.h"
-
namespace android {
class Fence;
diff --git a/services/vr/vr_window_manager/surface_flinger_view.cpp b/services/vr/vr_window_manager/surface_flinger_view.cpp
index aef23a1..b41de03 100644
--- a/services/vr/vr_window_manager/surface_flinger_view.cpp
+++ b/services/vr/vr_window_manager/surface_flinger_view.cpp
@@ -2,7 +2,6 @@
#include <android/dvr/IVrComposer.h>
#include <binder/IServiceManager.h>
-#include <impl/vr_composer_view.h>
#include <private/dvr/native_buffer.h>
#include "hwc_callback.h"
diff --git a/services/vr/vr_window_manager/vr_window_manager.cpp b/services/vr/vr_window_manager/vr_window_manager.cpp
index 9d7afe3..dd2cba7 100644
--- a/services/vr/vr_window_manager/vr_window_manager.cpp
+++ b/services/vr/vr_window_manager/vr_window_manager.cpp
@@ -2,7 +2,6 @@
#include <binder/IServiceManager.h>
#include <binder/ProcessState.h>
#include <hwbinder/IPCThreadState.h>
-#include <impl/vr_composer_view.h>
#include <impl/vr_hwc.h>
#include "shell_view.h"