Merge "DO NOT MERGE - Merge PPRL.190205.001 into master" (f93e7add) · Commits · e / os / android_frameworks_native

opengl/libs/EGL/eglApi.cpp

+9 −0

Original line number	Diff line number	Diff line
		@@ -552,6 +552,15 @@ static EGLBoolean processAttributes(egl_display_ptr dp, NativeWindowType window,
		break;
		}
		}

		// If the driver doesn't understand it, we should map sRGB-encoded P3 to
		// sRGB rather than just dropping the colorspace on the floor.
		// For this format, the driver is expected to apply the sRGB
		// transfer function during framebuffer operations.
		if (!copyAttribute && attr[1] == EGL_GL_COLORSPACE_DISPLAY_P3_EXT) {
		strippedAttribList->push_back(attr[0]);
		strippedAttribList->push_back(EGL_GL_COLORSPACE_SRGB_KHR);
		}
		}
		if (copyAttribute) {
		strippedAttribList->push_back(attr[0]);

services/surfaceflinger/ContainerLayer.cpp

+4 −0

Original line number	Diff line number	Diff line
		@@ -30,6 +30,10 @@ ContainerLayer::ContainerLayer(SurfaceFlinger* flinger, const sp<Client>& client

		void ContainerLayer::onDraw(const RenderArea&, const Region& /* clip */, bool) const {}

		bool ContainerLayer::isVisible() const {
		return !isHiddenByPolicy();
		}

		void ContainerLayer::setPerFrameData(const sp<const DisplayDevice>&) {}

		} // namespace android

services/surfaceflinger/ContainerLayer.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -32,7 +32,7 @@ public:
		const char* getTypeId() const override { return "ContainerLayer"; }
		void onDraw(const RenderArea& renderArea, const Region& clip,
		bool useIdentityTransform) const override;
		bool isVisible() const override { return false; }
		bool isVisible() const override;

		void setPerFrameData(const sp<const DisplayDevice>& displayDevice) override;

services/surfaceflinger/SurfaceFlinger.cpp

+8 −2

Original line number	Diff line number	Diff line
		@@ -4426,6 +4426,12 @@ void SurfaceFlinger::dumpAllLocked(const Vector<String16>& args, size_t& index,
		mEventThread->dump(result);
		result.append("\n");

		/*
		* Tracing state
		*/
		mTracing.dump(result);
		result.append("\n");

		/*
		* HWC layer minidump
		*/
		@@ -4755,12 +4761,12 @@ status_t SurfaceFlinger::onTransact(
		case 1025: { // Set layer tracing
		n = data.readInt32();
		if (n) {
		ALOGV("LayerTracing enabled");
		ALOGD("LayerTracing enabled");
		mTracing.enable();
		doTracing("tracing.enable");
		reply->writeInt32(NO_ERROR);
		} else {
		ALOGV("LayerTracing disabled");
		ALOGD("LayerTracing disabled");
		status_t err = mTracing.disable();
		reply->writeInt32(err);
		}

services/surfaceflinger/SurfaceTracing.cpp

+34 −12

Original line number	Diff line number	Diff line
		@@ -27,52 +27,67 @@
		namespace android {

		void SurfaceTracing::enable() {
		ATRACE_CALL();
		std::lock_guard<std::mutex> protoGuard(mTraceMutex);

		if (mEnabled) {
		return;
		}
		ATRACE_CALL();
		mEnabled = true;
		std::lock_guard<std::mutex> protoGuard(mTraceMutex);

		mTrace.set_magic_number(uint64_t(LayersTraceFileProto_MagicNumber_MAGIC_NUMBER_H) << 32 \|
		mTrace = std::make_unique<LayersTraceFileProto>();
		mTrace->set_magic_number(uint64_t(LayersTraceFileProto_MagicNumber_MAGIC_NUMBER_H) << 32 \|
		LayersTraceFileProto_MagicNumber_MAGIC_NUMBER_L);
		}

		status_t SurfaceTracing::disable() {
		ATRACE_CALL();
		std::lock_guard<std::mutex> protoGuard(mTraceMutex);

		if (!mEnabled) {
		return NO_ERROR;
		}
		ATRACE_CALL();
		std::lock_guard<std::mutex> protoGuard(mTraceMutex);
		mEnabled = false;
		status_t err(writeProtoFileLocked());
		ALOGE_IF(err == PERMISSION_DENIED, "Could not save the proto file! Permission denied");
		ALOGE_IF(err == NOT_ENOUGH_DATA, "Could not save the proto file! There are missing fields");
		mTrace.Clear();
		mTrace.reset();
		return err;
		}

		bool SurfaceTracing::isEnabled() {
		bool SurfaceTracing::isEnabled() const {
		std::lock_guard<std::mutex> protoGuard(mTraceMutex);
		return mEnabled;
		}

		void SurfaceTracing::traceLayers(const char* where, LayersProto layers) {
		std::lock_guard<std::mutex> protoGuard(mTraceMutex);

		LayersTraceProto* entry = mTrace.add_entry();
		if (!mEnabled) {
		return;
		}
		LayersTraceProto* entry = mTrace->add_entry();
		entry->set_elapsed_realtime_nanos(elapsedRealtimeNano());
		entry->set_where(where);
		entry->mutable_layers()->Swap(&layers);

		constexpr int maxBufferedEntryCount = 3600;
		if (mTrace->entry_size() >= maxBufferedEntryCount) {
		// TODO: flush buffered entries without disabling tracing
		ALOGE("too many buffered frames; force disable tracing");
		mEnabled = false;
		writeProtoFileLocked();
		mTrace.reset();
		}
		}

		status_t SurfaceTracing::writeProtoFileLocked() {
		ATRACE_CALL();

		if (!mTrace.IsInitialized()) {
		if (!mTrace->IsInitialized()) {
		return NOT_ENOUGH_DATA;
		}
		std::string output;
		if (!mTrace.SerializeToString(&output)) {
		if (!mTrace->SerializeToString(&output)) {
		return PERMISSION_DENIED;
		}
		if (!android::base::WriteStringToFile(output, mOutputFileName, true)) {
		@@ -82,4 +97,11 @@ status_t SurfaceTracing::writeProtoFileLocked() {
		return NO_ERROR;
		}

		void SurfaceTracing::dump(String8& result) const {
		std::lock_guard<std::mutex> protoGuard(mTraceMutex);

		result.appendFormat("Tracing state: %s\n", mEnabled ? "enabled" : "disabled");
		result.appendFormat(" number of entries: %d\n", mTrace ? mTrace->entry_size() : 0);
		}

		} // namespace android