werunplugged/unplugged-system
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
06ee9615ad
unplugged-system/device/generic/vulkan-cereal/stream-servers/FrameBuffer.h

919 lines
41 KiB
C++
Raw Blame History

/*
* Copyright (C) 2011-2015 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 _LIBRENDER_FRAMEBUFFER_H
#define _LIBRENDER_FRAMEBUFFER_H
#include <EGL/egl.h>
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#include <stdint.h>
#include <array>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <unordered_map>
#include <unordered_set>
#include "Buffer.h"
#include "Compositor.h"
#include "Display.h"
#include "DisplaySurface.h"
#include "Hwc2.h"
#include "PostCommands.h"
#include "PostWorker.h"
#include "ReadbackWorker.h"
#include "VsyncThread.h"
#include "aemu/base/AsyncResult.h"
#include "aemu/base/EventNotificationSupport.h"
#include "aemu/base/HealthMonitor.h"
#include "aemu/base/ManagedDescriptor.hpp"
#include "aemu/base/Metrics.h"
#include "aemu/base/files/Stream.h"
#include "aemu/base/synchronization/Lock.h"
#include "aemu/base/synchronization/MessageChannel.h"
#include "aemu/base/threads/Thread.h"
#include "aemu/base/threads/WorkerThread.h"
#include "gl/BufferGl.h"
#include "gl/ColorBufferGl.h"
#include "gl/CompositorGl.h"
#include "gl/DisplaySurfaceGl.h"
#include "gl/EmulatedEglConfig.h"
#include "gl/EmulatedEglContext.h"
#include "gl/EmulatedEglImage.h"
#include "gl/EmulatedEglWindowSurface.h"
#include "gl/EmulationGl.h"
#include "gl/GLESVersionDetector.h"
#include "gl/TextureDraw.h"
#include "render-utils/Renderer.h"
#include "render-utils/virtio_gpu_ops.h"
#include "render_api.h"
#include "snapshot/common.h"
#include "utils/RenderDoc.h"
#include "vulkan/vk_util.h"
namespace gfxstream {
namespace vk {
class DisplayVk;
} // namespace vk
} // namespace gfxstream
namespace gfxstream {
using android::base::CreateMetricsLogger;
using emugl::HealthMonitor;
using emugl::MetricsLogger;
struct BufferRef {
BufferPtr buffer;
};
class ProcessResources {
public:
// We only allow ProcessResources to be created on the heap, because the pointer to
// mSequenceNumber shouldn't change until ProcessResources is destroyed.
static std::unique_ptr<ProcessResources> create() {
return std::unique_ptr<ProcessResources>(new ProcessResources());
}
DISALLOW_COPY_ASSIGN_AND_MOVE(ProcessResources);
~ProcessResources() = default;
std::atomic<uint32_t>* getSequenceNumberPtr() const {
return &mSequenceNumber;
}
private:
ProcessResources() : mSequenceNumber(0) {}
mutable std::atomic<uint32_t> mSequenceNumber;
};
typedef std::unordered_map<uint64_t, gl::EmulatedEglWindowSurfaceSet>
ProcOwnedEmulatedEglWindowSurfaces;
typedef std::unordered_map<uint64_t, gl::EmulatedEglContextSet> ProcOwnedEmulatedEglContexts;
typedef std::unordered_map<uint64_t, ColorBufferSet> ProcOwnedColorBuffers;
typedef std::unordered_map<HandleType, BufferRef> BufferMap;
typedef std::unordered_multiset<HandleType> BufferSet;
typedef std::unordered_map<uint64_t, BufferSet> ProcOwnedBuffers;
typedef std::unordered_map<uint64_t, gl::EmulatedEglImageSet> ProcOwnedEmulatedEGLImages;
typedef std::unordered_map<void*, std::function<void()>> CallbackMap;
typedef std::unordered_map<uint64_t, CallbackMap> ProcOwnedCleanupCallbacks;
// The FrameBuffer class holds the global state of the emulation library on
// top of the underlying EGL/GLES implementation. It should probably be
// named "Display" instead of "FrameBuffer".
//
// There is only one global instance, that can be retrieved with getFB(),
// and which must be previously setup by calling initialize().
//
class FrameBuffer : public android::base::EventNotificationSupport<FrameBufferChangeEvent> {
public:
// Initialize the global instance.
// |width| and |height| are the dimensions of the emulator GPU display
// in pixels. |useSubWindow| is true to indicate that the caller
// will use setupSubWindow() to let EmuGL display the GPU content in its
// own sub-windows. If false, this means the caller will use
// setPostCallback() instead to retrieve the content.
// Returns true on success, false otherwise.
static bool initialize(int width, int height, bool useSubWindow,
bool egl2egl);
// Finalize the instance.
static void finalize();
// Setup a sub-window to display the content of the emulated GPU
// on-top of an existing UI window. |p_window| is the platform-specific
// parent window handle. |wx|, |wy|, |ww| and |wh| are the
// dimensions in pixels of the sub-window, relative to the parent window's
// coordinate. |fbw| and |fbh| are the dimensions used to initialize
// the framebuffer, which may be different from the dimensions of the
// sub-window (in which case scaling will be applied automatically).
// |dpr| is the device pixel ratio of the monitor, which is needed for
// proper panning on high-density displays (like retina)
// |zRot| is a rotation angle in degrees, (clockwise in the Y-upwards GL
// coordinate space).
//
// If a sub-window already exists, this function updates the subwindow
// and framebuffer properties to match the given values.
//
// Return true on success, false otherwise.
//
// NOTE: This can return false for software-only EGL engines like OSMesa.
bool setupSubWindow(FBNativeWindowType p_window, int wx, int wy, int ww,
int wh, int fbw, int fbh, float dpr, float zRot,
bool deleteExisting, bool hideWindow);
// Remove the sub-window created by setupSubWindow(), if any.
// Return true on success, false otherwise.
bool removeSubWindow();
// Return a pointer to the global instance. initialize() must be called
// previously, or this will return NULL.
static FrameBuffer* getFB() { return s_theFrameBuffer; }
// Wait for a FrameBuffer instance to be initialized and ready to use.
// This function blocks the caller until there is a valid initialized
// object in getFB() and
static void waitUntilInitialized();
// Return the emulated GPU display width in pixels.
int getWidth() const { return m_framebufferWidth; }
// Return the emulated GPU display height in pixels.
int getHeight() const { return m_framebufferHeight; }
// Return the list of configs available from this display.
const gl::EmulatedEglConfigList* getConfigs() const;
// Set a callback that will be called each time the emulated GPU content
// is updated. This can be relatively slow with host-based GPU emulation,
// so only do this when you need to.
void setPostCallback(Renderer::OnPostCallback onPost, void* onPostContext, uint32_t displayId,
bool useBgraReadback = false);
// Retrieve the GL strings of the underlying EGL/GLES implementation.
// On return, |*vendor|, |*renderer| and |*version| will point to strings
// that are owned by the instance (and must not be freed by the caller).
void getGLStrings(const char** vendor, const char** renderer,
const char** version) const {
*vendor = m_graphicsAdapterVendor.c_str();
*renderer = m_graphicsAdapterName.c_str();
*version = m_graphicsApiVersion.c_str();
}
// Create a new EmulatedEglContext instance for this display instance.
// |p_config| is the index of one of the configs returned by getConfigs().
// |p_share| is either EGL_NO_CONTEXT or the handle of a shared context.
// |version| specifies the GLES version as a GLESApi enum.
// Return a new handle value, which will be 0 in case of error.
HandleType createEmulatedEglContext(int p_config, HandleType p_share,
gl::GLESApi version = gl::GLESApi_CM);
// Destroy a given EmulatedEglContext instance. |p_context| is its handle
// value as returned by createEmulatedEglContext().
void destroyEmulatedEglContext(HandleType p_context);
// Create a new EmulatedEglWindowSurface instance from this display instance.
// |p_config| is the index of one of the configs returned by getConfigs().
// |p_width| and |p_height| are the window dimensions in pixels.
// Return a new handle value, or 0 in case of error.
HandleType createEmulatedEglWindowSurface(int p_config, int p_width, int p_height);
// Destroy a given EmulatedEglWindowSurface instance. |p_surcace| is its
// handle value as returned by createEmulatedEglWindowSurface().
void destroyEmulatedEglWindowSurface(HandleType p_surface);
// Returns the set of ColorBuffers destroyed (for further cleanup)
std::vector<HandleType> destroyEmulatedEglWindowSurfaceLocked(HandleType p_surface);
void createEmulatedEglFenceSync(EGLenum type,
int destroyWhenSignaled,
uint64_t* outSync = nullptr,
uint64_t* outSyncThread = nullptr);
// Create a new ColorBuffer instance from this display instance.
// |p_width| and |p_height| are its dimensions in pixels.
// |p_internalFormat| is the OpenGL format of this color buffer.
// |p_frameworkFormat| describes the Android frameework format of this
// color buffer, if differing from |p_internalFormat|.
// See ColorBuffer::create() for
// list of valid values. Note that ColorBuffer instances are reference-
// counted. Use openColorBuffer / closeColorBuffer to operate on the
// internal count.
HandleType createColorBuffer(int p_width, int p_height,
GLenum p_internalFormat,
FrameworkFormat p_frameworkFormat);
// Variant of createColorBuffer except with a particular
// handle already assigned. This is for use with
// virtio-gpu's RESOURCE_CREATE ioctl.
void createColorBufferWithHandle(int p_width, int p_height, GLenum p_internalFormat,
FrameworkFormat p_frameworkFormat, HandleType handle);
// Create a new data Buffer instance from this display instance.
// The buffer will be backed by a VkBuffer and VkDeviceMemory (if Vulkan
// is available).
// |size| is the requested size of Buffer in bytes.
// |memoryProperty| is the requested memory property bits of the device
// memory.
HandleType createBuffer(uint64_t size, uint32_t memoryProperty);
// Variant of createBuffer except with a particular handle already
// assigned and using device local memory. This is for use with
// virtio-gpu's RESOURCE_CREATE ioctl for BLOB resources.
void createBufferWithHandle(uint64_t size, HandleType handle);
// Call this function when a render thread terminates to destroy all
// resources it created. Necessary to avoid leaking host resources
// when a guest application crashes, for example.
void drainGlRenderThreadResources();
// Call this function when a render thread terminates to destroy all
// the remaining contexts it created. Necessary to avoid leaking host
// contexts when a guest application crashes, for example.
void drainGlRenderThreadContexts();
// Call this function when a render thread terminates to destroy all
// remaining window surface it created. Necessary to avoid leaking
// host buffers when a guest application crashes, for example.
void drainGlRenderThreadSurfaces();
// Increment the reference count associated with a given ColorBuffer
// instance. |p_colorbuffer| is its handle value as returned by
// createColorBuffer().
int openColorBuffer(HandleType p_colorbuffer);
// Decrement the reference count associated with a given ColorBuffer
// instance. |p_colorbuffer| is its handle value as returned by
// createColorBuffer(). Note that if the reference count reaches 0,
// the instance is destroyed automatically.
void closeColorBuffer(HandleType p_colorbuffer);
// Destroy a Buffer created previously. |p_buffer| is its handle value as
// returned by createBuffer().
void closeBuffer(HandleType p_colorbuffer);
// The caller mustn't refer to this puid before this function returns, i.e. the creation of the
// host process pipe must be blocked until this function returns.
void createGraphicsProcessResources(uint64_t puid);
// The process resource is returned so that we can destroy it on a separate thread.
std::unique_ptr<ProcessResources> removeGraphicsProcessResources(uint64_t puid);
// TODO(kaiyili): retire cleanupProcGLObjects in favor of removeGraphicsProcessResources.
void cleanupProcGLObjects(uint64_t puid);
// Equivalent for eglMakeCurrent() for the current display.
// |p_context|, |p_drawSurface| and |p_readSurface| are the handle values
// of the context, the draw surface and the read surface, respectively.
// Returns true on success, false on failure.
// Note: if all handle values are 0, this is an unbind operation.
bool bindContext(HandleType p_context, HandleType p_drawSurface,
HandleType p_readSurface);
// Return a render context pointer from its handle
gl::EmulatedEglContextPtr getContext_locked(HandleType p_context);
// Return a color buffer pointer from its handle
gl::EmulatedEglWindowSurfacePtr getWindowSurface_locked(HandleType p_windowsurface);
// Attach a ColorBuffer to a EmulatedEglWindowSurface instance.
// See the documentation for EmulatedEglWindowSurface::setColorBuffer().
// |p_surface| is the target EmulatedEglWindowSurface's handle value.
// |p_colorbuffer| is the ColorBuffer handle value.
// Returns true on success, false otherwise.
bool setEmulatedEglWindowSurfaceColorBuffer(HandleType p_surface,
HandleType p_colorbuffer);
// Copy the content of a EmulatedEglWindowSurface's Pbuffer to its attached
// ColorBuffer. See the documentation for
// EmulatedEglWindowSurface::flushColorBuffer().
// |p_surface| is the target WindowSurface's handle value.
// Returns true on success, false on failure.
bool flushEmulatedEglWindowSurfaceColorBuffer(HandleType p_surface);
// Retrieves the color buffer handle associated with |p_surface|.
// Returns 0 if there is no such handle.
HandleType getEmulatedEglWindowSurfaceColorBufferHandle(HandleType p_surface);
// Bind the current context's EGL_TEXTURE_2D texture to a ColorBuffer
// instance's EGLImage. This is intended to implement
// glEGLImageTargetTexture2DOES() for all GLES versions.
// |p_colorbuffer| is the ColorBuffer's handle value.
// Returns true on success, false on failure.
bool bindColorBufferToTexture(HandleType p_colorbuffer);
bool bindColorBufferToTexture2(HandleType p_colorbuffer);
// Bind the current context's EGL_RENDERBUFFER_OES render buffer to this
// ColorBuffer's EGLImage. This is intended to implement
// glEGLImageTargetRenderbufferStorageOES() for all GLES versions.
// |p_colorbuffer| is the ColorBuffer's handle value.
// Returns true on success, false on failure.
bool bindColorBufferToRenderbuffer(HandleType p_colorbuffer);
// Read the content of a given Buffer into client memory.
// |p_buffer| is the Buffer's handle value.
// |offset| and |size| are the position and size of a slice of the buffer
// that will be read.
// |bytes| is the address of a caller-provided buffer that will be filled
// with the buffer data.
void readBuffer(HandleType p_buffer, uint64_t offset, uint64_t size, void* bytes);
// Read the content of a given ColorBuffer into client memory.
// |p_colorbuffer| is the ColorBuffer's handle value. Similar
// to glReadPixels(), this can be a slow operation.
// |x|, |y|, |width| and |height| are the position and dimensions of
// a rectangle whose pixel values will be transfered to the host.
// |format| indicates the format of the pixel data, e.g. GL_RGB or GL_RGBA.
// |type| is the type of pixel data, e.g. GL_UNSIGNED_BYTE.
// |pixels| is the address of a caller-provided buffer that will be filled
// with the pixel data.
void readColorBuffer(HandleType p_colorbuffer, int x, int y, int width,
int height, GLenum format, GLenum type, void* pixels);
// Read the content of a given YUV420_888 ColorBuffer into client memory.
// |p_colorbuffer| is the ColorBuffer's handle value. Similar
// to glReadPixels(), this can be a slow operation.
// |x|, |y|, |width| and |height| are the position and dimensions of
// a rectangle whose pixel values will be transfered to the host.
// |pixels| is the address of a caller-provided buffer that will be filled
// with the pixel data.
// |pixles_size| is the size of buffer
void readColorBufferYUV(HandleType p_colorbuffer, int x, int y, int width,
int height, void* pixels, uint32_t pixels_size);
// create a Y texture and a UV texture with width and height, the created
// texture ids are stored in textures respectively
void createYUVTextures(uint32_t type, uint32_t count, int width, int height,
uint32_t* output);
void destroyYUVTextures(uint32_t type, uint32_t count, uint32_t* textures);
void updateYUVTextures(uint32_t type, uint32_t* textures, void* privData,
void* func);
void swapTexturesAndUpdateColorBuffer(uint32_t colorbufferhandle, int x,
int y, int width, int height,
uint32_t format, uint32_t type,
uint32_t texture_type,
uint32_t* textures);
// Update the content of a given Buffer from client data.
// |p_buffer| is the Buffer's handle value.
// |offset| and |size| are the position and size of a slice of the buffer
// that will be updated.
// |bytes| is the address of a caller-provided buffer containing the new
// buffer data.
bool updateBuffer(HandleType p_buffer, uint64_t offset, uint64_t size, void* pixels);
// Update the content of a given ColorBuffer from client data.
// |p_colorbuffer| is the ColorBuffer's handle value. Similar
// to glReadPixels(), this can be a slow operation.
// |x|, |y|, |width| and |height| are the position and dimensions of
// a rectangle whose pixel values will be transfered to the GPU
// |format| indicates the format of the OpenGL buffer, e.g. GL_RGB or
// GL_RGBA. |frameworkFormat| indicates the format of the pixel data; if
// FRAMEWORK_FORMAT_GL_COMPATIBLE, |format| (OpenGL format) is used.
// Otherwise, explicit conversion to |format| is needed.
// |type| is the type of pixel data, e.g. GL_UNSIGNED_BYTE.
// |pixels| is the address of a buffer containing the new pixel data.
// Returns true on success, false otherwise.
bool updateColorBuffer(HandleType p_colorbuffer, int x, int y, int width,
int height, GLenum format, GLenum type,
void* pixels);
bool updateColorBufferFromFrameworkFormat(HandleType p_colorbuffer, int x, int y, int width,
int height, FrameworkFormat fwkFormat, GLenum format,
GLenum type, void* pixels);
// Reads back the raw color buffer to |pixels|
// if |pixels| is not null.
// Always returns in |numBytes| how many bytes were
// planned to be transmitted.
// |numBytes| is not an input parameter;
// fewer or more bytes cannot be specified.
// If the framework format is YUV, it will read
// back as raw YUV data.
bool readColorBufferContents(HandleType p_colorbuffer, size_t* numBytes,
void* pixels);
bool getColorBufferInfo(HandleType p_colorbuffer, int* width, int* height,
GLint* internalformat,
FrameworkFormat* frameworkFormat = nullptr);
bool getBufferInfo(HandleType p_buffer, int* size);
// Display the content of a given ColorBuffer into the framebuffer's
// sub-window. |p_colorbuffer| is a handle value.
// |needLockAndBind| is used to indicate whether the operation requires
// acquiring/releasing the FrameBuffer instance's lock and binding the
// contexts. It should be |false| only when called internally.
bool post(HandleType p_colorbuffer, bool needLockAndBind = true);
// The callback will always be called; however, the callback may not be called
// until after this function has returned. If the callback is deferred, then it
// will be dispatched to run on SyncThread.
void postWithCallback(HandleType p_colorbuffer, Post::CompletionCallback callback, bool needLockAndBind = true);
bool hasGuestPostedAFrame() { return m_guestPostedAFrame; }
void resetGuestPostedAFrame() { m_guestPostedAFrame = false; }
// Runs the post callback with |pixels| (good for when the readback
// happens in a separate place)
void doPostCallback(void* pixels, uint32_t displayId);
void getPixels(void* pixels, uint32_t bytes, uint32_t displayId);
void flushReadPipeline(int displayId);
void ensureReadbackWorker();
bool asyncReadbackSupported();
Renderer::ReadPixelsCallback getReadPixelsCallback();
Renderer::FlushReadPixelPipeline getFlushReadPixelPipeline();
// Re-post the last ColorBuffer that was displayed through post().
// This is useful if you detect that the sub-window content needs to
// be re-displayed for any reason.
bool repost(bool needLockAndBind = true);
gl::EmulationGl& getEmulationGl();
bool hasEmulationGl() const { return m_emulationGl != nullptr; }
// Return the host EGLDisplay used by this instance.
EGLDisplay getDisplay() const;
EGLSurface getWindowSurface() const;
EGLContext getContext() const;
EGLConfig getConfig() const;
ContextHelper* getPbufferSurfaceContextHelper() const;
// Change the rotation of the displayed GPU sub-window.
void setDisplayRotation(float zRot) {
if (zRot != m_zRot) {
m_zRot = zRot;
repost();
}
}
// Changes what coordinate of this framebuffer will be displayed at the
// corner of the GPU sub-window. Specifically, |px| and |py| = 0 means
// align the bottom-left of the framebuffer with the bottom-left of the
// sub-window, and |px| and |py| = 1 means align the top right of the
// framebuffer with the top right of the sub-window. Intermediate values
// interpolate between these states.
void setDisplayTranslation(float px, float py) {
// Sanity check the values to ensure they are between 0 and 1
const float x = px > 1.f ? 1.f : (px < 0.f ? 0.f : px);
const float y = py > 1.f ? 1.f : (py < 0.f ? 0.f : py);
if (x != m_px || y != m_py) {
m_px = x;
m_py = y;
repost();
}
}
// Return a TextureDraw instance that can be used with this surfaces
// and windows created by this instance.
gl::TextureDraw* getTextureDraw() const;
// Create an eglImage and return its handle. Reference:
// https://www.khronos.org/registry/egl/extensions/KHR/EGL_KHR_image_base.txt
HandleType createEmulatedEglImage(HandleType context, EGLenum target,
GLuint buffer);
// Call the implementation of eglDestroyImageKHR, return if succeeds or
// not. Reference:
// https://www.khronos.org/registry/egl/extensions/KHR/EGL_KHR_image_base.txt
EGLBoolean destroyEmulatedEglImage(HandleType image);
void lockContextStructureRead() { m_contextStructureLock.lockRead(); }
void unlockContextStructureRead() { m_contextStructureLock.unlockRead(); }
// For use with sync threads and otherwise, any time we need a GL context
// not specifically for drawing, but to obtain certain things about
// GL state.
// It can be unsafe / leaky to change the structure of contexts
// outside the facilities the FrameBuffer class provides.
void createTrivialContext(HandleType shared, HandleType* contextOut,
HandleType* surfOut);
// createTrivialContext(), but with a m_pbufContext
// as shared, and not adding itself to the context map at all.
void createSharedTrivialContext(EGLContext* contextOut, EGLSurface* surfOut);
void destroySharedTrivialContext(EGLContext context, EGLSurface surf);
void setShuttingDown() { m_shuttingDown = true; }
bool isShuttingDown() const { return m_shuttingDown; }
bool compose(uint32_t bufferSize, void* buffer, bool post = true);
// When false is returned, the callback won't be called. The callback will
// be called on the PostWorker thread without blocking the current thread.
AsyncResult composeWithCallback(uint32_t bufferSize, void* buffer,
Post::CompletionCallback callback);
~FrameBuffer();
void onSave(android::base::Stream* stream,
const android::snapshot::ITextureSaverPtr& textureSaver);
bool onLoad(android::base::Stream* stream,
const android::snapshot::ITextureLoaderPtr& textureLoader);
// lock and unlock handles (EmulatedEglContext, ColorBuffer, EmulatedEglWindowSurface)
void lock();
void unlock();
gl::GLESDispatchMaxVersion getMaxGLESVersion();
float getDpr() const { return m_dpr; }
int windowWidth() const { return m_windowWidth; }
int windowHeight() const { return m_windowHeight; }
float getPx() const { return m_px; }
float getPy() const { return m_py; }
int getZrot() const { return m_zRot; }
bool isFastBlitSupported() const;
void disableFastBlitForTesting();
bool isVulkanInteropSupported() const { return m_vulkanInteropSupported; }
bool isVulkanEnabled() const { return m_vulkanEnabled; }
// Fill GLES usage protobuf
void fillGLESUsages(android_studio::EmulatorGLESUsages*);
// Saves a screenshot of the previous frame.
// nChannels should be 3 (RGB) or 4 (RGBA).
// You must provide a pre-allocated buffer of sufficient
// size. Returns 0 on success. In the case of failure and if *cPixels != 0
// you can call this function again with a buffer of size *cPixels. cPixels
// should usually be at at least desiredWidth * desiredHeight * nChannels.
//
// In practice the buffer should be > desiredWidth *
// desiredHeight * nChannels.
//
// Note: Do not call this function again if it fails and *cPixels == 0
// swiftshader_indirect does not work with 3 channels
//
// This function supports rectangle snipping by
// providing an |rect| parameter. The default value of {{0,0}, {0,0}}
// indicates the users wants to snip the entire screen instead of a
// partial screen.
// - |rect| represents a rectangle within the screen defined by
// desiredWidth and desiredHeight.
int getScreenshot(unsigned int nChannels, unsigned int* width, unsigned int* height,
uint8_t* pixels, size_t* cPixels, int displayId, int desiredWidth,
int desiredHeight, int desiredRotation, Rect rect = {{0, 0}, {0, 0}});
void onLastColorBufferRef(uint32_t handle);
ColorBufferPtr findColorBuffer(HandleType p_colorbuffer);
BufferPtr findBuffer(HandleType p_buffer);
void registerProcessCleanupCallback(void* key,
std::function<void()> callback);
void unregisterProcessCleanupCallback(void* key);
const ProcessResources* getProcessResources(uint64_t puid);
int createDisplay(uint32_t *displayId);
int createDisplay(uint32_t displayId);
int destroyDisplay(uint32_t displayId);
int setDisplayColorBuffer(uint32_t displayId, uint32_t colorBuffer);
int getDisplayColorBuffer(uint32_t displayId, uint32_t* colorBuffer);
int getColorBufferDisplay(uint32_t colorBuffer, uint32_t* displayId);
int getDisplayPose(uint32_t displayId, int32_t* x, int32_t* y, uint32_t* w,
uint32_t* h);
int setDisplayPose(uint32_t displayId, int32_t x, int32_t y, uint32_t w,
uint32_t h, uint32_t dpi = 0);
void getCombinedDisplaySize(int* w, int* h);
struct DisplayInfo {
uint32_t cb;
int32_t pos_x;
int32_t pos_y;
uint32_t width;
uint32_t height;
uint32_t dpi;
DisplayInfo()
: cb(0), pos_x(0), pos_y(0), width(0), height(0), dpi(0){};
DisplayInfo(uint32_t cb, int32_t x, int32_t y, uint32_t w, uint32_t h,
uint32_t d)
: cb(cb), pos_x(x), pos_y(y), width(w), height(h), dpi(d) {}
};
// Inline with MultiDisplay::s_invalidIdMultiDisplay
static const uint32_t s_invalidIdMultiDisplay = 0xFFFFFFAB;
static const uint32_t s_maxNumMultiDisplay = 11;
EGLContext getGlobalEGLContext() const;
HandleType getLastPostedColorBuffer() { return m_lastPostedColorBuffer; }
void waitForGpu(uint64_t eglsync);
void waitForGpuVulkan(uint64_t deviceHandle, uint64_t fenceHandle);
void asyncWaitForGpuWithCb(uint64_t eglsync, FenceCompletionCallback cb);
void asyncWaitForGpuVulkanWithCb(uint64_t deviceHandle, uint64_t fenceHandle, FenceCompletionCallback cb);
void asyncWaitForGpuVulkanQsriWithCb(uint64_t image, FenceCompletionCallback cb);
void waitForGpuVulkanQsri(uint64_t image);
bool platformImportResource(uint32_t handle, uint32_t info, void* resource);
void* platformCreateSharedEglContext(void);
bool platformDestroySharedEglContext(void* context);
void setGuestManagedColorBufferLifetime(bool guestManaged);
std::unique_ptr<BorrowedImageInfo> borrowColorBufferForComposition(uint32_t colorBufferHandle,
bool colorBufferIsTarget);
std::unique_ptr<BorrowedImageInfo> borrowColorBufferForDisplay(uint32_t colorBufferHandle);
HealthMonitor<>* getHealthMonitor() { return m_healthMonitor.get(); }
emugl::MetricsLogger& getMetricsLogger() {
return *m_logger;
}
void logVulkanOutOfMemory(VkResult result, const char* function, int line,
std::optional<uint64_t> allocationSize = std::nullopt);
void setVsyncHz(int vsyncHz);
void scheduleVsyncTask(VsyncThread::VsyncTask task);
void setDisplayConfigs(int configId, int w, int h, int dpiX, int dpiY);
void setDisplayActiveConfig(int configId);
const int getDisplayConfigsCount();
const int getDisplayConfigsParam(int configId, EGLint param);
const int getDisplayActiveConfig();
bool flushColorBufferFromGl(HandleType colorBufferHandle);
bool flushColorBufferFromGlLocked(HandleType colorBufferHandle);
bool flushColorBufferFromVk(HandleType colorBufferHandle);
bool flushColorBufferFromVkBytes(HandleType colorBufferHandle, const void* bytes, size_t bytesSize);
bool invalidateColorBufferForGl(HandleType colorBufferHandle);
bool invalidateColorBufferForVk(HandleType colorBufferHandle);
const gl::EGLDispatch* getEglDispatch();
const gl::GLESv2Dispatch* getGles2Dispatch();
private:
FrameBuffer(int p_width, int p_height, bool useSubWindow);
// Requires the caller to hold the m_colorBufferMapLock until the new handle is inserted into of
// the object handle maps.
HandleType genHandle_locked();
bool removeSubWindow_locked();
// Returns the set of ColorBuffers destroyed (for further cleanup)
std::vector<HandleType> cleanupProcGLObjects_locked(uint64_t puid,
bool forced = false);
void markOpened(ColorBufferRef* cbRef);
// Returns true if the color buffer was erased.
bool closeColorBufferLocked(HandleType p_colorbuffer, bool forced = false);
// Returns true if this was the last ref and we need to destroy stuff.
bool decColorBufferRefCountLocked(HandleType p_colorbuffer);
// Decrease refcount but not destroy the object.
// Mainly used in post thread, when we need to destroy the object but cannot in post thread.
void decColorBufferRefCountNoDestroy(HandleType p_colorbuffer);
// Close all expired color buffers for real.
// Treat all delayed color buffers as expired if forced=true
void performDelayedColorBufferCloseLocked(bool forced = false);
void eraseDelayedCloseColorBufferLocked(HandleType cb, uint64_t ts);
AsyncResult postImpl(HandleType p_colorbuffer, Post::CompletionCallback callback,
bool needLockAndBind = true, bool repaint = false);
bool postImplSync(HandleType p_colorbuffer, bool needLockAndBind = true, bool repaint = false);
void setGuestPostedAFrame() {
m_guestPostedAFrame = true;
fireEvent({FrameBufferChange::FrameReady, mFrameNumber++});
}
HandleType createColorBufferWithHandleLocked(int p_width, int p_height, GLenum p_internalFormat,
FrameworkFormat p_frameworkFormat,
HandleType handle);
HandleType createBufferWithHandleLocked(int p_size, HandleType handle, uint32_t memoryProperty);
void recomputeLayout();
void setDisplayPoseInSkinUI(int totalHeight);
void sweepColorBuffersLocked();
std::future<void> blockPostWorker(std::future<void> continueSignal);
private:
static FrameBuffer* s_theFrameBuffer;
static HandleType s_nextHandle;
int m_x = 0;
int m_y = 0;
int m_framebufferWidth = 0;
int m_framebufferHeight = 0;
std::atomic_int m_windowWidth = 0;
std::atomic_int m_windowHeight = 0;
float m_dpr = 0;
bool m_useSubWindow = false;
bool m_fpsStats = false;
bool m_perfStats = false;
int m_statsNumFrames = 0;
long long m_statsStartTime = 0;
android::base::Thread* m_perfThread;
android::base::Lock m_lock;
android::base::ReadWriteLock m_contextStructureLock;
android::base::Lock m_colorBufferMapLock;
uint64_t mFrameNumber;
FBNativeWindowType m_nativeWindow = 0;
gl::EmulatedEglContextMap m_contexts;
gl::EmulatedEglImageMap m_images;
gl::EmulatedEglWindowSurfaceMap m_windows;
ColorBufferMap m_colorbuffers;
BufferMap m_buffers;
std::unordered_map<HandleType, HandleType> m_EmulatedEglWindowSurfaceToColorBuffer;
// A collection of color buffers that were closed without any usages
// (|opened| == false).
//
// If a buffer reached |refcount| == 0 while not being |opened|, instead of
// deleting it we remember the timestamp when this happened. Later, we
// check if the buffer stayed unopened long enough and if it did, we delete
// it permanently. On the other hand, if the color buffer was used then
// we don't care about timestamps anymore.
//
// Note: this collection is ordered by |ts| field.
struct ColorBufferCloseInfo {
uint64_t ts; // when we got the close request.
HandleType cbHandle; // 0 == already closed, do nothing
};
using ColorBufferDelayedClose = std::vector<ColorBufferCloseInfo>;
ColorBufferDelayedClose m_colorBufferDelayedCloseList;
EGLNativeWindowType m_subWin = {};
HandleType m_lastPostedColorBuffer = 0;
float m_zRot = 0;
float m_px = 0;
float m_py = 0;
// Async readback
enum class ReadbackCmd {
Init = 0,
GetPixels = 1,
AddRecordDisplay = 2,
DelRecordDisplay = 3,
Exit = 4,
};
struct Readback {
ReadbackCmd cmd;
uint32_t displayId;
void* pixelsOut;
uint32_t bytes;
uint32_t width;
uint32_t height;
};
android::base::WorkerProcessingResult sendReadbackWorkerCmd(
const Readback& readback);
bool m_guestPostedAFrame = false;
struct onPost {
Renderer::OnPostCallback cb;
void* context;
uint32_t displayId;
uint32_t width;
uint32_t height;
unsigned char* img = nullptr;
bool readBgra;
~onPost() {
if (img) {
delete[] img;
img = nullptr;
}
}
};
std::map<uint32_t, onPost> m_onPost;
ReadbackWorker* m_readbackWorker = nullptr;
android::base::WorkerThread<Readback> m_readbackThread;
std::atomic_bool m_readbackThreadStarted = false;
std::string m_graphicsAdapterVendor;
std::string m_graphicsAdapterName;
std::string m_graphicsApiVersion;
std::string m_graphicsApiExtensions;
std::string m_graphicsDeviceExtensions;
// The host associates color buffers with guest processes for memory
// cleanup. Guest processes are identified with a host generated unique ID.
// TODO(kaiyili): move all those resources to the ProcessResources struct.
ProcOwnedColorBuffers m_procOwnedColorBuffers;
ProcOwnedEmulatedEGLImages m_procOwnedEmulatedEglImages;
ProcOwnedEmulatedEglContexts m_procOwnedEmulatedEglContexts;
ProcOwnedEmulatedEglWindowSurfaces m_procOwnedEmulatedEglWindowSurfaces;
ProcOwnedCleanupCallbacks m_procOwnedCleanupCallbacks;
std::unordered_map<uint64_t, std::unique_ptr<ProcessResources>> m_procOwnedResources;
// Flag set when emulator is shutting down.
bool m_shuttingDown = false;
// When this feature is enabled, open/close operations from gralloc in guest
// will no longer control the reference counting of color buffers on host.
// Instead, it will be managed by a file descriptor in the guest kernel. In
// case all the native handles in guest are destroyed, the pipe will be
// automatically closed by the kernel. We only need to do reference counting
// for color buffers attached in window surface.
bool m_refCountPipeEnabled = false;
// When this feature is enabled, and m_refCountPipeEnabled == false, color
// buffer close operations will immediately close the color buffer if host
// refcount hits 0. This is for use with guest kernels where the color
// buffer is already tied to a file descriptor in the guest kernel.
bool m_noDelayCloseColorBufferEnabled = false;
std::unique_ptr<PostWorker> m_postWorker = {};
std::atomic_bool m_postThreadStarted = false;
android::base::WorkerThread<Post> m_postThread;
android::base::WorkerProcessingResult postWorkerFunc(Post& post);
std::future<void> sendPostWorkerCmd(Post post);
bool m_vulkanInteropSupported = false;
bool m_vulkanEnabled = false;
bool m_guestUsesAngle = false;
// Whether the guest manages ColorBuffer lifetime
// so we don't need refcounting on the host side.
bool m_guestManagedColorBufferLifetime = false;
android::base::MessageChannel<HandleType, 1024>
mOutstandingColorBufferDestroys;
std::unique_ptr<gl::EmulationGl> m_emulationGl;
gl::DisplayGl* m_displayGl = nullptr;
Compositor* m_compositor = nullptr;
bool m_useVulkanComposition = false;
vk::VkEmulation* m_emulationVk = nullptr;
// The implementation for Vulkan native swapchain. Only initialized when useVulkan is set when
// calling FrameBuffer::initialize(). DisplayVk is actually owned by VkEmulation.
vk::DisplayVk* m_displayVk = nullptr;
VkInstance m_vkInstance = VK_NULL_HANDLE;
std::unique_ptr<emugl::RenderDoc> m_renderDoc = nullptr;
// TODO(b/233939967): Refactor to create DisplayGl and DisplaySurfaceGl
// and remove usage of non-generic DisplayVk.
Display* m_display;
std::unique_ptr<DisplaySurface> m_displaySurface;
// CompositorGl.
// TODO: update RenderDoc to be a DisplaySurfaceUser.
std::vector<DisplaySurfaceUser*> m_displaySurfaceUsers;
// UUIDs of physical devices for Vulkan and GLES, respectively. In most
// cases, this determines whether we can support zero-copy interop.
using VkUuid = std::array<uint8_t, VK_UUID_SIZE>;
VkUuid m_vulkanUUID{};
static_assert(VK_UUID_SIZE == GL_UUID_SIZE_EXT);
// Tracks platform EGL contexts that have been handed out to other users,
// indexed by underlying native EGL context object.
struct PlatformEglContextInfo {
EGLContext context;
EGLSurface surface;
};
std::unordered_map<void*, PlatformEglContextInfo> m_platformEglContexts;
std::unique_ptr<MetricsLogger> m_logger;
std::unique_ptr<HealthMonitor<>> m_healthMonitor;
int m_vsyncHz = 60;
// Vsync thread.
std::unique_ptr<VsyncThread> m_vsyncThread = {};
struct DisplayConfig{
int w;
int h;
int dpiX;
int dpiY;
DisplayConfig() {}
DisplayConfig(int w, int h, int x, int y)
: w(w), h(h), dpiX(x), dpiY(y) {}
};
std::map<int, DisplayConfig> mDisplayConfigs;
int mDisplayActiveConfigId = -1;
};
} // namespace gfxstream
#endif
Reference in New Issue View Git Blame Copy Permalink