X-Git-Url: https://gerrit.akraino.org/r/gitweb?a=blobdiff_plain;f=src%2Ftype3_AndroidCloud%2Fanbox-master%2Fsrc%2Fanbox%2Fgraphics%2Femugl%2FColorBuffer.h;fp=src%2Ftype3_AndroidCloud%2Fanbox-master%2Fsrc%2Fanbox%2Fgraphics%2Femugl%2FColorBuffer.h;h=19bf44c4880e489972d6605affc4e83fdeaaaedb;hb=e26c1ec581be598521517829adba8c8dd23a768f;hp=0000000000000000000000000000000000000000;hpb=6699c1aea74eeb0eb400e6299079f0c7576f716f;p=iec.git

diff --git a/src/type3_AndroidCloud/anbox-master/src/anbox/graphics/emugl/ColorBuffer.h b/src/type3_AndroidCloud/anbox-master/src/anbox/graphics/emugl/ColorBuffer.h
new file mode 100644
index 0000000..19bf44c
--- /dev/null
+++ b/src/type3_AndroidCloud/anbox-master/src/anbox/graphics/emugl/ColorBuffer.h
@@ -0,0 +1,139 @@
+/*
+* Copyright (C) 2011 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_COLORBUFFER_H
+#define _LIBRENDER_COLORBUFFER_H
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES/gl.h>
+
+#include <memory>
+
+class TextureDraw;
+class TextureResize;
+
+// A class used to model a guest color buffer, and used to implement several
+// related things:
+//
+//  - Every gralloc native buffer with HW read or write requirements will
+//    allocate a host ColorBuffer instance. When gralloc_lock() is called,
+//    the guest will use ColorBuffer::readPixels() to read the current content
+//    of the buffer. When gralloc_unlock() is later called, it will call
+//    ColorBuffer::subUpdate() to send the updated pixels.
+//
+//  - Every guest window EGLSurface is implemented by a host PBuffer
+//    (see WindowSurface.h) that can have a ColorBuffer instance attached to
+//    it (through WindowSurface::attachColorBuffer()). When such an attachment
+//    exists, WindowSurface::flushColorBuffer() will copy the PBuffer's
+//    pixel data into the ColorBuffer. The latter can then be displayed
+//    in the client's UI sub-window with ColorBuffer::post().
+//
+//  - Guest EGLImages are implemented as native gralloc buffers too.
+//    The guest glEGLImageTargetTexture2DOES() implementations will end up
+//    calling ColorBuffer::bindToTexture() to bind the current context's
+//    GL_TEXTURE_2D to the buffer. Similarly, the guest versions of
+//    glEGLImageTargetRenderbufferStorageOES() will end up calling
+//    ColorBuffer::bindToRenderbuffer().
+//
+// This forces the implementation to use a host EGLImage to implement each
+// ColorBuffer.
+//
+// As an additional twist.
+
+class ColorBuffer {
+ public:
+  // Helper interface class used during ColorBuffer operations. This is
+  // introduced to remove coupling from the FrameBuffer class implementation.
+  class Helper {
+   public:
+    Helper() {}
+    virtual ~Helper() {}
+    virtual bool setupContext() = 0;
+    virtual void teardownContext() = 0;
+    virtual TextureDraw* getTextureDraw() const = 0;
+  };
+
+  // Create a new ColorBuffer instance.
+  // |p_display| is the host EGLDisplay handle.
+  // |p_width| and |p_height| are the buffer's dimensions in pixels.
+  // |p_internalFormat| is the internal pixel format to use, valid values
+  // are: GL_RGB, GL_RGB565, GL_RGBA, GL_RGB5_A1_OES and GL_RGBA4_OES.
+  // Implementation is free to use something else though.
+  // |has_eglimage_texture_2d| should be true iff the display supports
+  // the EGL_KHR_gl_texture_2D_image extension.
+  // Returns NULL on failure.
+  static ColorBuffer* create(EGLDisplay p_display, int p_width, int p_height,
+                             GLenum p_internalFormat,
+                             bool has_eglimage_texture_2d, Helper* helper);
+
+  // Destructor.
+  ~ColorBuffer();
+
+  // Return ColorBuffer width and height in pixels
+  GLuint getWidth() const { return m_width; }
+  GLuint getHeight() const { return m_height; }
+
+  // Read the ColorBuffer instance's pixel values into host memory.
+  void readPixels(int x, int y, int width, int height, GLenum p_format,
+                  GLenum p_type, void* pixels);
+
+  // Update the ColorBuffer instance's pixel values from host memory.
+  void subUpdate(int x, int y, int width, int height, GLenum p_format,
+                 GLenum p_type, void* pixels);
+
+  // Bind the current context's EGL_TEXTURE_2D texture to this ColorBuffer's
+  // EGLImage. This is intended to implement glEGLImageTargetTexture2DOES()
+  // for all GLES versions.
+  bool bindToTexture();
+
+  // 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.
+  bool bindToRenderbuffer();
+
+  // Copy the content of the current context's read surface to this
+  // ColorBuffer. This is used from WindowSurface::flushColorBuffer().
+  // Return true on success, false on failure (e.g. no current context).
+  bool blitFromCurrentReadBuffer();
+
+  // Read the content of the whole ColorBuffer as 32-bit RGBA pixels.
+  // |img| must be a buffer large enough (i.e. width * height * 4).
+  void readback(unsigned char* img);
+
+  void bind();
+
+ private:
+  ColorBuffer();  // no default constructor.
+
+  explicit ColorBuffer(EGLDisplay display, Helper* helper);
+
+ private:
+  GLuint m_tex;
+  GLuint m_blitTex;
+  EGLImageKHR m_eglImage;
+  EGLImageKHR m_blitEGLImage;
+  GLuint m_width;
+  GLuint m_height;
+  GLuint m_fbo;
+  GLenum m_internalFormat;
+  EGLDisplay m_display;
+  Helper* m_helper;
+  TextureResize* m_resizer;
+};
+
+typedef std::shared_ptr<ColorBuffer> ColorBufferPtr;
+
+#endif