Merge "Check if a visible layer exists instead of an invisible layer exists" into oc-dev
diff --git a/cmds/lshal/Lshal.cpp b/cmds/lshal/Lshal.cpp
index 420ec3c..4c57361 100644
--- a/cmds/lshal/Lshal.cpp
+++ b/cmds/lshal/Lshal.cpp
@@ -301,7 +301,6 @@
if (!manifest.add(vintf::ManifestHal{
.format = vintf::HalFormat::HIDL,
.name = fqName.package(),
- .impl = {.implLevel = vintf::ImplLevel::GENERIC, .impl = ""},
.transportArch = {transport, arch}
})) {
mErr << "Warning: cannot add hal '" << fqInstanceName << "'" << std::endl;
diff --git a/include/ui/DebugUtils.h b/include/ui/DebugUtils.h
new file mode 100644
index 0000000..8483808
--- /dev/null
+++ b/include/ui/DebugUtils.h
@@ -0,0 +1,27 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <system/graphics.h>
+
+#include <string>
+
+std::string decodeStandard(android_dataspace dataspace);
+std::string decodeTransfer(android_dataspace dataspace);
+std::string decodeRange(android_dataspace dataspace);
+std::string dataspaceDetails(android_dataspace dataspace);
+std::string decodeColorMode(android_color_mode colormode);
diff --git a/libs/sensor/ISensorServer.cpp b/libs/sensor/ISensorServer.cpp
index f41f187..74186df 100644
--- a/libs/sensor/ISensorServer.cpp
+++ b/libs/sensor/ISensorServer.cpp
@@ -40,6 +40,7 @@
ENABLE_DATA_INJECTION,
GET_DYNAMIC_SENSOR_LIST,
CREATE_SENSOR_DIRECT_CONNECTION,
+ SET_OPERATION_PARAMETER,
};
class BpSensorServer : public BpInterface<ISensorServer>
@@ -117,6 +118,23 @@
remote()->transact(CREATE_SENSOR_DIRECT_CONNECTION, data, &reply);
return interface_cast<ISensorEventConnection>(reply.readStrongBinder());
}
+
+ virtual int setOperationParameter(
+ int32_t type, const Vector<float> &floats, const Vector<int32_t> &ints) {
+ Parcel data, reply;
+ data.writeInterfaceToken(ISensorServer::getInterfaceDescriptor());
+ data.writeInt32(type);
+ data.writeUint32(static_cast<uint32_t>(floats.size()));
+ for (auto i : floats) {
+ data.writeFloat(i);
+ }
+ data.writeUint32(static_cast<uint32_t>(ints.size()));
+ for (auto i : ints) {
+ data.writeInt32(i);
+ }
+ remote()->transact(SET_OPERATION_PARAMETER, data, &reply);
+ return reply.readInt32();
+ }
};
// Out-of-line virtual method definition to trigger vtable emission in this
@@ -183,6 +201,26 @@
reply->writeStrongBinder(IInterface::asBinder(ch));
return NO_ERROR;
}
+ case SET_OPERATION_PARAMETER: {
+ CHECK_INTERFACE(ISensorServer, data, reply);
+ int32_t type;
+ Vector<float> floats;
+ Vector<int32_t> ints;
+
+ type = data.readInt32();
+ floats.resize(data.readUint32());
+ for (auto &i : floats) {
+ i = data.readFloat();
+ }
+ ints.resize(data.readUint32());
+ for (auto &i : ints) {
+ i = data.readInt32();
+ }
+
+ int32_t ret = setOperationParameter(type, floats, ints);
+ reply->writeInt32(ret);
+ return NO_ERROR;
+ }
}
return BBinder::onTransact(code, data, reply, flags);
}
diff --git a/libs/sensor/SensorManager.cpp b/libs/sensor/SensorManager.cpp
index d6d3304..3fbc5eb 100644
--- a/libs/sensor/SensorManager.cpp
+++ b/libs/sensor/SensorManager.cpp
@@ -304,5 +304,14 @@
return ret;
}
+int SensorManager::setOperationParameter(
+ int type, const Vector<float> &floats, const Vector<int32_t> &ints) {
+ Mutex::Autolock _l(mLock);
+ if (assertStateLocked() != NO_ERROR) {
+ return NO_INIT;
+ }
+ return mSensorServer->setOperationParameter(type, floats, ints);
+}
+
// ----------------------------------------------------------------------------
}; // namespace android
diff --git a/libs/sensor/include/sensor/ISensorServer.h b/libs/sensor/include/sensor/ISensorServer.h
index f922307..8d50062 100644
--- a/libs/sensor/include/sensor/ISensorServer.h
+++ b/libs/sensor/include/sensor/ISensorServer.h
@@ -50,6 +50,9 @@
virtual sp<ISensorEventConnection> createSensorDirectConnection(const String16& opPackageName,
uint32_t size, int32_t type, int32_t format, const native_handle_t *resource) = 0;
+
+ virtual int setOperationParameter(
+ int32_t type, const Vector<float> &floats, const Vector<int32_t> &ints) = 0;
};
// ----------------------------------------------------------------------------
diff --git a/libs/sensor/include/sensor/SensorManager.h b/libs/sensor/include/sensor/SensorManager.h
index 92c9823..5fc85d3 100644
--- a/libs/sensor/include/sensor/SensorManager.h
+++ b/libs/sensor/include/sensor/SensorManager.h
@@ -64,6 +64,7 @@
int createDirectChannel(size_t size, int channelType, const native_handle_t *channelData);
void destroyDirectChannel(int channelNativeHandle);
int configureDirectChannel(int channelNativeHandle, int sensorHandle, int rateLevel);
+ int setOperationParameter(int type, const Vector<float> &floats, const Vector<int32_t> &ints);
private:
// DeathRecipient interface
diff --git a/libs/ui/Android.bp b/libs/ui/Android.bp
index 80fb064..310d25e 100644
--- a/libs/ui/Android.bp
+++ b/libs/ui/Android.bp
@@ -45,6 +45,7 @@
srcs: [
"ColorSpace.cpp",
+ "DebugUtils.cpp",
"Fence.cpp",
"FenceTime.cpp",
"FrameStats.cpp",
@@ -66,6 +67,9 @@
shared_libs: [
"android.hardware.graphics.allocator@2.0",
"android.hardware.graphics.mapper@2.0",
+ "android.hardware.configstore@1.0",
+ "android.hardware.configstore-utils",
+ "libbase",
"libnativeloader",
"libcutils",
"libhardware",
diff --git a/libs/ui/DebugUtils.cpp b/libs/ui/DebugUtils.cpp
new file mode 100644
index 0000000..882bd7c
--- /dev/null
+++ b/libs/ui/DebugUtils.cpp
@@ -0,0 +1,187 @@
+/*
+ * 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 <ui/DebugUtils.h>
+
+#include <android-base/stringprintf.h>
+#include <string>
+
+std::string decodeStandard(android_dataspace dataspace) {
+ const uint32_t dataspaceSelect = (dataspace & HAL_DATASPACE_STANDARD_MASK);
+ switch (dataspaceSelect) {
+ case HAL_DATASPACE_STANDARD_BT709:
+ return std::string("BT709");
+
+ case HAL_DATASPACE_STANDARD_BT601_625:
+ return std::string("BT601_625");
+
+ case HAL_DATASPACE_STANDARD_BT601_625_UNADJUSTED:
+ return std::string("BT601_625_UNADJUSTED");
+
+ case HAL_DATASPACE_STANDARD_BT601_525:
+ return std::string("BT601_525");
+
+ case HAL_DATASPACE_STANDARD_BT601_525_UNADJUSTED:
+ return std::string("BT601_525_UNADJUSTED");
+
+ case HAL_DATASPACE_STANDARD_BT2020:
+ return std::string("BT2020");
+
+ case HAL_DATASPACE_STANDARD_BT2020_CONSTANT_LUMINANCE:
+ return std::string("BT2020 (constant luminance)");
+
+ case HAL_DATASPACE_STANDARD_BT470M:
+ return std::string("BT470M");
+
+ case HAL_DATASPACE_STANDARD_FILM:
+ return std::string("FILM");
+
+ case HAL_DATASPACE_STANDARD_DCI_P3:
+ return std::string("DCI-P3");
+
+ case HAL_DATASPACE_STANDARD_ADOBE_RGB:
+ return std::string("AdobeRGB");
+
+ case 0:
+ switch (dataspace & 0xffff) {
+ case HAL_DATASPACE_JFIF:
+ return std::string("(deprecated) JFIF (BT601_625, SMPTE_170M Full range)");
+
+ case HAL_DATASPACE_BT601_625:
+ return std::string("(deprecated) BT601_625 (BT601_625, SMPTE_170M Limited "
+ "range)");
+
+ case HAL_DATASPACE_BT601_525:
+ return std::string("(deprecated) BT601_525 (BT601_525, SMPTE_170M Limited "
+ "range)");
+
+ case HAL_DATASPACE_SRGB_LINEAR:
+ return std::string("(deprecated) SRGB Linear Full range");
+
+ case HAL_DATASPACE_SRGB:
+ return std::string("(deprecated) sRGB");
+
+ case HAL_DATASPACE_V0_BT709:
+ return std::string("(deprecated) BT709 (BT709, SMPTE_170M Limited range)");
+
+ case HAL_DATASPACE_ARBITRARY:
+ return std::string("ARBITRARY");
+
+ case HAL_DATASPACE_UNKNOWN:
+ // Fallthrough
+ default:
+ return android::base::StringPrintf("Unknown deprecated dataspace code %d",
+ dataspaceSelect);
+ }
+ }
+
+ return android::base::StringPrintf("Unknown dataspace code %d", dataspaceSelect);
+}
+
+std::string decodeTransfer(android_dataspace dataspace) {
+ const uint32_t dataspaceTransfer = (dataspace & HAL_DATASPACE_TRANSFER_MASK);
+ switch (dataspaceTransfer) {
+ case HAL_DATASPACE_TRANSFER_UNSPECIFIED:
+ return std::string("Unspecified");
+
+ case HAL_DATASPACE_TRANSFER_LINEAR:
+ return std::string("Linear");
+
+ case HAL_DATASPACE_TRANSFER_SRGB:
+ return std::string("sRGB");
+
+ case HAL_DATASPACE_TRANSFER_SMPTE_170M:
+ return std::string("SMPTE_170M");
+
+ case HAL_DATASPACE_TRANSFER_GAMMA2_2:
+ return std::string("gamma 2.2");
+
+ case HAL_DATASPACE_TRANSFER_GAMMA2_6:
+ return std::string("gamma 2.6");
+
+ case HAL_DATASPACE_TRANSFER_GAMMA2_8:
+ return std::string("gamma 2.8");
+
+ case HAL_DATASPACE_TRANSFER_ST2084:
+ return std::string("SMPTE 2084");
+
+ case HAL_DATASPACE_TRANSFER_HLG:
+ return std::string("STD-B67");
+ }
+
+ return android::base::StringPrintf("Unknown dataspace transfer %d", dataspaceTransfer);
+}
+
+std::string decodeRange(android_dataspace dataspace) {
+ const uint32_t dataspaceRange = (dataspace & HAL_DATASPACE_RANGE_MASK);
+ switch (dataspaceRange) {
+ case HAL_DATASPACE_RANGE_UNSPECIFIED:
+ return std::string("Range Unspecified");
+
+ case HAL_DATASPACE_RANGE_FULL:
+ return std::string("Full range");
+
+ case HAL_DATASPACE_RANGE_LIMITED:
+ return std::string("Limited range");
+
+ case HAL_DATASPACE_RANGE_EXTENDED:
+ return std::string("Extended range");
+ }
+
+ return android::base::StringPrintf("Unknown dataspace range %d", dataspaceRange);
+}
+
+std::string dataspaceDetails(android_dataspace dataspace) {
+ return android::base::StringPrintf("%s %s %s", decodeStandard(dataspace).c_str(),
+ decodeTransfer(dataspace).c_str(),
+ decodeRange(dataspace).c_str());
+}
+
+std::string decodeColorMode(android_color_mode colorMode) {
+ switch (colorMode) {
+ case HAL_COLOR_MODE_NATIVE:
+ return std::string("HAL_COLOR_MODE_NATIVE");
+
+ case HAL_COLOR_MODE_STANDARD_BT601_625:
+ return std::string("HAL_COLOR_MODE_BT601_625");
+
+ case HAL_COLOR_MODE_STANDARD_BT601_625_UNADJUSTED:
+ return std::string("HAL_COLOR_MODE_BT601_625_UNADJUSTED");
+
+ case HAL_COLOR_MODE_STANDARD_BT601_525:
+ return std::string("HAL_COLOR_MODE_BT601_525");
+
+ case HAL_COLOR_MODE_STANDARD_BT601_525_UNADJUSTED:
+ return std::string("HAL_COLOR_MODE_BT601_525_UNADJUSTED");
+
+ case HAL_COLOR_MODE_STANDARD_BT709:
+ return std::string("HAL_COLOR_MODE_BT709");
+
+ case HAL_COLOR_MODE_DCI_P3:
+ return std::string("HAL_COLOR_MODE_DCI_P3");
+
+ case HAL_COLOR_MODE_SRGB:
+ return std::string("HAL_COLOR_MODE_SRGB");
+
+ case HAL_COLOR_MODE_ADOBE_RGB:
+ return std::string("HAL_COLOR_MODE_ADOBE_RGB");
+
+ case HAL_COLOR_MODE_DISPLAY_P3:
+ return std::string("HAL_COLOR_MODE_DISPLAY_P3");
+ }
+
+ return android::base::StringPrintf("Unknown color mode %d", colorMode);
+}
diff --git a/libs/vr/libvrflinger/Android.bp b/libs/vr/libvrflinger/Android.bp
index 3f79a7b..0daab64 100644
--- a/libs/vr/libvrflinger/Android.bp
+++ b/libs/vr/libvrflinger/Android.bp
@@ -47,7 +47,6 @@
]
sharedLibraries = [
- "android.dvr.composer@1.0",
"android.hardware.graphics.allocator@2.0",
"android.hardware.graphics.composer@2.1",
"libbinder",
diff --git a/opengl/tests/EGLTest/Android.mk b/opengl/tests/EGLTest/Android.mk
index b772450..5620496 100644
--- a/opengl/tests/EGLTest/Android.mk
+++ b/opengl/tests/EGLTest/Android.mk
@@ -12,12 +12,17 @@
EGL_test.cpp \
LOCAL_SHARED_LIBRARIES := \
+ android.hardware.configstore@1.0 \
+ android.hardware.configstore-utils \
libEGL \
libcutils \
libbinder \
+ libhidlbase \
+ libhidltransport \
libutils \
libgui \
libbase \
+ liblog \
LOCAL_C_INCLUDES := \
bionic/libc/private \
diff --git a/opengl/tests/EGLTest/EGL_test.cpp b/opengl/tests/EGLTest/EGL_test.cpp
index 1b3086b..94de5af 100644
--- a/opengl/tests/EGLTest/EGL_test.cpp
+++ b/opengl/tests/EGLTest/EGL_test.cpp
@@ -16,6 +16,9 @@
#include <gtest/gtest.h>
+#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
+
+#include <configstore/Utils.h>
#include <utils/String8.h>
#include <EGL/egl.h>
@@ -25,10 +28,31 @@
#include <gui/IGraphicBufferConsumer.h>
#include <gui/BufferQueue.h>
+#define PIXEL_FORMAT_FLOAT "EGL_EXT_pixel_format_float"
+
+bool hasEglPixelFormatFloat() {
+ EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+ const char* exts = eglQueryString(dpy, EGL_EXTENSIONS);
+ size_t cropExtLen = strlen(PIXEL_FORMAT_FLOAT);
+ size_t extsLen = strlen(exts);
+ bool equal = !strcmp(PIXEL_FORMAT_FLOAT, exts);
+ bool atStart = !strncmp(PIXEL_FORMAT_FLOAT " ", exts, cropExtLen + 1);
+ bool atEnd = (cropExtLen + 1) < extsLen &&
+ !strcmp(" " PIXEL_FORMAT_FLOAT, exts + extsLen - (cropExtLen + 1));
+ bool inMiddle = strstr(exts, " " PIXEL_FORMAT_FLOAT " ");
+ return equal || atStart || atEnd || inMiddle;
+}
+
namespace android {
#define EGL_UNSIGNED_TRUE static_cast<EGLBoolean>(EGL_TRUE)
+// retrieve wide-color setting from configstore
+using namespace android::hardware::configstore;
+
+static bool hasWideColorDisplay =
+ getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::hasWideColorDisplay>(false);
+
class EGLTest : public ::testing::Test {
protected:
EGLDisplay mEglDisplay;
@@ -169,5 +193,75 @@
EXPECT_GE(components[3], 8);
}
+TEST_F(EGLTest, EGLConfigFP16) {
+ EGLint numConfigs;
+ EGLConfig config;
+ EGLBoolean success;
+ if (!hasWideColorDisplay) {
+ // skip this test if device does not have wide-color display
+ return;
+ }
+
+ ASSERT_TRUE(hasEglPixelFormatFloat());
+
+ EGLint attrs[] = {EGL_SURFACE_TYPE,
+ EGL_WINDOW_BIT,
+ EGL_RENDERABLE_TYPE,
+ EGL_OPENGL_ES2_BIT,
+ EGL_RED_SIZE,
+ 16,
+ EGL_GREEN_SIZE,
+ 16,
+ EGL_BLUE_SIZE,
+ 16,
+ EGL_ALPHA_SIZE,
+ 16,
+ EGL_COLOR_COMPONENT_TYPE_EXT,
+ EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT,
+ EGL_NONE};
+ success = eglChooseConfig(mEglDisplay, attrs, &config, 1, &numConfigs);
+ ASSERT_EQ(EGL_UNSIGNED_TRUE, success);
+ ASSERT_EQ(1, numConfigs);
+
+ EGLint components[4];
+
+ success = eglGetConfigAttrib(mEglDisplay, config, EGL_RED_SIZE, &components[0]);
+ ASSERT_EQ(EGL_UNSIGNED_TRUE, success);
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ success = eglGetConfigAttrib(mEglDisplay, config, EGL_GREEN_SIZE, &components[1]);
+ ASSERT_EQ(EGL_UNSIGNED_TRUE, success);
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ success = eglGetConfigAttrib(mEglDisplay, config, EGL_BLUE_SIZE, &components[2]);
+ ASSERT_EQ(EGL_UNSIGNED_TRUE, success);
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ success = eglGetConfigAttrib(mEglDisplay, config, EGL_ALPHA_SIZE, &components[3]);
+ ASSERT_EQ(EGL_UNSIGNED_TRUE, success);
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+
+ EXPECT_GE(components[0], 16);
+ EXPECT_GE(components[1], 16);
+ EXPECT_GE(components[2], 16);
+ EXPECT_GE(components[3], 16);
+
+ struct DummyConsumer : public BnConsumerListener {
+ void onFrameAvailable(const BufferItem& /* item */) override {}
+ void onBuffersReleased() override {}
+ void onSidebandStreamChanged() override {}
+ };
+
+ // Create a EGLSurface
+ sp<IGraphicBufferProducer> producer;
+ sp<IGraphicBufferConsumer> consumer;
+ BufferQueue::createBufferQueue(&producer, &consumer);
+ consumer->consumerConnect(new DummyConsumer, false);
+ sp<Surface> mSTC = new Surface(producer);
+ sp<ANativeWindow> mANW = mSTC;
+
+ EGLSurface eglSurface = eglCreateWindowSurface(mEglDisplay, config, mANW.get(), NULL);
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ ASSERT_NE(EGL_NO_SURFACE, eglSurface);
+
+ EXPECT_TRUE(eglDestroySurface(mEglDisplay, eglSurface));
+}
}
diff --git a/services/sensorservice/SensorService.cpp b/services/sensorservice/SensorService.cpp
index 8fc4921..4d76272 100644
--- a/services/sensorservice/SensorService.cpp
+++ b/services/sensorservice/SensorService.cpp
@@ -13,23 +13,19 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
-#include <cutils/properties.h>
-
#include <binder/AppOpsManager.h>
#include <binder/BinderService.h>
#include <binder/IServiceManager.h>
#include <binder/PermissionCache.h>
-
#include <cutils/ashmem.h>
-#include <sensor/SensorEventQueue.h>
-
+#include <cutils/properties.h>
#include <hardware/sensors.h>
#include <hardware_legacy/power.h>
-
#include <openssl/digest.h>
#include <openssl/hmac.h>
#include <openssl/rand.h>
+#include <sensor/SensorEventQueue.h>
+#include <utils/SystemClock.h>
#include "BatteryService.h"
#include "CorrectedGyroSensor.h"
@@ -77,7 +73,8 @@
#define SENSOR_SERVICE_SCHED_FIFO_PRIORITY 10
// Permissions.
-static const String16 sDump("android.permission.DUMP");
+static const String16 sDumpPermission("android.permission.DUMP");
+static const String16 sLocationHardwarePermission("android.permission.LOCATION_HARDWARE");
SensorService::SensorService()
: mInitCheck(NO_INIT), mSocketBufferSize(SOCKET_BUFFER_SIZE_NON_BATCHED),
@@ -319,7 +316,7 @@
status_t SensorService::dump(int fd, const Vector<String16>& args) {
String8 result;
- if (!PermissionCache::checkCallingPermission(sDump)) {
+ if (!PermissionCache::checkCallingPermission(sDumpPermission)) {
result.appendFormat("Permission Denial: can't dump SensorService from pid=%d, uid=%d\n",
IPCThreadState::self()->getCallingPid(),
IPCThreadState::self()->getCallingUid());
@@ -1032,6 +1029,84 @@
return conn;
}
+int SensorService::setOperationParameter(
+ int32_t type, const Vector<float> &floats, const Vector<int32_t> &ints) {
+ Mutex::Autolock _l(mLock);
+
+ // check permission
+ int32_t uid;
+ bool hasPermission = checkCallingPermission(sLocationHardwarePermission, nullptr, &uid);
+ if (!hasPermission || (uid != 1000 && uid != 0)) {
+ return PERMISSION_DENIED;
+ }
+
+ bool isFloat = true;
+ size_t expectSize = INT32_MAX;
+ switch (type) {
+ case AINFO_LOCAL_GEOMAGNETIC_FIELD:
+ isFloat = true;
+ expectSize = 3;
+ break;
+ case AINFO_LOCAL_GRAVITY:
+ isFloat = true;
+ expectSize = 1;
+ break;
+ case AINFO_DOCK_STATE:
+ case AINFO_HIGH_PERFORMANCE_MODE:
+ case AINFO_MAGNETIC_FIELD_CALIBRATION:
+ isFloat = false;
+ expectSize = 1;
+ break;
+ default:
+ return BAD_VALUE;
+ }
+
+ // three events: first one is begin tag, last one is end tag, the one in the middle
+ // is the payload.
+ sensors_event_t event[3];
+ int64_t timestamp = elapsedRealtimeNano();
+ for (sensors_event_t* i = event; i < event + 3; i++) {
+ *i = (sensors_event_t) {
+ .version = sizeof(sensors_event_t),
+ .sensor = 0,
+ .type = SENSOR_TYPE_ADDITIONAL_INFO,
+ .timestamp = timestamp++,
+ .additional_info = (additional_info_event_t) {
+ .serial = 0
+ }
+ };
+ }
+
+ event[0].additional_info.type = AINFO_BEGIN;
+ event[1].additional_info.type = type;
+ event[2].additional_info.type = AINFO_END;
+
+ if (isFloat) {
+ if (floats.size() != expectSize) {
+ return BAD_VALUE;
+ }
+ for (size_t i = 0; i < expectSize; ++i) {
+ event[1].additional_info.data_float[i] = floats[i];
+ }
+ } else {
+ if (ints.size() != expectSize) {
+ return BAD_VALUE;
+ }
+ for (size_t i = 0; i < expectSize; ++i) {
+ event[1].additional_info.data_int32[i] = ints[i];
+ }
+ }
+
+ SensorDevice& dev(SensorDevice::getInstance());
+ for (sensors_event_t* i = event; i < event + 3; i++) {
+ int ret = dev.injectSensorData(i);
+ if (ret != NO_ERROR) {
+ return ret;
+ }
+ }
+ return NO_ERROR;
+}
+
status_t SensorService::resetToNormalMode() {
Mutex::Autolock _l(mLock);
return resetToNormalModeLocked();
diff --git a/services/sensorservice/SensorService.h b/services/sensorservice/SensorService.h
index d0be121..2a9d6e8 100644
--- a/services/sensorservice/SensorService.h
+++ b/services/sensorservice/SensorService.h
@@ -158,6 +158,8 @@
virtual int isDataInjectionEnabled();
virtual sp<ISensorEventConnection> createSensorDirectConnection(const String16& opPackageName,
uint32_t size, int32_t type, int32_t format, const native_handle *resource);
+ virtual int setOperationParameter(
+ int32_t type, const Vector<float> &floats, const Vector<int32_t> &ints);
virtual status_t dump(int fd, const Vector<String16>& args);
String8 getSensorName(int handle) const;
diff --git a/services/surfaceflinger/Android.mk b/services/surfaceflinger/Android.mk
index ebf72bc..76baa01 100644
--- a/services/surfaceflinger/Android.mk
+++ b/services/surfaceflinger/Android.mk
@@ -74,7 +74,7 @@
libvrflinger
LOCAL_SHARED_LIBRARIES := \
- android.dvr.composer@1.0 \
+ android.frameworks.vr.composer@1.0 \
android.hardware.graphics.allocator@2.0 \
android.hardware.graphics.composer@2.1 \
android.hardware.configstore@1.0 \
diff --git a/services/surfaceflinger/DisplayDevice.cpp b/services/surfaceflinger/DisplayDevice.cpp
index c3b48ca..87c4ea7 100644
--- a/services/surfaceflinger/DisplayDevice.cpp
+++ b/services/surfaceflinger/DisplayDevice.cpp
@@ -80,6 +80,7 @@
uint32_t DisplayDevice::sPrimaryDisplayOrientation = 0;
+// clang-format off
DisplayDevice::DisplayDevice(
const sp<SurfaceFlinger>& flinger,
DisplayType type,
@@ -91,7 +92,8 @@
const wp<IBinder>& displayToken,
const sp<DisplaySurface>& displaySurface,
const sp<IGraphicBufferProducer>& producer,
- EGLConfig config)
+ EGLConfig config,
+ bool supportWideColor)
: lastCompositionHadVisibleLayers(false),
mFlinger(flinger),
mType(type),
@@ -111,8 +113,12 @@
mLayerStack(NO_LAYER_STACK),
mOrientation(),
mPowerMode(HWC_POWER_MODE_OFF),
- mActiveConfig(0)
+ mActiveConfig(0),
+#ifdef USE_HWC2
+ mDisplayHasWideColor(supportWideColor)
+#endif
{
+ // clang-format on
Surface* surface;
mNativeWindow = surface = new Surface(producer, false);
ANativeWindow* const window = mNativeWindow.get();
diff --git a/services/surfaceflinger/DisplayDevice.h b/services/surfaceflinger/DisplayDevice.h
index caa7adc..e2852a7 100644
--- a/services/surfaceflinger/DisplayDevice.h
+++ b/services/surfaceflinger/DisplayDevice.h
@@ -83,6 +83,7 @@
NO_LAYER_STACK = 0xFFFFFFFF,
};
+ // clang-format off
DisplayDevice(
const sp<SurfaceFlinger>& flinger,
DisplayType type,
@@ -94,7 +95,9 @@
const wp<IBinder>& displayToken,
const sp<DisplaySurface>& displaySurface,
const sp<IGraphicBufferProducer>& producer,
- EGLConfig config);
+ EGLConfig config,
+ bool supportWideColor);
+ // clang-format on
~DisplayDevice();
@@ -146,6 +149,7 @@
status_t beginFrame(bool mustRecompose) const;
#ifdef USE_HWC2
status_t prepareFrame(HWComposer& hwc);
+ bool getWideColorSupport() const { return mDisplayHasWideColor; }
#else
status_t prepareFrame(const HWComposer& hwc) const;
#endif
@@ -264,6 +268,11 @@
#ifdef USE_HWC2
// current active color mode
android_color_mode_t mActiveColorMode;
+
+ // Need to know if display is wide-color capable or not.
+ // Initialized by SurfaceFlinger when the DisplayDevice is created.
+ // Fed to RenderEngine during composition.
+ bool mDisplayHasWideColor;
#endif
};
diff --git a/services/surfaceflinger/DisplayHardware/ComposerHal.cpp b/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
index d9bddb5..33aa759 100644
--- a/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
+++ b/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
@@ -17,7 +17,7 @@
#undef LOG_TAG
#define LOG_TAG "HwcComposer"
-#include <android/dvr/composer/1.0/IVrComposerClient.h>
+#include <android/frameworks/vr/composer/1.0/IVrComposerClient.h>
#include <inttypes.h>
#include <log/log.h>
#include <gui/BufferQueue.h>
@@ -26,7 +26,7 @@
namespace android {
-using dvr::composer::V1_0::IVrComposerClient;
+using frameworks::vr::composer::V1_0::IVrComposerClient;
using hardware::Return;
using hardware::hidl_vec;
using hardware::hidl_handle;
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index 16d8160..c211c7b 100644
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -1011,6 +1011,9 @@
return inverse(tr);
}
+/*
+ * onDraw will draw the current layer onto the presentable buffer
+ */
void Layer::onDraw(const sp<const DisplayDevice>& hw, const Region& clip,
bool useIdentityTransform) const
{
@@ -1172,6 +1175,9 @@
RenderEngine& engine(mFlinger->getRenderEngine());
engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(s), getAlpha());
+#ifdef USE_HWC2
+ engine.setSourceDataSpace(mCurrentState.dataSpace);
+#endif
engine.drawMesh(mMesh);
engine.disableBlending();
}
diff --git a/services/surfaceflinger/RenderEngine/GLES20RenderEngine.cpp b/services/surfaceflinger/RenderEngine/GLES20RenderEngine.cpp
index 406e611..413051d 100644
--- a/services/surfaceflinger/RenderEngine/GLES20RenderEngine.cpp
+++ b/services/surfaceflinger/RenderEngine/GLES20RenderEngine.cpp
@@ -14,11 +14,16 @@
* limitations under the License.
*/
+//#define LOG_NDEBUG 0
+#undef LOG_TAG
+#define LOG_TAG "RenderEngine"
#define ATRACE_TAG ATRACE_TAG_GRAPHICS
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
+#include <ui/ColorSpace.h>
+#include <ui/DebugUtils.h>
#include <ui/Rect.h>
#include <utils/String8.h>
@@ -35,6 +40,71 @@
#include "Mesh.h"
#include "Texture.h"
+#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
+#include <configstore/Utils.h>
+
+#include <fstream>
+
+static constexpr bool outputDebugPPMs = false;
+
+// ---------------------------------------------------------------------------
+bool checkGlError(const char* op, int lineNumber) {
+ bool errorFound = false;
+ GLint error = glGetError();
+ while (error != GL_NO_ERROR) {
+ errorFound = true;
+ error = glGetError();
+ ALOGV("after %s() (line # %d) glError (0x%x)\n", op, lineNumber, error);
+ }
+ return errorFound;
+}
+
+void writePPM(const char* basename, GLuint width, GLuint height) {
+ ALOGV("writePPM #%s: %d x %d", basename, width, height);
+
+ std::vector<GLubyte> pixels(width * height * 4);
+ std::vector<GLubyte> outBuffer(width * height * 3);
+
+ // TODO(courtneygo): We can now have float formats, need
+ // to remove this code or update to support.
+ // Make returned pixels fit in uint32_t, one byte per component
+ glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data());
+ if (checkGlError(__FUNCTION__, __LINE__)) {
+ return;
+ }
+
+ std::string filename(basename);
+ filename.append(".ppm");
+ std::ofstream file(filename.c_str(), std::ios::binary);
+ if (!file.is_open()) {
+ ALOGE("Unable to open file: %s", filename.c_str());
+ ALOGE("You may need to do: \"adb shell setenforce 0\" to enable "
+ "surfaceflinger to write debug images");
+ return;
+ }
+
+ file << "P6\n";
+ file << width << "\n";
+ file << height << "\n";
+ file << 255 << "\n";
+
+ auto ptr = reinterpret_cast<char*>(pixels.data());
+ auto outPtr = reinterpret_cast<char*>(outBuffer.data());
+ for (int y = height - 1; y >= 0; y--) {
+ char* data = ptr + y * width * sizeof(uint32_t);
+
+ for (GLuint x = 0; x < width; x++) {
+ // Only copy R, G and B components
+ outPtr[0] = data[0];
+ outPtr[1] = data[1];
+ outPtr[2] = data[2];
+ data += sizeof(uint32_t);
+ outPtr += 3;
+ }
+ }
+ file.write(reinterpret_cast<char*>(outBuffer.data()), outBuffer.size());
+}
+
// ---------------------------------------------------------------------------
namespace android {
// ---------------------------------------------------------------------------
@@ -59,6 +129,26 @@
GL_RGB, GL_UNSIGNED_SHORT_5_6_5, protTexData);
//mColorBlindnessCorrection = M;
+
+ // retrieve wide-color and hdr settings from configstore
+ using namespace android::hardware::configstore;
+ using namespace android::hardware::configstore::V1_0;
+
+ mPlatformHasWideColor =
+ getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::hasWideColorDisplay>(false);
+ if (mPlatformHasWideColor) {
+ // Compute sRGB to DisplayP3 color transform
+ // NOTE: For now, we are limiting wide-color support to
+ // Display-P3 only.
+ mat3 srgbToP3 = ColorSpace::DisplayP3().getXYZtoRGB() * ColorSpace::sRGB().getRGBtoXYZ();
+
+ // color transform needs to be transposed and expanded to 4x4
+ // to be what the shader wants
+ // mat has an initializer that expands mat3 to mat4, but
+ // not an assignment operator
+ mat4 gamutTransform(transpose(srgbToP3));
+ mSrgbToDisplayP3 = gamutTransform;
+ }
}
GLES20RenderEngine::~GLES20RenderEngine() {
@@ -170,6 +260,42 @@
}
}
+#ifdef USE_HWC2
+void GLES20RenderEngine::setColorMode(android_color_mode mode) {
+ ALOGV("setColorMode: %s (0x%x)", decodeColorMode(mode).c_str(), mode);
+
+ if (mColorMode == mode) return;
+
+ if (!mPlatformHasWideColor || !mDisplayHasWideColor || mode == HAL_COLOR_MODE_SRGB ||
+ mode == HAL_COLOR_MODE_NATIVE) {
+ // We are returning back to our default color_mode
+ mUseWideColor = false;
+ mWideColorFrameCount = 0;
+ } else {
+ mUseWideColor = true;
+ }
+
+ mColorMode = mode;
+}
+
+void GLES20RenderEngine::setSourceDataSpace(android_dataspace source) {
+ if (source == HAL_DATASPACE_UNKNOWN) {
+ // Treat UNKNOWN as SRGB
+ source = HAL_DATASPACE_V0_SRGB;
+ }
+ mDataSpace = source;
+}
+
+void GLES20RenderEngine::setWideColor(bool hasWideColor) {
+ ALOGV("setWideColor: %s", hasWideColor ? "true" : "false");
+ mDisplayHasWideColor = hasWideColor;
+}
+
+bool GLES20RenderEngine::usesWideColor() {
+ return mUseWideColor;
+}
+#endif
+
void GLES20RenderEngine::setupLayerTexturing(const Texture& texture) {
GLuint target = texture.getTextureTarget();
glBindTexture(target, texture.getTextureName());
@@ -242,8 +368,6 @@
void GLES20RenderEngine::drawMesh(const Mesh& mesh) {
- ProgramCache::getInstance().useProgram(mState);
-
if (mesh.getTexCoordsSize()) {
glEnableVertexAttribArray(Program::texCoords);
glVertexAttribPointer(Program::texCoords,
@@ -259,7 +383,26 @@
mesh.getByteStride(),
mesh.getPositions());
- glDrawArrays(mesh.getPrimitive(), 0, mesh.getVertexCount());
+ if (usesWideColor()) {
+ Description wideColorState = mState;
+ if (mDataSpace != HAL_DATASPACE_DISPLAY_P3) {
+ wideColorState.setColorMatrix(mState.getColorMatrix() * mSrgbToDisplayP3);
+ ALOGV("drawMesh: gamut transform applied");
+ }
+ ProgramCache::getInstance().useProgram(wideColorState);
+
+ glDrawArrays(mesh.getPrimitive(), 0, mesh.getVertexCount());
+
+ if (outputDebugPPMs) {
+ std::ostringstream out;
+ out << "/data/texture_out" << mWideColorFrameCount++;
+ writePPM(out.str().c_str(), mVpWidth, mVpHeight);
+ }
+ } else {
+ ProgramCache::getInstance().useProgram(mState);
+
+ glDrawArrays(mesh.getPrimitive(), 0, mesh.getVertexCount());
+ }
if (mesh.getTexCoordsSize()) {
glDisableVertexAttribArray(Program::texCoords);
@@ -268,6 +411,11 @@
void GLES20RenderEngine::dump(String8& result) {
RenderEngine::dump(result);
+ if (usesWideColor()) {
+ result.append("Wide-color: On\n");
+ } else {
+ result.append("Wide-color: Off\n");
+ }
}
// ---------------------------------------------------------------------------
diff --git a/services/surfaceflinger/RenderEngine/GLES20RenderEngine.h b/services/surfaceflinger/RenderEngine/GLES20RenderEngine.h
index 7c3f9b5..19cbb60 100644
--- a/services/surfaceflinger/RenderEngine/GLES20RenderEngine.h
+++ b/services/surfaceflinger/RenderEngine/GLES20RenderEngine.h
@@ -72,6 +72,27 @@
virtual void setupLayerBlending(bool premultipliedAlpha, bool opaque,
float alpha) override;
virtual void setupDimLayerBlending(float alpha) override;
+
+ // Color management related functions and state
+ void setColorMode(android_color_mode mode);
+ void setSourceDataSpace(android_dataspace source);
+ void setWideColor(bool hasWideColor);
+ bool usesWideColor();
+
+ // Current color mode of display using the render engine
+ android_color_mode mColorMode = HAL_COLOR_MODE_NATIVE;
+
+ // Current dataspace of layer being rendered
+ android_dataspace mDataSpace = HAL_DATASPACE_V0_SRGB;
+
+ // Indicate if wide-color mode is needed or not
+ bool mPlatformHasWideColor = false;
+ bool mDisplayHasWideColor = false;
+ bool mUseWideColor = false;
+ uint64_t mWideColorFrameCount = 0;
+
+ // Currently only supporting sRGB and DisplayP3 color spaces
+ mat4 mSrgbToDisplayP3;
#else
virtual void setupLayerBlending(bool premultipliedAlpha, bool opaque,
int alpha);
diff --git a/services/surfaceflinger/RenderEngine/RenderEngine.h b/services/surfaceflinger/RenderEngine/RenderEngine.h
index d19137b..8b031bc 100644
--- a/services/surfaceflinger/RenderEngine/RenderEngine.h
+++ b/services/surfaceflinger/RenderEngine/RenderEngine.h
@@ -98,6 +98,10 @@
#ifdef USE_HWC2
virtual void setupLayerBlending(bool premultipliedAlpha, bool opaque, float alpha) = 0;
virtual void setupDimLayerBlending(float alpha) = 0;
+ virtual void setColorMode(android_color_mode mode) = 0;
+ virtual void setSourceDataSpace(android_dataspace source) = 0;
+ virtual void setWideColor(bool hasWideColor) = 0;
+ virtual bool usesWideColor() = 0;
#else
virtual void setupLayerBlending(bool premultipliedAlpha, bool opaque, int alpha) = 0;
virtual void setupDimLayerBlending(int alpha) = 0;
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index 834c1c4..26baaae 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -37,6 +37,7 @@
#include <dvr/vr_flinger.h>
+#include <ui/DebugUtils.h>
#include <ui/DisplayInfo.h>
#include <ui/DisplayStatInfo.h>
@@ -119,6 +120,7 @@
bool SurfaceFlinger::hasSyncFramework;
bool SurfaceFlinger::useVrFlinger;
int64_t SurfaceFlinger::maxFrameBufferAcquiredBuffers;
+bool SurfaceFlinger::hasWideColorDisplay;
SurfaceFlinger::SurfaceFlinger()
: BnSurfaceComposer(),
@@ -189,6 +191,9 @@
maxFrameBufferAcquiredBuffers = getInt64< ISurfaceFlingerConfigs,
&ISurfaceFlingerConfigs::maxFrameBufferAcquiredBuffers>(2);
+ hasWideColorDisplay =
+ getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::hasWideColorDisplay>(false);
+
// debugging stuff...
char value[PROPERTY_VALUE_MAX];
@@ -867,13 +872,10 @@
void SurfaceFlinger::setActiveColorModeInternal(const sp<DisplayDevice>& hw,
android_color_mode_t mode) {
- ALOGD("Set active color mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(),
- this);
int32_t type = hw->getDisplayType();
android_color_mode_t currentMode = hw->getActiveColorMode();
if (mode == currentMode) {
- ALOGD("Screen type=%d is already in color mode=%d", hw->getDisplayType(), mode);
return;
}
@@ -882,6 +884,9 @@
return;
}
+ ALOGD("Set active color mode: %s (%d), type=%d", decodeColorMode(mode).c_str(), mode,
+ hw->getDisplayType());
+
hw->setActiveColorMode(mode);
getHwComposer().setActiveColorMode(type, mode);
}
@@ -902,17 +907,17 @@
mFlinger.getDisplayColorModes(mDisplay, &modes);
bool exists = std::find(std::begin(modes), std::end(modes), mMode) != std::end(modes);
if (mMode < 0 || !exists) {
- ALOGE("Attempt to set invalid active color mode = %d for display %p", mMode,
- mDisplay.get());
+ ALOGE("Attempt to set invalid active color mode %s (%d) for display %p",
+ decodeColorMode(mMode).c_str(), mMode, mDisplay.get());
return true;
}
sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
if (hw == nullptr) {
- ALOGE("Attempt to set active color mode = %d for null display %p",
- mMode, mDisplay.get());
+ ALOGE("Attempt to set active color mode %s (%d) for null display %p",
+ decodeColorMode(mMode).c_str(), mMode, mDisplay.get());
} else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) {
- ALOGW("Attempt to set active color mode= %d for virtual display",
- mMode);
+ ALOGW("Attempt to set active color mode %s %d for virtual display",
+ decodeColorMode(mMode).c_str(), mMode);
} else {
mFlinger.setActiveColorModeInternal(hw, mMode);
}
@@ -1144,10 +1149,30 @@
sp<FramebufferSurface> fbs = new FramebufferSurface(*mHwc,
DisplayDevice::DISPLAY_PRIMARY, consumer);
- sp<DisplayDevice> hw = new DisplayDevice(this,
- DisplayDevice::DISPLAY_PRIMARY, disp, isSecure, token, fbs,
- producer, mRenderEngine->getEGLConfig());
+
+ bool hasWideColorModes = false;
+ std::vector<android_color_mode_t> modes = getHwComposer().getColorModes(type);
+ for (android_color_mode_t colorMode : modes) {
+ switch (colorMode) {
+ case HAL_COLOR_MODE_DISPLAY_P3:
+ case HAL_COLOR_MODE_ADOBE_RGB:
+ case HAL_COLOR_MODE_DCI_P3:
+ hasWideColorModes = true;
+ break;
+ default:
+ break;
+ }
+ }
+ sp<DisplayDevice> hw =
+ new DisplayDevice(this, DisplayDevice::DISPLAY_PRIMARY, disp, isSecure, token, fbs,
+ producer, mRenderEngine->getEGLConfig(),
+ hasWideColorModes && hasWideColorDisplay);
mDisplays.add(token, hw);
+ android_color_mode defaultColorMode = HAL_COLOR_MODE_NATIVE;
+ if (hasWideColorModes && hasWideColorDisplay) {
+ defaultColorMode = HAL_COLOR_MODE_SRGB;
+ }
+ setActiveColorModeInternal(hw, defaultColorMode);
} else {
auto type = DisplayDevice::DISPLAY_EXTERNAL;
Mutex::Autolock _l(mStateLock);
@@ -1591,6 +1616,39 @@
}
}
+// pickColorMode translates a given dataspace into the best available color mode.
+// Currently only support sRGB and Display-P3.
+android_color_mode SurfaceFlinger::pickColorMode(android_dataspace dataSpace) {
+ switch (dataSpace) {
+ // treat Unknown as regular SRGB buffer, since that's what the rest of the
+ // system expects.
+ case HAL_DATASPACE_UNKNOWN:
+ case HAL_DATASPACE_SRGB:
+ case HAL_DATASPACE_V0_SRGB:
+ return HAL_COLOR_MODE_SRGB;
+ break;
+
+ case HAL_DATASPACE_DISPLAY_P3:
+ return HAL_COLOR_MODE_DISPLAY_P3;
+ break;
+
+ default:
+ // TODO (courtneygo): Do we want to assert an error here?
+ ALOGE("No color mode mapping for %s (%#x)", dataspaceDetails(dataSpace).c_str(),
+ dataSpace);
+ return HAL_COLOR_MODE_SRGB;
+ break;
+ }
+}
+
+android_dataspace SurfaceFlinger::bestTargetDataSpace(android_dataspace a, android_dataspace b) {
+ // Only support sRGB and Display-P3 right now.
+ if (a == HAL_DATASPACE_DISPLAY_P3 || b == HAL_DATASPACE_DISPLAY_P3) {
+ return HAL_DATASPACE_DISPLAY_P3;
+ }
+ return HAL_DATASPACE_V0_SRGB;
+}
+
void SurfaceFlinger::setUpHWComposer() {
ATRACE_CALL();
ALOGV("setUpHWComposer");
@@ -1661,6 +1719,7 @@
for (size_t displayId = 0; displayId < mDisplays.size(); ++displayId) {
auto& displayDevice = mDisplays[displayId];
const auto hwcId = displayDevice->getHwcDisplayId();
+
if (hwcId < 0) {
continue;
}
@@ -1672,6 +1731,21 @@
for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) {
layer->setPerFrameData(displayDevice);
}
+
+ if (hasWideColorDisplay) {
+ android_color_mode newColorMode;
+ android_dataspace newDataSpace = HAL_DATASPACE_V0_SRGB;
+
+ for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) {
+ newDataSpace = bestTargetDataSpace(layer->getDataSpace(), newDataSpace);
+ ALOGV("layer: %s, dataspace: %s (%#x), newDataSpace: %s (%#x)",
+ layer->getName().string(), dataspaceDetails(layer->getDataSpace()).c_str(),
+ layer->getDataSpace(), dataspaceDetails(newDataSpace).c_str(), newDataSpace);
+ }
+ newColorMode = pickColorMode(newDataSpace);
+
+ setActiveColorModeInternal(displayDevice, newColorMode);
+ }
}
mPreviousColorMatrix = colorMatrix;
@@ -1950,10 +2024,11 @@
const wp<IBinder>& display(curr.keyAt(i));
if (dispSurface != NULL) {
- sp<DisplayDevice> hw = new DisplayDevice(this,
- state.type, hwcId, state.isSecure, display,
- dispSurface, producer,
- mRenderEngine->getEGLConfig());
+ sp<DisplayDevice> hw =
+ new DisplayDevice(this, state.type, hwcId, state.isSecure, display,
+ dispSurface, producer,
+ mRenderEngine->getEGLConfig(),
+ hasWideColorDisplay);
hw->setLayerStack(state.layerStack);
hw->setProjection(state.orientation,
state.viewport, state.frame);
@@ -2369,6 +2444,10 @@
if (hasClientComposition) {
ALOGV("hasClientComposition");
+#ifdef USE_HWC2
+ mRenderEngine->setColorMode(displayDevice->getActiveColorMode());
+ mRenderEngine->setWideColor(displayDevice->getWideColorSupport());
+#endif
if (!displayDevice->makeCurrent(mEGLDisplay, mEGLContext)) {
ALOGW("DisplayDevice::makeCurrent failed. Aborting surface composition for display %s",
displayDevice->getDisplayName().string());
@@ -3014,7 +3093,6 @@
int currentMode = hw->getPowerMode();
if (mode == currentMode) {
- ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode);
return;
}
@@ -3171,6 +3249,12 @@
dumpFrameEventsLocked(result);
dumpAll = false;
}
+
+ if ((index < numArgs) && (args[index] == String16("--wide-color"))) {
+ index++;
+ dumpWideColorInfo(result);
+ dumpAll = false;
+ }
}
if (dumpAll) {
@@ -3341,6 +3425,30 @@
result.append("\n");
}
+void SurfaceFlinger::dumpWideColorInfo(String8& result) const {
+ result.appendFormat("hasWideColorDisplay: %d\n", hasWideColorDisplay);
+
+ // TODO: print out if wide-color mode is active or not
+
+ for (size_t d = 0; d < mDisplays.size(); d++) {
+ const sp<const DisplayDevice>& displayDevice(mDisplays[d]);
+ int32_t hwcId = displayDevice->getHwcDisplayId();
+ if (hwcId == DisplayDevice::DISPLAY_ID_INVALID) {
+ continue;
+ }
+
+ result.appendFormat("Display %d color modes:\n", hwcId);
+ std::vector<android_color_mode_t> modes = getHwComposer().getColorModes(hwcId);
+ for (auto&& mode : modes) {
+ result.appendFormat(" %s (%d)\n", decodeColorMode(mode).c_str(), mode);
+ }
+
+ android_color_mode_t currentMode = displayDevice->getActiveColorMode();
+ result.appendFormat(" Current color mode: %s (%d)\n",
+ decodeColorMode(currentMode).c_str(), currentMode);
+ }
+ result.append("\n");
+}
void SurfaceFlinger::dumpAllLocked(const Vector<String16>& args, size_t& index,
String8& result) const
@@ -3373,6 +3481,9 @@
appendGuiConfigString(result);
result.append("\n");
+ result.append("\nWide-Color information:\n");
+ dumpWideColorInfo(result);
+
colorizer.bold(result);
result.append("Sync configuration: ");
colorizer.reset(result);
diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h
index 4ecbddd..46121cf 100644
--- a/services/surfaceflinger/SurfaceFlinger.h
+++ b/services/surfaceflinger/SurfaceFlinger.h
@@ -151,6 +151,13 @@
// FramebufferSurface
static int64_t maxFrameBufferAcquiredBuffers;
+ // Indicate if platform supports color management on its
+ // wide-color display. This is typically found on devices
+ // with wide gamut (e.g. Display-P3) display.
+ // This also allows devices with wide-color displays that don't
+ // want to support color management to disable color management.
+ static bool hasWideColorDisplay;
+
static char const* getServiceName() ANDROID_API {
return "SurfaceFlinger";
}
@@ -472,6 +479,12 @@
nsecs_t vsyncPhase, nsecs_t vsyncInterval,
nsecs_t compositeToPresentLatency);
void rebuildLayerStacks();
+
+ // Given a dataSpace, returns the appropriate color_mode to use
+ // to display that dataSpace.
+ android_color_mode pickColorMode(android_dataspace dataSpace);
+ android_dataspace bestTargetDataSpace(android_dataspace a, android_dataspace b);
+
void setUpHWComposer();
void doComposition();
void doDebugFlashRegions();
@@ -522,6 +535,7 @@
void recordBufferingStats(const char* layerName,
std::vector<OccupancyTracker::Segment>&& history);
void dumpBufferingStats(String8& result) const;
+ void dumpWideColorInfo(String8& result) const;
bool isLayerTripleBufferingDisabled() const {
return this->mLayerTripleBufferingDisabled;
diff --git a/services/vr/hardware_composer/Android.bp b/services/vr/hardware_composer/Android.bp
index 629d65b..b94d333 100644
--- a/services/vr/hardware_composer/Android.bp
+++ b/services/vr/hardware_composer/Android.bp
@@ -56,7 +56,7 @@
"libvr_hwc-binder",
],
shared_libs: [
- "android.dvr.composer@1.0",
+ "android.frameworks.vr.composer@1.0",
"android.hardware.graphics.composer@2.1",
"libbase",
"libbinder",
diff --git a/services/vr/vr_window_manager/Android.bp b/services/vr/vr_window_manager/Android.bp
index 0406331..669426b 100644
--- a/services/vr/vr_window_manager/Android.bp
+++ b/services/vr/vr_window_manager/Android.bp
@@ -47,7 +47,7 @@
]
shared_libs = [
- "android.dvr.composer@1.0",
+ "android.frameworks.vr.composer@1.0",
"android.hardware.graphics.composer@2.1",
"libvrhwc",
"libbase",
diff --git a/services/vr/vr_window_manager/application.cpp b/services/vr/vr_window_manager/application.cpp
index b2f02e5..8b4460a 100644
--- a/services/vr/vr_window_manager/application.cpp
+++ b/services/vr/vr_window_manager/application.cpp
@@ -206,8 +206,9 @@
if (fade_value_ > 1.0f)
fade_value_ = 1.0f;
- controller_position_ = elbow_model_.Update(delta, last_pose_.GetRotation(),
- controller_orientation_, false);
+ controller_position_ =
+ elbow_model_.Update(delta, last_pose_.GetRotation(),
+ controller_orientation_, should_recenter_);
dvrBeginRenderFrameEds(graphics_context_, pose.orientation,
pose.translation);
@@ -233,6 +234,7 @@
OnEndFrame();
dvrPresent(graphics_context_);
+ should_recenter_ = false;
}
}
diff --git a/services/vr/vr_window_manager/application.h b/services/vr/vr_window_manager/application.h
index 4b36ecc..ed99157 100644
--- a/services/vr/vr_window_manager/application.h
+++ b/services/vr/vr_window_manager/application.h
@@ -80,6 +80,9 @@
bool shmem_controller_active_ = false;
uint64_t shmem_controller_buttons_;
+ // Used to center the scene when the shell becomes visible.
+ bool should_recenter_ = true;
+
bool is_visible_ = false;
std::chrono::time_point<std::chrono::system_clock> visibility_button_press_;
bool debug_mode_ = false;
diff --git a/services/vr/vr_window_manager/composer/1.0/Android.bp b/services/vr/vr_window_manager/composer/1.0/Android.bp
deleted file mode 100644
index 58f83f8..0000000
--- a/services/vr/vr_window_manager/composer/1.0/Android.bp
+++ /dev/null
@@ -1,54 +0,0 @@
-// This file is autogenerated by hidl-gen. Do not edit manually.
-
-genrule {
- name: "android.dvr.composer@1.0_genc++",
- tools: ["hidl-gen"],
- cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hidl:system/libhidl/transport -randroid.hardware:hardware/interfaces/ -randroid.dvr:frameworks/native/services/vr/vr_window_manager android.dvr.composer@1.0",
- srcs: [
- "IVrComposerClient.hal",
- ],
- out: [
- "android/dvr/composer/1.0/VrComposerClientAll.cpp",
- ],
-}
-
-genrule {
- name: "android.dvr.composer@1.0_genc++_headers",
- tools: ["hidl-gen"],
- cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hidl:system/libhidl/transport -randroid.hardware:hardware/interfaces/ -randroid.dvr:frameworks/native/services/vr/vr_window_manager android.dvr.composer@1.0",
- srcs: [
- "IVrComposerClient.hal",
- ],
- out: [
- "android/dvr/composer/1.0/IVrComposerClient.h",
- "android/dvr/composer/1.0/IHwVrComposerClient.h",
- "android/dvr/composer/1.0/BnHwVrComposerClient.h",
- "android/dvr/composer/1.0/BpHwVrComposerClient.h",
- "android/dvr/composer/1.0/BsVrComposerClient.h",
- ],
-}
-
-cc_library_shared {
- name: "android.dvr.composer@1.0",
- generated_sources: ["android.dvr.composer@1.0_genc++"],
- generated_headers: ["android.dvr.composer@1.0_genc++_headers"],
- export_generated_headers: ["android.dvr.composer@1.0_genc++_headers"],
- shared_libs: [
- "libhidlbase",
- "libhidltransport",
- "libhwbinder",
- "liblog",
- "libutils",
- "libcutils",
- "android.hardware.graphics.composer@2.1",
- "android.hidl.base@1.0",
- ],
- export_shared_lib_headers: [
- "libhidlbase",
- "libhidltransport",
- "libhwbinder",
- "libutils",
- "android.hardware.graphics.composer@2.1",
- "android.hidl.base@1.0",
- ],
-}
diff --git a/services/vr/vr_window_manager/composer/1.0/IVrComposerClient.hal b/services/vr/vr_window_manager/composer/1.0/IVrComposerClient.hal
deleted file mode 100644
index 230a68a..0000000
--- a/services/vr/vr_window_manager/composer/1.0/IVrComposerClient.hal
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package android.dvr.composer@1.0;
-
-import android.hardware.graphics.composer@2.1::IComposerClient;
-
-interface IVrComposerClient
- extends android.hardware.graphics.composer@2.1::IComposerClient {
- /*
- * Used to annotate the layer with additional information, which will be
- * used to describe the content of the layer (ie: notification, permission,
- * etc) which allows VR window manager to treat certain layer types
- * specially.
- *
- * @param display is the display on which the layer was created.
- * @param layer is the layer affected by the change.
- * @param layer_type the type of the layer as described by the window
- * manager.
- * @param application_id the application id the layer belongs to.
- * @return error is NONE upon success. Otherwise,
- * BAD_DISPLAY when an invalid display handle was passed in.
- * BAD_LAYER when an invalid layer handle was passed in.
- *
- * setLayerInfo(Display display,
- * Layer layer,
- * uint32_t layer_type,
- * uint32_t application_id)
- * generates(Error error);
- */
-
- enum VrCommand : int32_t {
- OPCODE_SHIFT = android.hardware.graphics.composer@2.1::IComposerClient.Command:OPCODE_SHIFT,
-
- SET_LAYER_INFO = 0x800 << OPCODE_SHIFT,
- };
-};
diff --git a/services/vr/vr_window_manager/composer/Android.bp b/services/vr/vr_window_manager/composer/Android.bp
index f28818a..007251f 100644
--- a/services/vr/vr_window_manager/composer/Android.bp
+++ b/services/vr/vr_window_manager/composer/Android.bp
@@ -1,7 +1,3 @@
-subdirs = [
- "1.0",
-]
-
cc_library_shared {
name: "libvrhwc",
@@ -20,7 +16,7 @@
],
shared_libs: [
- "android.dvr.composer@1.0",
+ "android.frameworks.vr.composer@1.0",
"android.hardware.graphics.composer@2.1",
"libbase",
"libcutils",
diff --git a/services/vr/vr_window_manager/composer/impl/vr_composer_client.cpp b/services/vr/vr_window_manager/composer/impl/vr_composer_client.cpp
index 367acb7..acf0dac 100644
--- a/services/vr/vr_window_manager/composer/impl/vr_composer_client.cpp
+++ b/services/vr/vr_window_manager/composer/impl/vr_composer_client.cpp
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-#include <android/dvr/composer/1.0/IVrComposerClient.h>
+#include <android/frameworks/vr/composer/1.0/IVrComposerClient.h>
#include <hardware/gralloc.h>
#include <hardware/gralloc1.h>
#include <log/log.h>
@@ -26,7 +26,7 @@
namespace dvr {
using android::hardware::graphics::common::V1_0::PixelFormat;
-using android::dvr::composer::V1_0::IVrComposerClient;
+using android::frameworks::vr::composer::V1_0::IVrComposerClient;
VrComposerClient::VrComposerClient(dvr::VrHwc& hal)
: ComposerClient(hal), mVrHal(hal) {}
diff --git a/services/vr/vr_window_manager/shell_view.cpp b/services/vr/vr_window_manager/shell_view.cpp
index 850f604..2b53cd6 100644
--- a/services/vr/vr_window_manager/shell_view.cpp
+++ b/services/vr/vr_window_manager/shell_view.cpp
@@ -327,7 +327,6 @@
// Position the quad horizontally aligned in the direction the user
// is facing, effectively taking out head roll.
displays_[0]->Recenter(GetHorizontallyAlignedMatrixFromPose(last_pose_));
- should_recenter_ = false;
}
for (auto& display : displays_) {
diff --git a/services/vr/vr_window_manager/shell_view.h b/services/vr/vr_window_manager/shell_view.h
index be2ae58..d90e833 100644
--- a/services/vr/vr_window_manager/shell_view.h
+++ b/services/vr/vr_window_manager/shell_view.h
@@ -84,9 +84,6 @@
bool is_touching_ = false;
int touchpad_buttons_ = 0;
- // Used to center the scene when the shell becomes visible.
- bool should_recenter_ = true;
-
std::mutex display_frame_mutex_;
std::vector<std::unique_ptr<DisplayView>> displays_;