| /* |
| * Copyright (C) 2023 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 <vector> |
| #include <math.h> |
| |
| #define GL_GLEXT_PROTOTYPES |
| #define EGL_EGLEXT_PROTOTYPES |
| #include <EGL/egl.h> |
| #include <EGL/eglext.h> |
| #include <GLES2/gl2.h> |
| #include <GLES2/gl2ext.h> |
| #undef EGL_EGLEXT_PROTOTYPES |
| #undef GL_GLEXT_PROTOTYPES |
| |
| #include "abc3d.h" |
| #include "debug.h" |
| |
| namespace android { |
| namespace hardware { |
| namespace camera { |
| namespace provider { |
| namespace implementation { |
| namespace abc3d { |
| namespace { |
| constexpr char kTag[] = "abc3d"; |
| |
| float dot3(const float a3[], const float b3[]) { |
| return a3[0] * b3[0] + a3[1] * b3[1] + a3[2] * b3[2]; |
| } |
| |
| /* |
| * https://registry.khronos.org/OpenGL-Refpages/gl2.1/xhtml/gluLookAt.xml |
| * https://registry.khronos.org/OpenGL-Refpages/gl2.1/xhtml/glTranslate.xml |
| * This function takes `m44` (where zzz (assumed zero) and ooo (assumed one) |
| * are ignored) and multiplies it by a translation matrix. |
| * |
| * m44 translate |
| * [ s0 s1 s2 zzz ] [ 1 0 0 -eyeX ] [ s0 s1 s2 -dot3(m44[0:2], eye3) ] |
| * [ up0 up1 up2 zzz ] * [ 0 1 0 -eyeY ] = [ up0 up1 up2 -dot3(m44[4:6], eye3) ] |
| * [ b0 b1 b2 zzz ] [ 0 0 1 -eyeZ ] [ b0 b1 b2 -dot3(m44[8:10], eye3) ] |
| * [ zzz zzz zzz ooo ] [ 0 0 0 1 ] [ 0 0 0 1 ] |
| */ |
| void lookAtEyeCoordinates(float m44[], const float eye3[]) { |
| m44[3] = -dot3(&m44[0], eye3); |
| m44[7] = -dot3(&m44[4], eye3); |
| m44[11] = -dot3(&m44[8], eye3); |
| m44[12] = 0; |
| m44[13] = 0; |
| m44[14] = 0; |
| m44[15] = 1; |
| } |
| } // namespace |
| |
| #define RETURN_CTOR_FAILED(S) \ |
| ALOGE("%s:%s:%d %s failed", kTag, __func__, __LINE__, S); return; |
| |
| AutoImageKHR::AutoImageKHR(const EGLDisplay display, const EGLClientBuffer clientBuf) |
| : mEglDisplay(display) { |
| static const EGLint imageAttrs[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE}; |
| mEglImage = eglCreateImageKHR( |
| display, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID, clientBuf, imageAttrs); |
| if (mEglImage == EGL_NO_IMAGE_KHR) { |
| RETURN_CTOR_FAILED("eglCreateImageKHR"); |
| } |
| } |
| |
| AutoImageKHR::AutoImageKHR(AutoImageKHR&& rhs) noexcept |
| : mEglDisplay(rhs.mEglDisplay) |
| , mEglImage(std::exchange(rhs.mEglImage, EGL_NO_IMAGE_KHR)) {} |
| |
| AutoImageKHR& AutoImageKHR::operator=(AutoImageKHR&& rhs) noexcept { |
| if (this != &rhs) { |
| mEglDisplay = rhs.mEglDisplay; |
| mEglImage = std::exchange(rhs.mEglImage, EGL_NO_IMAGE_KHR); |
| } |
| return *this; |
| } |
| |
| AutoImageKHR::~AutoImageKHR() { |
| if (mEglImage != EGL_NO_IMAGE_KHR) { |
| eglDestroyImageKHR(mEglDisplay, mEglImage); |
| } |
| } |
| |
| EglCurrentContext::EglCurrentContext(const EGLDisplay display) |
| : mEglDisplay(display) {} |
| |
| EglCurrentContext::EglCurrentContext(EglCurrentContext&& rhs) noexcept |
| : mEglDisplay(std::exchange(rhs.mEglDisplay, EGL_NO_DISPLAY)) {} |
| |
| EglCurrentContext& EglCurrentContext::operator=(EglCurrentContext&& rhs) noexcept { |
| if (this != &rhs) { |
| mEglDisplay = std::exchange(rhs.mEglDisplay, EGL_NO_DISPLAY); |
| } |
| return *this; |
| } |
| |
| EglCurrentContext::~EglCurrentContext() { |
| if (mEglDisplay != EGL_NO_DISPLAY) { |
| LOG_ALWAYS_FATAL_IF(!eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, |
| EGL_NO_SURFACE, EGL_NO_CONTEXT)); |
| } |
| } |
| |
| EglContext::EglContext(EglContext&& rhs) noexcept |
| : mEglDisplay(std::exchange(rhs.mEglDisplay, EGL_NO_DISPLAY)) |
| , mEglContext(std::exchange(rhs.mEglContext, EGL_NO_CONTEXT)) |
| , mEglSurface(std::exchange(rhs.mEglSurface, EGL_NO_SURFACE)) {} |
| |
| EglContext& EglContext::operator=(EglContext&& rhs) noexcept { |
| if (this != &rhs) { |
| mEglDisplay = std::exchange(rhs.mEglDisplay, EGL_NO_DISPLAY); |
| mEglContext = std::exchange(rhs.mEglContext, EGL_NO_CONTEXT); |
| mEglSurface = std::exchange(rhs.mEglSurface, EGL_NO_SURFACE); |
| } |
| return *this; |
| } |
| |
| EglContext::~EglContext() { |
| clear(); |
| } |
| |
| void EglContext::clear() { |
| if (mEglSurface != EGL_NO_SURFACE) { |
| eglDestroySurface(mEglDisplay, mEglSurface); |
| mEglSurface = EGL_NO_SURFACE; |
| } |
| if (mEglContext != EGL_NO_CONTEXT) { |
| eglDestroyContext(mEglDisplay, mEglContext); |
| mEglContext = EGL_NO_CONTEXT; |
| } |
| if (mEglDisplay != EGL_NO_DISPLAY) { |
| eglTerminate(mEglDisplay); |
| mEglDisplay = EGL_NO_DISPLAY; |
| } |
| } |
| |
| EglCurrentContext EglContext::init() { |
| if (mEglContext != EGL_NO_CONTEXT) { |
| LOG_ALWAYS_FATAL_IF(!eglMakeCurrent(mEglDisplay, mEglSurface, |
| mEglSurface, mEglContext)); |
| return EglCurrentContext(mEglDisplay); |
| } |
| |
| const EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY); |
| if (display == EGL_NO_DISPLAY) { |
| return EglCurrentContext(FAILURE(EGL_NO_DISPLAY)); |
| } |
| |
| EGLint major, minor; |
| if (!eglInitialize(display, &major, &minor)) { |
| return EglCurrentContext(FAILURE(EGL_NO_DISPLAY)); |
| } |
| ALOGD("%s:%d: Initialized EGL, version %d.%d", __func__, __LINE__, |
| static_cast<int>(major), static_cast<int>(minor)); |
| |
| static const EGLint configAttrs[] = { |
| EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, |
| EGL_CONFIG_CAVEAT, EGL_NONE, |
| EGL_RED_SIZE, 8, |
| EGL_GREEN_SIZE, 8, |
| EGL_BLUE_SIZE, 8, |
| EGL_ALPHA_SIZE, 8, |
| EGL_NONE |
| }; |
| |
| EGLint numConfigs = 1; |
| EGLConfig config = EGL_NO_CONFIG_KHR; |
| if (!eglChooseConfig(display, configAttrs, &config, 1, &numConfigs) || |
| (config == EGL_NO_CONFIG_KHR) || (numConfigs != 1)) { |
| eglTerminate(display); |
| return EglCurrentContext(FAILURE(EGL_NO_DISPLAY)); |
| } |
| |
| static const EGLint contextAttrs[] = { |
| EGL_CONTEXT_CLIENT_VERSION, 2, |
| EGL_NONE |
| }; |
| const EGLContext context = eglCreateContext(display, config, |
| EGL_NO_CONTEXT, contextAttrs); |
| if (context == EGL_NO_CONTEXT) { |
| eglTerminate(display); |
| return EglCurrentContext(FAILURE(EGL_NO_DISPLAY)); |
| } |
| |
| EGLSurface surface = EGL_NO_SURFACE; |
| if (!eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, context)) { |
| // EGL_KHR_surfaceless_context is not supported |
| const EGLint surfaceAttrs[] = { |
| EGL_WIDTH, 1, |
| EGL_HEIGHT, 1, |
| EGL_NONE |
| }; |
| surface = eglCreatePbufferSurface(display, config, surfaceAttrs); |
| if (surface == EGL_NO_SURFACE) { |
| eglDestroyContext(display, context); |
| eglTerminate(display); |
| return EglCurrentContext(FAILURE(EGL_NO_DISPLAY)); |
| } |
| |
| if (!eglMakeCurrent(display, surface, surface, context)) { |
| eglDestroySurface(display, surface); |
| eglDestroyContext(display, context); |
| eglTerminate(display); |
| return EglCurrentContext(FAILURE(EGL_NO_DISPLAY)); |
| } |
| } |
| |
| mEglDisplay = display; |
| mEglContext = context; |
| mEglSurface = surface; |
| |
| return EglCurrentContext(display); |
| } |
| |
| EglCurrentContext EglContext::getCurrentContext() { |
| if (mEglContext == EGL_NO_CONTEXT) { |
| return EglCurrentContext(EGL_NO_DISPLAY); |
| } else if (eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) { |
| return EglCurrentContext(mEglDisplay); |
| } else { |
| return EglCurrentContext(FAILURE(EGL_NO_DISPLAY)); |
| } |
| } |
| |
| AutoTexture::AutoTexture(const GLenum target) { |
| glGenTextures(1, &mTex); |
| if (mTex) { |
| glBindTexture(target, mTex); |
| } else { |
| RETURN_CTOR_FAILED("glGenTextures"); |
| } |
| } |
| |
| AutoTexture::AutoTexture(const GLenum target, |
| const GLint internalformat, |
| const GLsizei width, |
| const GLsizei height, |
| const GLenum format, |
| const GLenum type, |
| const void* data) { |
| glGenTextures(1, &mTex); |
| if (mTex) { |
| glBindTexture(target, mTex); |
| glTexImage2D(target, 0, internalformat, width, height, 0, format, type, data); |
| } else { |
| RETURN_CTOR_FAILED("glGenTextures"); |
| } |
| } |
| |
| AutoTexture::AutoTexture(AutoTexture&& rhs) noexcept |
| : mTex(std::exchange(rhs.mTex, 0)) {} |
| |
| AutoTexture& AutoTexture::operator=(AutoTexture&& rhs) noexcept { |
| if (this != &rhs) { |
| mTex = std::exchange(rhs.mTex, 0); |
| } |
| return *this; |
| } |
| |
| AutoTexture::~AutoTexture() { |
| clear(); |
| } |
| |
| void AutoTexture::clear() { |
| if (mTex) { |
| glDeleteTextures(1, &mTex); |
| mTex = 0; |
| } |
| } |
| |
| AutoFrameBuffer::AutoFrameBuffer() { |
| glGenFramebuffers(1, &mFBO); |
| if (mFBO) { |
| glBindFramebuffer(GL_FRAMEBUFFER, mFBO); |
| } else { |
| RETURN_CTOR_FAILED("glGenFramebuffers"); |
| } |
| } |
| |
| AutoFrameBuffer::~AutoFrameBuffer() { |
| if (mFBO) { |
| glDeleteFramebuffers(1, &mFBO); |
| } |
| } |
| |
| AutoShader::AutoShader(AutoShader&& rhs) noexcept |
| : mShader(std::exchange(rhs.mShader, 0)) {} |
| |
| AutoShader& AutoShader::operator=(AutoShader&& rhs) noexcept { |
| if (this != &rhs) { |
| mShader = std::exchange(rhs.mShader, 0); |
| } |
| return *this; |
| } |
| |
| AutoShader::~AutoShader() { |
| if (mShader) { |
| glDeleteShader(mShader); |
| } |
| } |
| |
| GLuint AutoShader::compile(const GLenum type, const char* text) { |
| const GLuint shader = glCreateShader(type); |
| if (!shader) { |
| return FAILURE(0); |
| } |
| |
| glShaderSource(shader, 1, &text, nullptr); |
| glCompileShader(shader); |
| GLint compiled = 0; |
| glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled); |
| if (!compiled) { |
| GLint infoLen = 0; |
| glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen); |
| if(infoLen > 1) { |
| std::vector<char> msg(infoLen + 1); |
| glGetShaderInfoLog(shader, infoLen, nullptr, msg.data()); |
| msg[infoLen] = 0; |
| ALOGE("%s:%d: error compiling shader '%s' (type=%d): '%s'", |
| __func__, __LINE__, text, type, msg.data()); |
| } |
| glDeleteShader(shader); |
| return FAILURE(0); |
| } |
| |
| if (mShader) { |
| glDeleteShader(mShader); |
| } |
| |
| mShader = shader; |
| return shader; |
| } |
| |
| AutoProgram::AutoProgram(AutoProgram&& rhs) noexcept |
| : mProgram(std::exchange(rhs.mProgram, 0)) {} |
| |
| AutoProgram& AutoProgram::operator=(AutoProgram&& rhs) noexcept { |
| if (this != &rhs) { |
| mProgram = std::exchange(rhs.mProgram, 0); |
| } |
| return *this; |
| } |
| |
| AutoProgram::~AutoProgram() { |
| clear(); |
| } |
| |
| void AutoProgram::clear() { |
| if (mProgram) { |
| glDeleteProgram(mProgram); |
| mProgram = 0; |
| } |
| } |
| |
| bool AutoProgram::link(const GLuint vertexShader, |
| const GLuint fragmentShader) { |
| const GLuint program = glCreateProgram(); |
| if (!program) { |
| return FAILURE(false); |
| } |
| |
| glAttachShader(program, vertexShader); |
| glAttachShader(program, fragmentShader); |
| glLinkProgram(program); |
| |
| GLint linked = 0; |
| glGetProgramiv(program, GL_LINK_STATUS, &linked); |
| if (!linked) { |
| GLint infoLen = 0; |
| glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLen); |
| if(infoLen > 1) { |
| std::vector<char> msg(infoLen + 1); |
| glGetProgramInfoLog(program, infoLen, nullptr, msg.data()); |
| msg[infoLen] = 0; |
| ALOGE("%s:%d: error linking shaders: '%s'", |
| __func__, __LINE__, msg.data()); |
| } |
| |
| glDeleteProgram(program); |
| return FAILURE(false); |
| } |
| |
| if (mProgram) { |
| glDeleteProgram(mProgram); |
| } |
| |
| mProgram = program; |
| return true; |
| } |
| |
| GLint AutoProgram::getAttribLocation(const char* name) const { |
| if (mProgram > 0) { |
| const GLint result = glGetAttribLocation(mProgram, name); |
| return (result >= 0) ? result : FAILURE(-1); |
| } else { |
| return FAILURE(-1); |
| } |
| } |
| |
| GLint AutoProgram::getUniformLocation(const char* name) const { |
| if (mProgram > 0) { |
| const GLint result = glGetUniformLocation(mProgram, name); |
| return (result >= 0) ? result : FAILURE(-1); |
| } else { |
| return FAILURE(-1); |
| } |
| } |
| |
| // https://registry.khronos.org/OpenGL-Refpages/gl2.1/xhtml/glFrustum.xml |
| void frustum(float m44[], |
| const double left, const double right, |
| const double bottom, const double top, |
| const double near, const double far) { |
| const double invWidth = 1.0 / (right - left); |
| const double invHeight = 1.0 / (top - bottom); |
| const double invDepth = 1.0 / (far - near); |
| const double near2 = 2 * near; |
| |
| m44[0] = near2 * invWidth; |
| m44[1] = 0; |
| m44[2] = (right + left) * invWidth; |
| m44[3] = 0; |
| |
| m44[4] = 0; |
| m44[5] = near2 * invHeight; |
| m44[6] = (top + bottom) * invHeight; |
| m44[7] = 0; |
| |
| m44[8] = 0; |
| m44[9] = 0; |
| m44[10] = -(far + near) * invDepth; |
| m44[11] = -far * near2 * invDepth; |
| |
| m44[12] = 0; |
| m44[13] = 0; |
| m44[14] = -1; |
| m44[15] = 0; |
| } |
| |
| /* |
| * https://registry.khronos.org/OpenGL-Refpages/gl2.1/xhtml/gluLookAt.xml |
| * https://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations |
| * |
| * Here we calculate {Side, Up, Backwards} from Euler angles in the XYZ order: |
| * |
| * [ 1, 0, 0 ] [ cosY, 0, sinY ] [ cosZ, -sinZ, 0 ] [ sx, ux, bx ] |
| * [ 0, cosX, -sinX ] * [ 0, 1, 0 ] * [ sinZ, cosZ, 0 ] = [ sy, uy, by ] |
| * [ 0, sinX, cosX ] [ -sinY, 0, cosY ] [ 0, 0, 1 ] [ sz, uz, bz ] |
| * |
| * We calculate `backwards` because the camera looks into the negative Z |
| * direction, so instead of calculating camera's forward and negating it twice, |
| * let's call it `backwards`. |
| * |
| * After multiplying the first two: |
| * [ cosY, 0, sinY ] |
| * [ sinX * sinY, cosX, -sinX * cosY ] |
| * [ -cosX * sinY, sinX, cosX * cosY ] |
| * |
| * The final result: |
| * [ cosY * cosZ, -cosY * sinZ, sinY ] |
| * [ sinX * sinY * cosZ + cosX * sinZ, -sinX * sinY * sinZ + cosX * cosZ, -sinX * cosY ] |
| * [ -cosX * sinY * cosZ + sinX * sinZ, cosX * sinY * sinZ + sinX * cosZ, cosX * cosY ] |
| * |
| * {Side, Up, Backwards} are the columns in the matrix above. |
| */ |
| void lookAtXyzRot(float m44[], const float eye3[], const float rot3[]) { |
| const double sinX = sin(rot3[0]); |
| const double cosX = cos(rot3[0]); |
| const double sinY = sin(rot3[1]); |
| const double cosY = cos(rot3[1]); |
| const double sinZ = sin(rot3[2]); |
| const double cosZ = cos(rot3[2]); |
| |
| m44[0] = cosY * cosZ; |
| m44[1] = sinX * sinY * cosZ + cosX * sinZ; |
| m44[2] = -cosX * sinY * cosZ + sinX * sinZ; |
| m44[4] = -cosY * sinZ; |
| m44[5] = -sinX * sinY * sinZ + cosX * cosZ; |
| m44[6] = cosX * sinY * sinZ + sinX * cosZ; |
| m44[8] = sinY; |
| m44[9] = -sinX * cosY; |
| m44[10] = cosX * cosY; |
| lookAtEyeCoordinates(m44, eye3); |
| } |
| |
| void mulM44(float m44[], const float lhs44[], const float rhs44[]) { |
| m44[0] = lhs44[0] * rhs44[0] + lhs44[1] * rhs44[4] + lhs44[2] * rhs44[8] + lhs44[3] * rhs44[12]; |
| m44[1] = lhs44[0] * rhs44[1] + lhs44[1] * rhs44[5] + lhs44[2] * rhs44[9] + lhs44[3] * rhs44[13]; |
| m44[2] = lhs44[0] * rhs44[2] + lhs44[1] * rhs44[6] + lhs44[2] * rhs44[10] + lhs44[3] * rhs44[14]; |
| m44[3] = lhs44[0] * rhs44[3] + lhs44[1] * rhs44[7] + lhs44[2] * rhs44[11] + lhs44[3] * rhs44[15]; |
| |
| m44[4] = lhs44[4] * rhs44[0] + lhs44[5] * rhs44[4] + lhs44[6] * rhs44[8] + lhs44[7] * rhs44[12]; |
| m44[5] = lhs44[4] * rhs44[1] + lhs44[5] * rhs44[5] + lhs44[6] * rhs44[9] + lhs44[7] * rhs44[13]; |
| m44[6] = lhs44[4] * rhs44[2] + lhs44[5] * rhs44[6] + lhs44[6] * rhs44[10] + lhs44[7] * rhs44[14]; |
| m44[7] = lhs44[4] * rhs44[3] + lhs44[5] * rhs44[7] + lhs44[6] * rhs44[11] + lhs44[7] * rhs44[15]; |
| |
| m44[8] = lhs44[8] * rhs44[0] + lhs44[9] * rhs44[4] + lhs44[10] * rhs44[8] + lhs44[11] * rhs44[12]; |
| m44[9] = lhs44[8] * rhs44[1] + lhs44[9] * rhs44[5] + lhs44[10] * rhs44[9] + lhs44[11] * rhs44[13]; |
| m44[10] = lhs44[8] * rhs44[2] + lhs44[9] * rhs44[6] + lhs44[10] * rhs44[10] + lhs44[11] * rhs44[14]; |
| m44[11] = lhs44[8] * rhs44[3] + lhs44[9] * rhs44[7] + lhs44[10] * rhs44[11] + lhs44[11] * rhs44[15]; |
| |
| m44[12] = lhs44[12] * rhs44[0] + lhs44[13] * rhs44[4] + lhs44[14] * rhs44[8] + lhs44[15] * rhs44[12]; |
| m44[13] = lhs44[12] * rhs44[1] + lhs44[13] * rhs44[5] + lhs44[14] * rhs44[9] + lhs44[15] * rhs44[13]; |
| m44[14] = lhs44[12] * rhs44[2] + lhs44[13] * rhs44[6] + lhs44[14] * rhs44[10] + lhs44[15] * rhs44[14]; |
| m44[15] = lhs44[12] * rhs44[3] + lhs44[13] * rhs44[7] + lhs44[14] * rhs44[11] + lhs44[15] * rhs44[15]; |
| } |
| |
| } // namespace abc3d |
| } // namespace implementation |
| } // namespace provider |
| } // namespace camera |
| } // namespace hardware |
| } // namespace android |
