--- /dev/null
+/*
+* 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
Code Review / iec.git / blobdiff