egl.h

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2024, Linaro Ltd.
 *
 * Authors:
 * Bryan O'Donoghue <bryan.odonoghue@linaro.org>
 *
 */
 
#pragma once
 
#include <span>
#include <sys/types.h>
#include <unistd.h>
 
#include <libcamera/base/log.h>
#include <libcamera/base/thread.h>
#include <libcamera/base/utils.h>
 
/*
 * Workaround for build issues on Mesa <= 22.2, see
 * https://github.com/KhronosGroup/EGL-Registry/pull/130
 */
#ifndef EGL_NO_X11
#define EGL_NO_X11
#endif
 
#define EGL_EGLEXT_PROTOTYPES
#include <EGL/egl.h>
#include <EGL/eglext.h>
#define GL_GLEXT_PROTOTYPES
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
 
namespace libcamera {
 
LOG_DECLARE_CATEGORY(eGL)
 
 
class eGLImage
{
public:
    eGLImage(GLint format, uint32_t width, uint32_t height, uint32_t stride, GLenum texture_unit, uint32_t texture_unit_uniform_id)
        : format_(format), width_(width), height_(height), stride_(stride),
          framesize_(stride * height),
          texture_unit_uniform_id_(texture_unit_uniform_id),
          texture_unit_(texture_unit)
    {
        glGenTextures(1, &texture_);
        glGenFramebuffers(1, &fbo_);
    }
 
    ~eGLImage()
    {
        glDeleteFramebuffers(1, &fbo_);
        glDeleteTextures(1, &texture_);
    }
 
    GLint format_; 
    uint32_t width_; 
    uint32_t height_; 
    uint32_t stride_; 
    uint32_t offset_; 
    uint32_t framesize_; 
    uint32_t texture_unit_uniform_id_; 
    GLenum texture_unit_; 
    GLuint texture_; 
    GLuint fbo_; 
    bool dmabuf_import_failed_ = false; 
private:
    LIBCAMERA_DISABLE_COPY_AND_MOVE(eGLImage)
};
 
class eGL
{
public:
    eGL(EGLDisplay display);
    ~eGL();
 
    int initEGLContext();
    void resetEGLContext();
    static EGLDisplay probeDisplay();
 
    int createInputDMABufTexture2D(eGLImage &eglImage, int fd);
    int createOutputDMABufTexture2D(eGLImage &eglImage, int fd);
    void createTexture2D(eGLImage &eglImage, const void *data, GLint filter);
    void updateTexture2D(eGLImage &eglImage, const void *data);
    void createOutputTexture2D(eGLImage &eglImage);
 
    int attachTextureToFBO(eGLImage &eglImage);
    void activateBindTexture(eGLImage &eglImage);
 
    void pushEnv(std::vector<std::string> &shaderEnv, const char *str);
 
    int compileVertexShader(GLuint &shaderId, std::span<const unsigned char> shaderData,
                std::span<const std::string> shaderEnv);
    int compileFragmentShader(GLuint &shaderId, std::span<const unsigned char> shaderData,
                  std::span<const std::string> shaderEnv);
    int linkProgram(GLuint &programId, GLuint fragmentshaderId, GLuint vertexshaderId);
    void dumpShaderSource(GLuint shaderId);
    void syncOutput();
    void flushOutput();
 
    void assertThread() const
    {
        ASSERT(tid_ == Thread::currentId());
    }
 
private:
    LIBCAMERA_DISABLE_COPY_AND_MOVE(eGL)
 
    pid_t tid_ = -1;
 
    EGLDisplay display_ = EGL_NO_DISPLAY;
    EGLContext context_ = EGL_NO_CONTEXT;
 
    int compileShader(int shaderType, GLuint &shaderId, std::span<const unsigned char> shaderData,
              std::span<const std::string> shaderEnv);
 
    int createDMABufTexture2D(eGLImage &eglImage, int fd, bool output);
 
    void makeCurrent();
 
    struct VTable {
        PFNGLEGLIMAGETARGETTEXTURE2DOESPROC glEGLImageTargetTexture2DOES;
        PFNEGLCREATEIMAGEKHRPROC eglCreateImageKHR;
        PFNEGLDESTROYIMAGEKHRPROC eglDestroyImageKHR;
    } vtable_ = {};
};
} //namespace libcamera