| /* |
| * 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. |
| */ |
| |
| #include "base/logging.h" |
| |
| #include "core/gl_env.h" |
| #include "core/gl_frame.h" |
| #include "core/shader_program.h" |
| |
| #include <vector> |
| |
| namespace android { |
| namespace filterfw { |
| |
| static const int kIdentityShaderKey = 1; |
| |
| // |
| // A GLFrame stores pixel data on the GPU. It uses two kinds of GL data |
| // containers for this: Textures and Frame Buffer Objects (FBOs). Textures are |
| // used whenever pixel data needs to be read into a shader or the host program, |
| // and when pixel data is uploaded to a GLFrame. The FBO is used as a rendering |
| // target for shaders. |
| // |
| |
| GLFrame::GLFrame(GLEnv* gl_env) |
| : gl_env_(gl_env), |
| width_(0), |
| height_(0), |
| vp_x_(0), |
| vp_y_(0), |
| vp_width_(0), |
| vp_height_(0), |
| texture_id_(0), |
| fbo_id_(0), |
| texture_target_(GL_TEXTURE_2D), |
| texture_state_(kStateUninitialized), |
| fbo_state_(kStateUninitialized), |
| owns_texture_(false), |
| owns_fbo_(false) { |
| SetDefaultTexParameters(); |
| } |
| |
| bool GLFrame::Init(int width, int height) { |
| // Make sure we haven't been initialized already |
| if (width_ == 0 && height_ == 0) { |
| InitDimensions(width, height); |
| return true; |
| } |
| return false; |
| } |
| |
| bool GLFrame::InitWithTexture(GLint texture_id, int width, int height) { |
| texture_id_ = texture_id; |
| texture_state_ = glIsTexture(texture_id) ? kStateComplete : kStateGenerated; |
| InitDimensions(width, height); |
| return true; |
| } |
| |
| bool GLFrame::InitWithFbo(GLint fbo_id, int width, int height) { |
| fbo_id_ = fbo_id; |
| fbo_state_ = glIsFramebuffer(fbo_id) ? kStateComplete : kStateGenerated; |
| texture_state_ = kStateUnmanaged; |
| InitDimensions(width, height); |
| return true; |
| } |
| |
| bool GLFrame::InitWithExternalTexture() { |
| texture_target_ = GL_TEXTURE_EXTERNAL_OES; |
| width_ = 0; |
| height_ = 0; |
| return GenerateTextureName(); |
| } |
| |
| void GLFrame::InitDimensions(int width, int height) { |
| width_ = width; |
| height_ = height; |
| vp_width_ = width; |
| vp_height_ = height; |
| } |
| |
| GLFrame::~GLFrame() { |
| // Delete texture |
| if (owns_texture_) { |
| // Bind FBO so that texture is unbound from it during deletion |
| if (fbo_state_ == kStateComplete) { |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo_id_); |
| } |
| glDeleteTextures(1, &texture_id_); |
| } |
| |
| // Delete FBO |
| if (owns_fbo_) { |
| glDeleteFramebuffers(1, &fbo_id_); |
| } |
| } |
| |
| bool GLFrame::GenerateMipMap() { |
| if (FocusTexture()) { |
| glGenerateMipmap(GL_TEXTURE_2D); |
| return !GLEnv::CheckGLError("Generating MipMap!"); |
| } |
| return false; |
| } |
| |
| bool GLFrame::SetTextureParameter(GLenum pname, GLint value) { |
| if (value != tex_params_[pname]) { |
| if (FocusTexture()) { |
| glTexParameteri(GL_TEXTURE_2D, pname, value); |
| if (!GLEnv::CheckGLError("Setting texture parameter!")) { |
| tex_params_[pname] = value; |
| return true; |
| } |
| } |
| } else { |
| return true; |
| } |
| return false; |
| } |
| |
| bool GLFrame::UpdateTexParameters() { |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, tex_params_[GL_TEXTURE_MAG_FILTER]); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, tex_params_[GL_TEXTURE_MIN_FILTER]); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, tex_params_[GL_TEXTURE_WRAP_S]); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, tex_params_[GL_TEXTURE_WRAP_T]); |
| return !GLEnv::CheckGLError("Resetting texture parameters!"); |
| } |
| |
| bool GLFrame::TexParametersModifed() { |
| return tex_params_[GL_TEXTURE_MAG_FILTER] != GL_LINEAR |
| || tex_params_[GL_TEXTURE_MIN_FILTER] != GL_LINEAR |
| || tex_params_[GL_TEXTURE_WRAP_S] != GL_CLAMP_TO_EDGE |
| || tex_params_[GL_TEXTURE_WRAP_T] != GL_CLAMP_TO_EDGE; |
| } |
| |
| void GLFrame::SetDefaultTexParameters() { |
| tex_params_[GL_TEXTURE_MAG_FILTER] = GL_LINEAR; |
| tex_params_[GL_TEXTURE_MIN_FILTER] = GL_LINEAR; |
| tex_params_[GL_TEXTURE_WRAP_S] = GL_CLAMP_TO_EDGE; |
| tex_params_[GL_TEXTURE_WRAP_T] = GL_CLAMP_TO_EDGE; |
| } |
| |
| bool GLFrame::ResetTexParameters() { |
| if (TexParametersModifed()) { |
| if (BindTexture()) { |
| SetDefaultTexParameters(); |
| return UpdateTexParameters(); |
| } |
| return false; |
| } |
| return true; |
| } |
| |
| bool GLFrame::CopyDataTo(uint8_t* buffer, int size) { |
| return (size >= Size()) |
| ? CopyPixelsTo(buffer) |
| : false; |
| } |
| |
| bool GLFrame::CopyPixelsTo(uint8_t* buffer) { |
| // Use one of the pixel reading methods below, ordered from most |
| // efficient to least efficient. |
| if (fbo_state_ == kStateComplete) |
| return ReadFboPixels(buffer); |
| else if (texture_state_ == kStateComplete) |
| return ReadTexturePixels(buffer); |
| else |
| return false; |
| } |
| |
| bool GLFrame::WriteData(const uint8_t* data, int data_size) { |
| return (data_size == Size()) ? UploadTexturePixels(data) : false; |
| } |
| |
| bool GLFrame::SetViewport(int x, int y, int width, int height) { |
| vp_x_ = x; |
| vp_y_ = y; |
| vp_width_ = width; |
| vp_height_ = height; |
| return true; |
| } |
| |
| GLFrame* GLFrame::Clone() const { |
| GLFrame* target = new GLFrame(gl_env_); |
| target->Init(width_, height_); |
| target->CopyPixelsFrom(this); |
| return target; |
| } |
| |
| bool GLFrame::CopyPixelsFrom(const GLFrame* frame) { |
| if (frame == this) { |
| return true; |
| } else if (frame && frame->width_ == width_ && frame->height_ == height_) { |
| std::vector<const GLFrame*> sources; |
| sources.push_back(frame); |
| GetIdentity()->Process(sources, this); |
| return true; |
| } |
| return false; |
| } |
| |
| int GLFrame::Size() const { |
| return width_ * height_ * 4; |
| } |
| |
| ShaderProgram* GLFrame::GetIdentity() const { |
| ShaderProgram* stored_shader = gl_env_->ShaderWithKey(kIdentityShaderKey); |
| if (!stored_shader) { |
| stored_shader = ShaderProgram::CreateIdentity(gl_env_); |
| gl_env_->AttachShader(kIdentityShaderKey, stored_shader); |
| } |
| return stored_shader; |
| } |
| |
| bool GLFrame::BindFrameBuffer() const { |
| // Bind the FBO |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo_id_); |
| if (GLEnv::CheckGLError("FBO Binding")) return false; |
| |
| // Set viewport |
| glViewport(vp_x_, vp_y_, vp_width_, vp_height_); |
| if (GLEnv::CheckGLError("ViewPort Setup")) return false; |
| |
| return true; |
| } |
| |
| bool GLFrame::FocusFrameBuffer() { |
| // Create texture backing if necessary |
| if (texture_state_ == kStateUninitialized) { |
| if (!GenerateTextureName()) |
| return false; |
| } |
| |
| // Create and bind FBO to texture if necessary |
| if (fbo_state_ != kStateComplete) { |
| if (!GenerateFboName() || !AttachTextureToFbo()) |
| return false; |
| } |
| |
| // And bind it. |
| return BindFrameBuffer(); |
| } |
| |
| bool GLFrame::BindTexture() const { |
| glBindTexture(GL_TEXTURE_2D, texture_id_); |
| return !GLEnv::CheckGLError("Texture Binding"); |
| } |
| |
| GLuint GLFrame::GetTextureId() const { |
| return texture_id_; |
| } |
| |
| // Returns the held FBO id. Only call this if the GLFrame holds an FBO. You |
| // can check this by calling HoldsFbo(). |
| GLuint GLFrame::GetFboId() const { |
| return fbo_id_; |
| } |
| |
| bool GLFrame::FocusTexture() { |
| // Make sure we have a texture |
| if (!GenerateTextureName()) |
| return false; |
| |
| // Bind the texture |
| if (!BindTexture()) |
| return false; |
| |
| return !GLEnv::CheckGLError("Texture Binding"); |
| } |
| |
| bool GLFrame::GenerateTextureName() { |
| if (texture_state_ == kStateUninitialized) { |
| // Make sure texture not in use already |
| if (glIsTexture(texture_id_)) { |
| ALOGE("GLFrame: Cannot generate texture id %d, as it is in use already!", texture_id_); |
| return false; |
| } |
| |
| // Generate the texture |
| glGenTextures (1, &texture_id_); |
| if (GLEnv::CheckGLError("Texture Generation")) |
| return false; |
| texture_state_ = kStateGenerated; |
| owns_texture_ = true; |
| } |
| |
| return true; |
| } |
| |
| bool GLFrame::AllocateTexture() { |
| // Allocate or re-allocate (if texture was deleted externally). |
| if (texture_state_ == kStateGenerated || TextureWasDeleted()) { |
| LOG_FRAME("GLFrame: Allocating texture: %d", texture_id_); |
| glBindTexture(GL_TEXTURE_2D, texture_id_); |
| glTexImage2D(GL_TEXTURE_2D, |
| 0, |
| GL_RGBA, |
| width_, |
| height_, |
| 0, |
| GL_RGBA, |
| GL_UNSIGNED_BYTE, |
| NULL); |
| if (!GLEnv::CheckGLError("Texture Allocation")) { |
| UpdateTexParameters(); |
| texture_state_ = kStateComplete; |
| } |
| } |
| return texture_state_ == kStateComplete; |
| } |
| |
| bool GLFrame::TextureWasDeleted() const { |
| return texture_state_ == kStateComplete && !glIsTexture(texture_id_); |
| } |
| |
| bool GLFrame::GenerateFboName() { |
| if (fbo_state_ == kStateUninitialized) { |
| // Make sure FBO not in use already |
| if (glIsFramebuffer(fbo_id_)) { |
| ALOGE("GLFrame: Cannot generate FBO id %d, as it is in use already!", fbo_id_); |
| return false; |
| } |
| |
| // Create FBO |
| glGenFramebuffers(1, &fbo_id_); |
| if (GLEnv::CheckGLError("FBO Generation")) |
| return false; |
| fbo_state_ = kStateGenerated; |
| owns_fbo_ = true; |
| } |
| |
| return true; |
| } |
| |
| bool GLFrame::ReadFboPixels(uint8_t* pixels) const { |
| if (fbo_state_ == kStateComplete) { |
| BindFrameBuffer(); |
| glReadPixels(0, |
| 0, |
| width_, |
| height_, |
| GL_RGBA, |
| GL_UNSIGNED_BYTE, |
| pixels); |
| return !GLEnv::CheckGLError("FBO Pixel Readout"); |
| } |
| return false; |
| } |
| |
| bool GLFrame::ReadTexturePixels(uint8_t* pixels) const { |
| // Read pixels from texture if we do not have an FBO |
| // NOTE: OpenGL ES does NOT support glGetTexImage() for reading out texture |
| // data. The only way for us to get texture data is to create a new FBO and |
| // render the current texture frame into it. As this is quite inefficient, |
| // and unnecessary (this can only happen if the user is reading out data |
| // that was just set, and not run through a filter), we warn the user about |
| // this here. |
| ALOGW("Warning: Reading pixel data from unfiltered GL frame. This is highly " |
| "inefficient. Please consider using your original pixel buffer " |
| "instead!"); |
| |
| // Create source frame set (unfortunately this requires an ugly const-cast, |
| // as we need to wrap ourselves in a frame-set. Still, as this set is used |
| // as input only, we are certain we will not be modified). |
| std::vector<const GLFrame*> sources; |
| sources.push_back(this); |
| |
| // Create target frame |
| GLFrame target(gl_env_); |
| target.Init(width_, height_); |
| |
| // Render the texture to the target |
| GetIdentity()->Process(sources, &target); |
| |
| // Get the pixel data |
| return target.ReadFboPixels(pixels); |
| } |
| |
| bool GLFrame::AttachTextureToFbo() { |
| // Check FBO and texture state. We do not do anything if we are not managing the texture. |
| if (fbo_state_ == kStateComplete || texture_state_ == kStateUnmanaged) { |
| return true; |
| } else if (fbo_state_ != kStateGenerated) { |
| ALOGE("Attempting to attach texture to FBO with no FBO in place!"); |
| return false; |
| } |
| |
| // If texture has been generated, make sure it is allocated. |
| if (!AllocateTexture()) |
| return false; |
| |
| // Bind the frame buffer, and check if we it is already bound |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo_id_); |
| |
| // Bind the texture to the frame buffer |
| LOG_FRAME("Attaching tex %d w %d h %d to fbo %d", texture_id_, width_, height_, fbo_id_); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, |
| GL_COLOR_ATTACHMENT0, |
| GL_TEXTURE_2D, |
| texture_id_, |
| 0); |
| |
| // Cleanup |
| glBindTexture(GL_TEXTURE_2D, 0); |
| glBindFramebuffer(GL_FRAMEBUFFER, 0); |
| |
| if (GLEnv::CheckGLError("Texture Binding to FBO")) |
| return false; |
| else |
| fbo_state_ = kStateComplete; |
| |
| return true; |
| } |
| |
| bool GLFrame::ReattachTextureToFbo() { |
| return (fbo_state_ == kStateGenerated) ? AttachTextureToFbo() : true; |
| } |
| |
| bool GLFrame::DetachTextureFromFbo() { |
| if (fbo_state_ == kStateComplete && texture_state_ == kStateComplete) { |
| LOG_FRAME("Detaching tex %d w %d h %d from fbo %d", texture_id_, width_, height_, fbo_id_); |
| glBindFramebuffer(GL_FRAMEBUFFER, fbo_id_); |
| glFramebufferTexture2D(GL_FRAMEBUFFER, |
| GL_COLOR_ATTACHMENT0, |
| GL_TEXTURE_2D, |
| 0, |
| 0); |
| if (GLEnv::CheckGLError("Detaching texture to FBO")) |
| return false; |
| else |
| fbo_state_ = kStateGenerated; |
| } |
| return true; |
| } |
| |
| bool GLFrame::UploadTexturePixels(const uint8_t* pixels) { |
| // Bind the texture object |
| FocusTexture(); |
| |
| // Load mipmap level 0 |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width_, height_, |
| 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels); |
| |
| // Set the user specified texture parameters |
| UpdateTexParameters(); |
| |
| if (GLEnv::CheckGLError("Texture Pixel Upload")) |
| return false; |
| |
| texture_state_ = kStateComplete; |
| return true; |
| } |
| |
| } // namespace filterfw |
| } // namespace android |