--- /dev/null
+/*
+* 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 "anbox/graphics/emugl/ColorBuffer.h"
+#include "anbox/graphics/emugl/RenderContext.h"
+#include "anbox/graphics/emugl/RendererConfig.h"
+#include "anbox/graphics/emugl/TextureDraw.h"
+#include "anbox/graphics/emugl/WindowSurface.h"
+#include "anbox/graphics/emugl/Renderable.h"
+
+#include "anbox/graphics/primitives.h"
+#include "anbox/graphics/program_family.h"
+#include "anbox/graphics/renderer.h"
+
+#include <EGL/egl.h>
+
+#include <map>
+#include <mutex>
+
+#include <stdint.h>
+
+// Type of handles, a.k.a. "object names" in the GL specification.
+// These are integers used to uniquely identify a resource of a given type.
+typedef uint32_t HandleType;
+
+struct ColorBufferRef {
+ ColorBufferPtr cb;
+ uint32_t refcount; // number of client-side references
+};
+typedef std::map<HandleType, RenderContextPtr> RenderContextMap;
+typedef std::map<HandleType, std::pair<WindowSurfacePtr, HandleType>>
+ WindowSurfaceMap;
+typedef std::map<HandleType, ColorBufferRef> ColorBufferMap;
+
+// A structure used to list the capabilities of the underlying EGL
+// implementation that the FrameBuffer instance depends on.
+// |has_eglimage_texture_2d| is true iff the EGL_KHR_gl_texture_2D_image
+// extension is supported.
+// |has_eglimage_renderbuffer| is true iff the EGL_KHR_gl_renderbuffer_image
+// extension is supported.
+// |eglMajor| and |eglMinor| are the major and minor version numbers of
+// the underlying EGL implementation.
+struct RendererCaps {
+ bool has_eglimage_texture_2d;
+ bool has_eglimage_renderbuffer;
+ EGLint eglMajor;
+ EGLint eglMinor;
+};
+
+struct RendererWindow;
+
+// 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 Renderer : public anbox::graphics::Renderer {
+ public:
+ Renderer();
+ virtual ~Renderer();
+
+ // 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.
+ bool initialize(EGLNativeDisplayType nativeDisplay);
+
+ // Finalize the instance.
+ void finalize();
+
+ // Return the capabilities of the underlying display.
+ const RendererCaps& getCaps() const { return m_caps; }
+
+ // Return the list of configs available from this display.
+ const RendererConfigList* getConfigs() const { return m_configs; }
+
+ // 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_glVendor;
+ *renderer = m_glRenderer;
+ *version = m_glVersion;
+ }
+
+ RendererWindow* createNativeWindow(EGLNativeWindowType native_window);
+ void destroyNativeWindow(RendererWindow* window);
+ void destroyNativeWindow(EGLNativeWindowType native_window);
+
+ // Create a new RenderContext 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.
+ // |p_isGL2| is true to create a GLES 2.x context, or false for a GLES 1.x
+ // one.
+ // Return a new handle value, which will be 0 in case of error.
+ HandleType createRenderContext(int p_config, HandleType p_share,
+ bool p_isGL2 = false);
+
+ // Create a new WindowSurface 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 createWindowSurface(int p_config, int p_width, int p_height);
+
+ // Create a new ColorBuffer instance from this display instance.
+ // |p_width| and |p_height| are its dimensions in pixels.
+ // |p_internalFormat| is the pixel format. 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);
+
+ // 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 drainRenderContext();
+
+ // Call this function when a render thread terminates to destroy all
+ // remaining window surfqce it created. Necessary to avoid leaking
+ // host buffers when a guest application crashes, for example.
+ void drainWindowSurface();
+
+ // Destroy a given RenderContext instance. |p_context| is its handle
+ // value as returned by createRenderContext().
+ void DestroyRenderContext(HandleType p_context);
+
+ // Destroy a given WindowSurface instance. |p_surcace| is its handle
+ // value as returned by createWindowSurface().
+ void DestroyWindowSurface(HandleType p_surface);
+
+ // 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);
+
+ // 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);
+
+ // Attach a ColorBuffer to a WindowSurface instance.
+ // See the documentation for WindowSurface::setColorBuffer().
+ // |p_surface| is the target WindowSurface's handle value.
+ // |p_colorbuffer| is the ColorBuffer handle value.
+ // Returns true on success, false otherwise.
+ bool setWindowSurfaceColorBuffer(HandleType p_surface,
+ HandleType p_colorbuffer);
+
+ // Copy the content of a WindowSurface's Pbuffer to its attached
+ // ColorBuffer. See the documentation for WindowSurface::flushColorBuffer()
+ // |p_surface| is the target WindowSurface's handle value.
+ // Returns true on success, false on failure.
+ bool flushWindowSurfaceColorBuffer(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);
+
+ // 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 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);
+
+ // 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 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 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 draw(EGLNativeWindowType native_window,
+ const anbox::graphics::Rect& window_frame,
+ const RenderableList& renderables) override;
+
+ // Return the host EGLDisplay used by this instance.
+ EGLDisplay getDisplay() const { return m_eglDisplay; }
+
+ // Return a TextureDraw instance that can be used with this surfaces
+ // and windows created by this instance.
+ TextureDraw* getTextureDraw() const { return m_textureDraw; }
+
+ HandleType createClientImage(HandleType context, EGLenum target,
+ GLuint buffer);
+ EGLBoolean destroyClientImage(HandleType image);
+
+ // Used internally.
+ bool bind_locked();
+ bool unbind_locked();
+
+ private:
+ HandleType genHandle();
+
+ bool bindWindow_locked(RendererWindow* window);
+
+ void setupViewport(RendererWindow* window, const anbox::graphics::Rect& rect);
+ struct Program;
+ void draw(RendererWindow* window, const Renderable& renderable,
+ const Program& prog);
+ void tessellate(std::vector<anbox::graphics::Primitive>& primitives,
+ const anbox::graphics::Rect& buf_size,
+ const Renderable& renderable);
+
+ private:
+ static Renderer* s_renderer;
+ static HandleType s_nextHandle;
+ std::mutex m_lock;
+ RendererConfigList* m_configs;
+ RendererCaps m_caps;
+ EGLDisplay m_eglDisplay;
+ RenderContextMap m_contexts;
+ WindowSurfaceMap m_windows;
+ ColorBufferMap m_colorbuffers;
+ ColorBuffer::Helper* m_colorBufferHelper;
+
+ EGLContext m_eglContext;
+ EGLSurface m_pbufSurface;
+ EGLContext m_pbufContext;
+
+ EGLContext m_prevContext;
+ EGLSurface m_prevReadSurf;
+ EGLSurface m_prevDrawSurf;
+ TextureDraw* m_textureDraw;
+ EGLConfig m_eglConfig;
+ HandleType m_lastPostedColorBuffer;
+
+ int m_statsNumFrames;
+ long long m_statsStartTime;
+ bool m_fpsStats;
+
+ const char* m_glVendor;
+ const char* m_glRenderer;
+ const char* m_glVersion;
+
+ std::map<EGLNativeWindowType, RendererWindow*> m_nativeWindows;
+
+ anbox::graphics::ProgramFamily m_family;
+ struct Program {
+ GLuint id = 0;
+ GLint tex_uniform = -1;
+ GLint position_attr = -1;
+ GLint texcoord_attr = -1;
+ GLint center_uniform = -1;
+ GLint display_transform_uniform = -1;
+ GLint transform_uniform = -1;
+ GLint screen_to_gl_coords_uniform = -1;
+ GLint alpha_uniform = -1;
+ mutable long long last_used_frameno = 0;
+
+ Program(GLuint program_id);
+ Program() {}
+ };
+ Program m_defaultProgram, m_alphaProgram;
+
+ std::vector<anbox::graphics::Primitive> m_primitives;
+
+ static const GLchar* const vshader;
+ static const GLchar* const defaultFShader;
+ static const GLchar* const alphaFShader;
+};
+#endif
Code Review / iec.git / blobdiff