Snap for 7721244 from 38953ba5e4f2a33c397382ed336075b71a8717c0 to sc-v2-release (191347a1) · Commits · e / devices / smdk4412 / android_frameworks_native

libs/gui/SurfaceComposerClient.cpp

+20 −7

Original line number	Diff line number	Diff line
		@@ -194,7 +194,7 @@ CallbackId TransactionCompletedListener::addCallbackFunction(
		void TransactionCompletedListener::addJankListener(const sp<JankDataListener>& listener,
		sp<SurfaceControl> surfaceControl) {
		std::lock_guard<std::mutex> lock(mMutex);
		mJankListeners.insert({surfaceControl->getHandle(), listener});
		mJankListeners.insert({surfaceControl->getLayerId(), listener});
		}

		void TransactionCompletedListener::removeJankListener(const sp<JankDataListener>& listener) {
		@@ -223,8 +223,8 @@ void TransactionCompletedListener::removeReleaseBufferCallback(
		void TransactionCompletedListener::addSurfaceStatsListener(void* context, void* cookie,
		sp<SurfaceControl> surfaceControl, SurfaceStatsCallback listener) {
		std::scoped_lock<std::recursive_mutex> lock(mSurfaceStatsListenerMutex);
		mSurfaceStatsListeners.insert({surfaceControl->getHandle(),
		SurfaceStatsCallbackEntry(context, cookie, listener)});
		mSurfaceStatsListeners.insert(
		{surfaceControl->getLayerId(), SurfaceStatsCallbackEntry(context, cookie, listener)});
		}

		void TransactionCompletedListener::removeSurfaceStatsListener(void* context, void* cookie) {
		@@ -254,7 +254,7 @@ void TransactionCompletedListener::addSurfaceControlToCallbacks(

		void TransactionCompletedListener::onTransactionCompleted(ListenerStats listenerStats) {
		std::unordered_map<CallbackId, CallbackTranslation, CallbackIdHash> callbacksMap;
		std::multimap<sp<IBinder>, sp<JankDataListener>> jankListenersMap;
		std::multimap<int32_t, sp<JankDataListener>> jankListenersMap;
		{
		std::lock_guard<std::mutex> lock(mMutex);

		@@ -352,13 +352,26 @@ void TransactionCompletedListener::onTransactionCompleted(ListenerStats listener
		callbackFunction(transactionStats.latchTime, transactionStats.presentFence,
		surfaceControlStats);
		}

		for (const auto& surfaceStats : transactionStats.surfaceStats) {
		// The callbackMap contains the SurfaceControl object, which we need to look up the
		// layerId. Since we don't know which callback contains the SurfaceControl, iterate
		// through all until the SC is found.
		int32_t layerId = -1;
		for (auto callbackId : transactionStats.callbackIds) {
		sp<SurfaceControl> sc =
		callbacksMap[callbackId].surfaceControls[surfaceStats.surfaceControl];
		if (sc != nullptr) {
		layerId = sc->getLayerId();
		break;
		}
		}

		{
		// Acquire surface stats listener lock such that we guarantee that after calling
		// unregister, there won't be any further callback.
		std::scoped_lock<std::recursive_mutex> lock(mSurfaceStatsListenerMutex);
		auto listenerRange = mSurfaceStatsListeners.equal_range(
		surfaceStats.surfaceControl);
		auto listenerRange = mSurfaceStatsListeners.equal_range(layerId);
		for (auto it = listenerRange.first; it != listenerRange.second; it++) {
		auto entry = it->second;
		entry.callback(entry.context, transactionStats.latchTime,
		@@ -367,7 +380,7 @@ void TransactionCompletedListener::onTransactionCompleted(ListenerStats listener
		}

		if (surfaceStats.jankData.empty()) continue;
		auto jankRange = jankListenersMap.equal_range(surfaceStats.surfaceControl);
		auto jankRange = jankListenersMap.equal_range(layerId);
		for (auto it = jankRange.first; it != jankRange.second; it++) {
		it->second->onJankDataAvailable(surfaceStats.jankData);
		}

libs/gui/include/gui/SurfaceComposerClient.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -688,13 +688,13 @@ protected:

		std::unordered_map<CallbackId, CallbackTranslation, CallbackIdHash> mCallbacks
		GUARDED_BY(mMutex);
		std::multimap<sp<IBinder>, sp<JankDataListener>> mJankListeners GUARDED_BY(mMutex);
		std::multimap<int32_t, sp<JankDataListener>> mJankListeners GUARDED_BY(mMutex);
		std::unordered_map<ReleaseCallbackId, ReleaseBufferCallback, ReleaseBufferCallbackIdHash>
		mReleaseBufferCallbacks GUARDED_BY(mMutex);

		// This is protected by mSurfaceStatsListenerMutex, but GUARDED_BY isn't supported for
		// std::recursive_mutex
		std::multimap<sp<IBinder>, SurfaceStatsCallbackEntry> mSurfaceStatsListeners;
		std::multimap<int32_t, SurfaceStatsCallbackEntry> mSurfaceStatsListeners;

		public:
		static sp<TransactionCompletedListener> getInstance();

libs/renderengine/skia/SkiaGLRenderEngine.cpp

+25 −10

Original line number	Diff line number	Diff line
		@@ -424,14 +424,28 @@ base::unique_fd SkiaGLRenderEngine::flush() {
		return fenceFd;
		}

		bool SkiaGLRenderEngine::waitFence(base::unique_fd fenceFd) {
		void SkiaGLRenderEngine::waitFence(base::borrowed_fd fenceFd) {
		if (fenceFd.get() >= 0 && !waitGpuFence(fenceFd)) {
		ATRACE_NAME("SkiaGLRenderEngine::waitFence");
		sync_wait(fenceFd.get(), -1);
		}
		}

		bool SkiaGLRenderEngine::waitGpuFence(base::borrowed_fd fenceFd) {
		if (!gl::GLExtensions::getInstance().hasNativeFenceSync() \|\|
		!gl::GLExtensions::getInstance().hasWaitSync()) {
		return false;
		}

		// Duplicate the fence for passing to eglCreateSyncKHR.
		base::unique_fd fenceDup(dup(fenceFd.get()));
		if (fenceDup.get() < 0) {
		ALOGE("failed to create duplicate fence fd: %d", fenceDup.get());
		return false;
		}

		// release the fd and transfer the ownership to EGLSync
		EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, fenceFd.release(), EGL_NONE};
		EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, fenceDup.release(), EGL_NONE};
		EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
		if (sync == EGL_NO_SYNC_KHR) {
		ALOGE("failed to create EGL native fence sync: %#x", eglGetError());
		@@ -726,14 +740,6 @@ status_t SkiaGLRenderEngine::drawLayers(const DisplaySettings& display,
		return NO_ERROR;
		}

		if (bufferFence.get() >= 0) {
		// Duplicate the fence for passing to waitFence.
		base::unique_fd bufferFenceDup(dup(bufferFence.get()));
		if (bufferFenceDup < 0 \|\| !waitFence(std::move(bufferFenceDup))) {
		ATRACE_NAME("Waiting before draw");
		sync_wait(bufferFence.get(), -1);
		}
		}
		if (buffer == nullptr) {
		ALOGE("No output buffer provided. Aborting GPU composition.");
		return BAD_VALUE;
		@@ -758,6 +764,9 @@ status_t SkiaGLRenderEngine::drawLayers(const DisplaySettings& display,
		true, mTextureCleanupMgr);
		}

		// wait on the buffer to be ready to use prior to using it
		waitFence(bufferFence);

		const ui::Dataspace dstDataspace =
		mUseColorManagement ? display.outputDataspace : ui::Dataspace::V0_SRGB_LINEAR;
		sk_sp<SkSurface> dstSurface = surfaceTextureRef->getOrCreateSurface(dstDataspace, grContext);
		@@ -1014,6 +1023,12 @@ status_t SkiaGLRenderEngine::drawLayers(const DisplaySettings& display,
		false, mTextureCleanupMgr);
		}

		// if the layer's buffer has a fence, then we must must respect the fence prior to using
		// the buffer.
		if (layer->source.buffer.fence != nullptr) {
		waitFence(layer->source.buffer.fence->get());
		}

		// isOpaque means we need to ignore the alpha in the image,
		// replacing it with the alpha specified by the LayerSettings. See
		// https://developer.android.com/reference/android/view/SurfaceControl.Builder#setOpaque(boolean)

libs/renderengine/skia/SkiaGLRenderEngine.h

+4 −1

Original line number	Diff line number	Diff line
		@@ -99,7 +99,10 @@ private:
		inline GrDirectContext* getActiveGrContext() const;

		base::unique_fd flush();
		bool waitFence(base::unique_fd fenceFd);
		// waitFence attempts to wait in the GPU, and if unable to waits on the CPU instead.
		void waitFence(base::borrowed_fd fenceFd);
		bool waitGpuFence(base::borrowed_fd fenceFd);

		void initCanvas(SkCanvas* canvas, const DisplaySettings& display);
		void drawShadow(SkCanvas* canvas, const SkRRect& casterRRect,
		const ShadowSettings& shadowSettings);