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 <sys/types.h>
#include <unistd.h>
 
#include <libcamera/base/log.h>
#include <libcamera/base/span.h>
#include <libcamera/base/utils.h>
 
/*
 * Workaround for build issues on Mesa <= 22.2, see
 * https://github.com/KhronosGroup/EGL-Registry/pull/130
 */
#define EGL_NO_X11
 
#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(uint32_t width, uint32_t height, uint32_t stride, GLenum texture_unit, uint32_t texture_unit_uniform_id)
        : 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_);
    }
 
    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_; 
 
private:
    LIBCAMERA_DISABLE_COPY_AND_MOVE(eGLImage)
};
 
class eGL
{
public:
    eGL();
    ~eGL();
 
    int initEGLContext();
 
    int createInputDMABufTexture2D(eGLImage &eglImage, int fd);
    int createOutputDMABufTexture2D(eGLImage &eglImage, int fd);
    void createTexture2D(eGLImage &eglImage, GLint format, uint32_t width, uint32_t height, void *data);
 
    void pushEnv(std::vector<std::string> &shaderEnv, const char *str);
    void makeCurrent();
 
    int compileVertexShader(GLuint &shaderId, const unsigned char *shaderData,
                unsigned int shaderDataLen,
                Span<const std::string> shaderEnv);
    int compileFragmentShader(GLuint &shaderId, const unsigned char *shaderData,
                  unsigned int shaderDataLen,
                  Span<const std::string> shaderEnv);
    int linkProgram(GLuint &programId, GLuint fragmentshaderId, GLuint vertexshaderId);
    void dumpShaderSource(GLuint shaderId);
    void useProgram(GLuint programId);
    void deleteProgram(GLuint programId);
    void syncOutput();
 
private:
    LIBCAMERA_DISABLE_COPY_AND_MOVE(eGL)
 
    pid_t tid_;
 
    EGLDisplay display_ = EGL_NO_DISPLAY;
    EGLContext context_ = EGL_NO_CONTEXT;
    EGLSurface surface_ = EGL_NO_SURFACE;
 
    int compileShader(int shaderType, GLuint &shaderId, const unsigned char *shaderData,
              unsigned int shaderDataLen,
              Span<const std::string> shaderEnv);
 
    int createDMABufTexture2D(eGLImage &eglImage, int fd, bool output);
 
    PFNGLEGLIMAGETARGETTEXTURE2DOESPROC glEGLImageTargetTexture2DOES;
    PFNEGLCREATEIMAGEKHRPROC eglCreateImageKHR;
    PFNEGLDESTROYIMAGEKHRPROC eglDestroyImageKHR;
    PFNGLGETSTRINGPROC glGetString;
};
} //namespace libcamera