host/PostWorkerGl.cpp - platform/hardware/google/gfxstream - Git at Google

 /*
  * Copyright (C) 2023 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 "PostWorkerGl.h"

 #include "FrameBuffer.h"
 #include "gl/DisplayGl.h"
 #include "gl/DisplaySurfaceGl.h"
 #include "host-common/GfxstreamFatalError.h"
 #include "host-common/logging.h"
 #include "host-common/misc.h"

 namespace gfxstream {

 namespace {

 using emugl::ABORT_REASON_OTHER;
 using emugl::FatalError;
 using gl::DisplayGl;
 using gl::DisplaySurfaceGl;
 using gl::EmulationGl;
 using gl::s_egl;

 hwc_transform_t getTransformFromRotation(int rotation) {
     switch (static_cast<int>(rotation / 90)) {
         case 1:
             return HWC_TRANSFORM_ROT_270;
         case 2:
             return HWC_TRANSFORM_ROT_180;
         case 3:
             return HWC_TRANSFORM_ROT_90;
         default:
             return HWC_TRANSFORM_NONE;
     }
 }

 }  // namespace

 PostWorkerGl::PostWorkerGl(bool mainThreadPostingOnly, FrameBuffer* fb, Compositor* compositor,
                            DisplayGl* displayGl, gl::EmulationGl* emulationGl)
     : PostWorker(mainThreadPostingOnly, fb, compositor),
       m_displayGl(displayGl),
       mEmulationGl(emulationGl) {
     if (!m_displayGl) {
         GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "PostWorker missing DisplayGl.";
     }
 }

 void PostWorkerGl::screenshot(ColorBuffer* cb, int screenwidth, int screenheight, GLenum format,
                               GLenum type, int skinRotation, void* pixels, Rect rect) {
     // See b/292237104.
     mFb->lock();
     cb->readToBytesScaled(screenwidth, screenheight, format, type, skinRotation, rect, pixels);
     mFb->unlock();
 }

 std::shared_future<void> PostWorkerGl::postImpl(ColorBuffer* cb) {
     if (!mContextBound || m_mainThreadPostingOnly) {
         // This might happen on headless mode
         // Also if posting on main thread, the context binding can get polluted easily, which
         // requires frequent rebinds.
         setupContext();
     }
     std::shared_future<void> completedFuture = std::async(std::launch::deferred, [] {}).share();
     completedFuture.wait();

     DisplayGl::Post post = {};

     ComposeLayer postLayerOptions = {
         .composeMode = HWC2_COMPOSITION_DEVICE,
         .blendMode = HWC2_BLEND_MODE_NONE,
         .alpha = 1.0f,
         .transform = HWC_TRANSFORM_NONE,
     };

     const auto& multiDisplay = emugl::get_emugl_multi_display_operations();
     const bool pixel_fold = multiDisplay.isPixelFold();
     if (pixel_fold) {
 #ifdef CONFIG_AEMU
         if (emugl::shouldSkipDraw()) {
             post.layers.clear();
         } else {
             post.layers.push_back(postWithOverlay(cb));
         }
 #endif
     }
     else if (multiDisplay.isMultiDisplayEnabled()) {
         if (multiDisplay.isMultiDisplayWindow()) {
             int32_t previousDisplayId = -1;
             uint32_t currentDisplayId;
             uint32_t currentDisplayColorBufferHandle;
             while (multiDisplay.getNextMultiDisplay(previousDisplayId, &currentDisplayId,
                                                     /*x=*/nullptr,
                                                     /*y=*/nullptr,
                                                     /*w=*/nullptr,
                                                     /*h=*/nullptr,
                                                     /*dpi=*/nullptr,
                                                     /*flags=*/nullptr,
                                                     &currentDisplayColorBufferHandle)) {
                 previousDisplayId = currentDisplayId;

                 if (currentDisplayColorBufferHandle == 0) {
                     continue;
                 }
                 emugl::get_emugl_window_operations().paintMultiDisplayWindow(
                     currentDisplayId, currentDisplayColorBufferHandle);
             }
             post.layers.push_back(postWithOverlay(cb));
         } else {
             uint32_t combinedDisplayW = 0;
             uint32_t combinedDisplayH = 0;
             multiDisplay.getCombinedDisplaySize(&combinedDisplayW, &combinedDisplayH);

             post.frameWidth = combinedDisplayW;
             post.frameHeight = combinedDisplayH;

             int32_t previousDisplayId = -1;
             uint32_t currentDisplayId;
             int32_t currentDisplayOffsetX;
             int32_t currentDisplayOffsetY;
             uint32_t currentDisplayW;
             uint32_t currentDisplayH;
             uint32_t currentDisplayColorBufferHandle;
             while (multiDisplay.getNextMultiDisplay(
                 previousDisplayId, &currentDisplayId, &currentDisplayOffsetX,
                 &currentDisplayOffsetY, &currentDisplayW, &currentDisplayH,
                 /*dpi=*/nullptr,
                 /*flags=*/nullptr, &currentDisplayColorBufferHandle)) {
                 previousDisplayId = currentDisplayId;

                 if (currentDisplayW == 0 || currentDisplayH == 0 ||
                     (currentDisplayId != 0 && currentDisplayColorBufferHandle == 0)) {
                     continue;
                 }

                 ColorBuffer* currentCb =
                     currentDisplayId == 0
                         ? cb
                         : mFb->findColorBuffer(currentDisplayColorBufferHandle).get();
                 if (!currentCb) {
                     continue;
                 }

                 const auto transform = getTransformFromRotation(mFb->getZrot());
                 postLayerOptions.transform = transform;
                 if ( transform == HWC_TRANSFORM_ROT_90 || transform == HWC_TRANSFORM_ROT_270) {
                     std::swap(currentDisplayW, currentDisplayH);
                 }
                 postLayerOptions.displayFrame = {
                     .left = static_cast<int>(currentDisplayOffsetX),
                     .top = static_cast<int>(currentDisplayOffsetY),
                     .right = static_cast<int>(currentDisplayOffsetX + currentDisplayW),
                     .bottom = static_cast<int>(currentDisplayOffsetY + currentDisplayH),
                 };
                 postLayerOptions.crop = {
                     .left = 0.0f,
                     .top = static_cast<float>(currentCb->getHeight()),
                     .right = static_cast<float>(currentCb->getWidth()),
                     .bottom = 0.0f,
                 };

                 post.layers.push_back(DisplayGl::PostLayer{
                     .colorBuffer = currentCb,
                     .layerOptions = postLayerOptions,
                 });
             }
         }
     } else if (emugl::get_emugl_window_operations().isFolded()) {
         const float dpr = mFb->getDpr();

         post.frameWidth = m_viewportWidth / dpr;
         post.frameHeight = m_viewportHeight / dpr;

         int displayOffsetX;
         int displayOffsetY;
         int displayW;
         int displayH;
         emugl::get_emugl_window_operations().getFoldedArea(&displayOffsetX, &displayOffsetY,
                                                            &displayW, &displayH);

         postLayerOptions.displayFrame = {
             .left = 0,
             .top = 0,
             .right = mFb->windowWidth(),
             .bottom = mFb->windowHeight(),
         };
         postLayerOptions.crop = {
             .left = static_cast<float>(displayOffsetX),
             .top = static_cast<float>(displayOffsetY + displayH),
             .right = static_cast<float>(displayOffsetX + displayW),
             .bottom = static_cast<float>(displayOffsetY),
         };
         postLayerOptions.transform = getTransformFromRotation(mFb->getZrot());

         post.layers.push_back(DisplayGl::PostLayer{
             .colorBuffer = cb,
             .layerOptions = postLayerOptions,
         });
     } else {
         post.layers.push_back(postWithOverlay(cb));
     }
     return m_displayGl->post(post);
 }

 DisplayGl::PostLayer PostWorkerGl::postWithOverlay(ColorBuffer* cb) {
     float dpr = mFb->getDpr();
     int windowWidth = mFb->windowWidth();
     int windowHeight = mFb->windowHeight();
     float px = mFb->getPx();
     float py = mFb->getPy();
     int zRot = mFb->getZrot();
     hwc_transform_t rotation = (hwc_transform_t)0;

     // Find the x and y values at the origin when "fully scrolled."
     // Multiply by 2 because the texture goes from -1 to 1, not 0 to 1.
     // Multiply the windowing coordinates by DPR because they ignore
     // DPR, but the viewport includes DPR.
     float fx = 2.f * (m_viewportWidth - windowWidth * dpr) / (float)m_viewportWidth;
     float fy = 2.f * (m_viewportHeight - windowHeight * dpr) / (float)m_viewportHeight;

     // finally, compute translation values
     float dx = px * fx;
     float dy = py * fy;

     return DisplayGl::PostLayer{
         .colorBuffer = cb,
         .overlayOptions =
             DisplayGl::PostLayer::OverlayOptions{
                 .rotation = static_cast<float>(zRot),
                 .dx = dx,
                 .dy = dy,
             },
     };
 }

 // Called whenever the subwindow needs a refresh (FrameBuffer::setupSubWindow).
 // This rebinds the subwindow context (to account for
 // when the refresh is a display change, for instance)
 // and resets the posting viewport.
 void PostWorkerGl::viewportImpl(int width, int height) {
     setupContext();
     const float dpr = mFb->getDpr();
     m_viewportWidth = width * dpr;
     m_viewportHeight = height * dpr;

     if (!m_displayGl) {
         GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "PostWorker missing DisplayGl.";
     }
     m_displayGl->viewport(m_viewportWidth, m_viewportHeight);
 }

 // Called when the subwindow refreshes, but there is no
 // last posted color buffer to show to the user. Instead of
 // displaying whatever happens to be in the back buffer,
 // clear() is useful for outputting consistent colors.
 void PostWorkerGl::clearImpl() {
     if (!mContextBound || m_mainThreadPostingOnly) {
         // This might happen on headless mode
         setupContext();
     }
     m_displayGl->clear();
 }

 std::shared_future<void> PostWorkerGl::composeImpl(const FlatComposeRequest& composeRequest) {
     if (!mContextBound || m_mainThreadPostingOnly) {
         // This might happen on headless mode
         setupContext();
     }
     return PostWorker::composeImpl(composeRequest);
 }

 void PostWorkerGl::setupContext() {
     android::base::AutoLock lock(mMutex);
     const auto* surface = getBoundSurface();
     const DisplaySurfaceGl* surfaceGl = nullptr;
     if (surface) {
         surfaceGl = static_cast<const DisplaySurfaceGl*>(surface->getImpl());
     } else {
         // Create a fake context.
         // This could happen in AEMU with -qt-hide-window. Also due to an Intel bug
         // this needs to happen on post thread.
         // b/274313125
         if (!mFakeWindowSurface) {
             mFakeWindowSurface = mEmulationGl->createFakeWindowSurface();
         }
         if (!mFakeWindowSurface) {
             ERR("Post worker does not have a window surface.");
             return;
         }
         surfaceGl = static_cast<const DisplaySurfaceGl*>(mFakeWindowSurface->getImpl());
     }

     // It will be no-op if it rebinds to the same context.
     // We need to retry just in case the surface is changed.

     // Also we could not use the scope context helper here,
     // because (1) binds and unbinds happen in very different places;
     // (2) they both need to happen in post thread, but the d'tor
     // of PostWorker can happen in a different thread.
     if (!surfaceGl->bindContext()) {
         ERR("Failed to bind to post worker context.");
         return;
     }
     mContextBound = true;
 }

 void PostWorkerGl::exitImpl() {
     if (!mContextBound) {
         return;
     }
     s_egl.eglMakeCurrent(s_egl.eglGetDisplay(EGL_DEFAULT_DISPLAY), nullptr, nullptr, nullptr);
     mContextBound = false;
 }

 }  // namespace gfxstream
	/*
	* Copyright (C) 2023 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 "PostWorkerGl.h"

	#include "FrameBuffer.h"
	#include "gl/DisplayGl.h"
	#include "gl/DisplaySurfaceGl.h"
	#include "host-common/GfxstreamFatalError.h"
	#include "host-common/logging.h"
	#include "host-common/misc.h"

	namespace gfxstream {

	namespace {

	using emugl::ABORT_REASON_OTHER;
	using emugl::FatalError;
	using gl::DisplayGl;
	using gl::DisplaySurfaceGl;
	using gl::EmulationGl;
	using gl::s_egl;

	hwc_transform_t getTransformFromRotation(int rotation) {
	switch (static_cast<int>(rotation / 90)) {
	case 1:
	return HWC_TRANSFORM_ROT_270;
	case 2:
	return HWC_TRANSFORM_ROT_180;
	case 3:
	return HWC_TRANSFORM_ROT_90;
	default:
	return HWC_TRANSFORM_NONE;
	}
	}

	} // namespace

	PostWorkerGl::PostWorkerGl(bool mainThreadPostingOnly, FrameBuffer* fb, Compositor* compositor,
	DisplayGl* displayGl, gl::EmulationGl* emulationGl)
	: PostWorker(mainThreadPostingOnly, fb, compositor),
	m_displayGl(displayGl),
	mEmulationGl(emulationGl) {
	if (!m_displayGl) {
	GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "PostWorker missing DisplayGl.";
	}
	}

	void PostWorkerGl::screenshot(ColorBuffer* cb, int screenwidth, int screenheight, GLenum format,
	GLenum type, int skinRotation, void* pixels, Rect rect) {
	// See b/292237104.
	mFb->lock();
	cb->readToBytesScaled(screenwidth, screenheight, format, type, skinRotation, rect, pixels);
	mFb->unlock();
	}

	std::shared_future<void> PostWorkerGl::postImpl(ColorBuffer* cb) {
	if (!mContextBound \|\| m_mainThreadPostingOnly) {
	// This might happen on headless mode
	// Also if posting on main thread, the context binding can get polluted easily, which
	// requires frequent rebinds.
	setupContext();
	}
	std::shared_future<void> completedFuture = std::async(std::launch::deferred, [] {}).share();
	completedFuture.wait();

	DisplayGl::Post post = {};

	ComposeLayer postLayerOptions = {
	.composeMode = HWC2_COMPOSITION_DEVICE,
	.blendMode = HWC2_BLEND_MODE_NONE,
	.alpha = 1.0f,
	.transform = HWC_TRANSFORM_NONE,
	};

	const auto& multiDisplay = emugl::get_emugl_multi_display_operations();
	const bool pixel_fold = multiDisplay.isPixelFold();
	if (pixel_fold) {
	#ifdef CONFIG_AEMU
	if (emugl::shouldSkipDraw()) {
	post.layers.clear();
	} else {
	post.layers.push_back(postWithOverlay(cb));
	}
	#endif
	}
	else if (multiDisplay.isMultiDisplayEnabled()) {
	if (multiDisplay.isMultiDisplayWindow()) {
	int32_t previousDisplayId = -1;
	uint32_t currentDisplayId;
	uint32_t currentDisplayColorBufferHandle;
	while (multiDisplay.getNextMultiDisplay(previousDisplayId, &currentDisplayId,
	/x=/nullptr,
	/y=/nullptr,
	/w=/nullptr,
	/h=/nullptr,
	/dpi=/nullptr,
	/flags=/nullptr,
	&currentDisplayColorBufferHandle)) {
	previousDisplayId = currentDisplayId;

	if (currentDisplayColorBufferHandle == 0) {
	continue;
	}
	emugl::get_emugl_window_operations().paintMultiDisplayWindow(
	currentDisplayId, currentDisplayColorBufferHandle);
	}
	post.layers.push_back(postWithOverlay(cb));
	} else {
	uint32_t combinedDisplayW = 0;
	uint32_t combinedDisplayH = 0;
	multiDisplay.getCombinedDisplaySize(&combinedDisplayW, &combinedDisplayH);

	post.frameWidth = combinedDisplayW;
	post.frameHeight = combinedDisplayH;

	int32_t previousDisplayId = -1;
	uint32_t currentDisplayId;
	int32_t currentDisplayOffsetX;
	int32_t currentDisplayOffsetY;
	uint32_t currentDisplayW;
	uint32_t currentDisplayH;
	uint32_t currentDisplayColorBufferHandle;
	while (multiDisplay.getNextMultiDisplay(
	previousDisplayId, &currentDisplayId, &currentDisplayOffsetX,
	&currentDisplayOffsetY, &currentDisplayW, &currentDisplayH,
	/dpi=/nullptr,
	/flags=/nullptr, &currentDisplayColorBufferHandle)) {
	previousDisplayId = currentDisplayId;

	if (currentDisplayW == 0 \|\| currentDisplayH == 0 \|\|
	(currentDisplayId != 0 && currentDisplayColorBufferHandle == 0)) {
	continue;
	}

	ColorBuffer* currentCb =
	currentDisplayId == 0
	? cb
	: mFb->findColorBuffer(currentDisplayColorBufferHandle).get();
	if (!currentCb) {
	continue;
	}

	const auto transform = getTransformFromRotation(mFb->getZrot());
	postLayerOptions.transform = transform;
	if ( transform == HWC_TRANSFORM_ROT_90 \|\| transform == HWC_TRANSFORM_ROT_270) {
	std::swap(currentDisplayW, currentDisplayH);
	}
	postLayerOptions.displayFrame = {
	.left = static_cast<int>(currentDisplayOffsetX),
	.top = static_cast<int>(currentDisplayOffsetY),
	.right = static_cast<int>(currentDisplayOffsetX + currentDisplayW),
	.bottom = static_cast<int>(currentDisplayOffsetY + currentDisplayH),
	};
	postLayerOptions.crop = {
	.left = 0.0f,
	.top = static_cast<float>(currentCb->getHeight()),
	.right = static_cast<float>(currentCb->getWidth()),
	.bottom = 0.0f,
	};

	post.layers.push_back(DisplayGl::PostLayer{
	.colorBuffer = currentCb,
	.layerOptions = postLayerOptions,
	});
	}
	}
	} else if (emugl::get_emugl_window_operations().isFolded()) {
	const float dpr = mFb->getDpr();

	post.frameWidth = m_viewportWidth / dpr;
	post.frameHeight = m_viewportHeight / dpr;

	int displayOffsetX;
	int displayOffsetY;
	int displayW;
	int displayH;
	emugl::get_emugl_window_operations().getFoldedArea(&displayOffsetX, &displayOffsetY,
	&displayW, &displayH);

	postLayerOptions.displayFrame = {
	.left = 0,
	.top = 0,
	.right = mFb->windowWidth(),
	.bottom = mFb->windowHeight(),
	};
	postLayerOptions.crop = {
	.left = static_cast<float>(displayOffsetX),
	.top = static_cast<float>(displayOffsetY + displayH),
	.right = static_cast<float>(displayOffsetX + displayW),
	.bottom = static_cast<float>(displayOffsetY),
	};
	postLayerOptions.transform = getTransformFromRotation(mFb->getZrot());

	post.layers.push_back(DisplayGl::PostLayer{
	.colorBuffer = cb,
	.layerOptions = postLayerOptions,
	});
	} else {
	post.layers.push_back(postWithOverlay(cb));
	}
	return m_displayGl->post(post);
	}

	DisplayGl::PostLayer PostWorkerGl::postWithOverlay(ColorBuffer* cb) {
	float dpr = mFb->getDpr();
	int windowWidth = mFb->windowWidth();
	int windowHeight = mFb->windowHeight();
	float px = mFb->getPx();
	float py = mFb->getPy();
	int zRot = mFb->getZrot();
	hwc_transform_t rotation = (hwc_transform_t)0;

	// Find the x and y values at the origin when "fully scrolled."
	// Multiply by 2 because the texture goes from -1 to 1, not 0 to 1.
	// Multiply the windowing coordinates by DPR because they ignore
	// DPR, but the viewport includes DPR.
	float fx = 2.f * (m_viewportWidth - windowWidth * dpr) / (float)m_viewportWidth;
	float fy = 2.f * (m_viewportHeight - windowHeight * dpr) / (float)m_viewportHeight;

	// finally, compute translation values
	float dx = px * fx;
	float dy = py * fy;

	return DisplayGl::PostLayer{
	.colorBuffer = cb,
	.overlayOptions =
	DisplayGl::PostLayer::OverlayOptions{
	.rotation = static_cast<float>(zRot),
	.dx = dx,
	.dy = dy,
	},
	};
	}

	// Called whenever the subwindow needs a refresh (FrameBuffer::setupSubWindow).
	// This rebinds the subwindow context (to account for
	// when the refresh is a display change, for instance)
	// and resets the posting viewport.
	void PostWorkerGl::viewportImpl(int width, int height) {
	setupContext();
	const float dpr = mFb->getDpr();
	m_viewportWidth = width * dpr;
	m_viewportHeight = height * dpr;

	if (!m_displayGl) {
	GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "PostWorker missing DisplayGl.";
	}
	m_displayGl->viewport(m_viewportWidth, m_viewportHeight);
	}

	// Called when the subwindow refreshes, but there is no
	// last posted color buffer to show to the user. Instead of
	// displaying whatever happens to be in the back buffer,
	// clear() is useful for outputting consistent colors.
	void PostWorkerGl::clearImpl() {
	if (!mContextBound \|\| m_mainThreadPostingOnly) {
	// This might happen on headless mode
	setupContext();
	}
	m_displayGl->clear();
	}

	std::shared_future<void> PostWorkerGl::composeImpl(const FlatComposeRequest& composeRequest) {
	if (!mContextBound \|\| m_mainThreadPostingOnly) {
	// This might happen on headless mode
	setupContext();
	}
	return PostWorker::composeImpl(composeRequest);
	}

	void PostWorkerGl::setupContext() {
	android::base::AutoLock lock(mMutex);
	const auto* surface = getBoundSurface();
	const DisplaySurfaceGl* surfaceGl = nullptr;
	if (surface) {
	surfaceGl = static_cast<const DisplaySurfaceGl*>(surface->getImpl());
	} else {
	// Create a fake context.
	// This could happen in AEMU with -qt-hide-window. Also due to an Intel bug
	// this needs to happen on post thread.
	// b/274313125
	if (!mFakeWindowSurface) {
	mFakeWindowSurface = mEmulationGl->createFakeWindowSurface();
	}
	if (!mFakeWindowSurface) {
	ERR("Post worker does not have a window surface.");
	return;
	}
	surfaceGl = static_cast<const DisplaySurfaceGl*>(mFakeWindowSurface->getImpl());
	}

	// It will be no-op if it rebinds to the same context.
	// We need to retry just in case the surface is changed.

	// Also we could not use the scope context helper here,
	// because (1) binds and unbinds happen in very different places;
	// (2) they both need to happen in post thread, but the d'tor
	// of PostWorker can happen in a different thread.
	if (!surfaceGl->bindContext()) {
	ERR("Failed to bind to post worker context.");
	return;
	}
	mContextBound = true;
	}

	void PostWorkerGl::exitImpl() {
	if (!mContextBound) {
	return;
	}
	s_egl.eglMakeCurrent(s_egl.eglGetDisplay(EGL_DEFAULT_DISPLAY), nullptr, nullptr, nullptr);
	mContextBound = false;
	}

	} // namespace gfxstream