[v2,24/37] libcamera: software_isp: egl: Introduce an eGL base helper class

24207 diff mbox series

Introduce an eGL base helper class which provides an eGL context based on a
passed width and height.

The initGLContext function could be overloaded to provide an interface to a
real display.

A set of helper functions is provided to compile and link GLSL shaders.
linkShaderProgram currently compiles vertex/fragment pairs but could be
overloaded or passed a parameter to link a compute shader instead.

Breaking the eGL interface away from debayering - allows to use the eGL
context inside of a dma-buf heap cleanly, reuse that context inside of a
debayer layer and conceivably reuse the context in a multi-stage shader
pass.

Small note the image_attrs[] array doesn't pass checkstyle.py however the
elements of the array are in pairs.

Signed-off-by: Bryan O'Donoghue <bryan.odonoghue@linaro.org>
---
 include/libcamera/internal/egl.h | 133 +++++++++++++
 src/libcamera/egl.cpp            | 408 +++++++++++++++++++++++++++++++++++++++
 src/libcamera/meson.build        |  23 +++
 3 files changed, 564 insertions(+)

Thanks a lot for the series / all your work!

I just tested it on a OnePlus6 / Freedreno - there's one issue, see below.

On 24.08.25 02:48, Bryan O'Donoghue wrote:
> Introduce an eGL base helper class which provides an eGL context based on a
> passed width and height.
>
> The initGLContext function could be overloaded to provide an interface to a
> real display.
>
> A set of helper functions is provided to compile and link GLSL shaders.
> linkShaderProgram currently compiles vertex/fragment pairs but could be
> overloaded or passed a parameter to link a compute shader instead.
>
> Breaking the eGL interface away from debayering - allows to use the eGL
> context inside of a dma-buf heap cleanly, reuse that context inside of a
> debayer layer and conceivably reuse the context in a multi-stage shader
> pass.
>
> Small note the image_attrs[] array doesn't pass checkstyle.py however the
> elements of the array are in pairs.
>
> Signed-off-by: Bryan O'Donoghue<bryan.odonoghue@linaro.org>
> ---
>   include/libcamera/internal/egl.h | 133 +++++++++++++
>   src/libcamera/egl.cpp            | 408 +++++++++++++++++++++++++++++++++++++++
>   src/libcamera/meson.build        |  23 +++
>   3 files changed, 564 insertions(+)
>
> diff --git a/include/libcamera/internal/egl.h b/include/libcamera/internal/egl.h
> new file mode 100644
> index 0000000000000000000000000000000000000000..2c48e28e14aaa1fa8029dd18662c8ce24e6a550c
> --- /dev/null
> +++ b/include/libcamera/internal/egl.h
> @@ -0,0 +1,133 @@
> +/* SPDX-License-Identifier: LGPL-2.1-or-later */
> +/*
> + * Copyright (C) 2024, Linaro Ltd.
> + *
> + * Authors:
> + * Bryan O'Donoghue<bryan.odonoghue@linaro.org>
> + *
> + * egl_context.cpp - Helper class for managing eGL interactions.
> + */
> +
> +#pragma once
> +
> +#include <unistd.h>
> +
> +#include <libcamera/base/log.h>
> +
> +#include "libcamera/internal/gbm.h"
> +
> +#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 bpp, uint32_t stride, GLenum texture_unit, uint32_t texture_unit_uniform_id)
> +	{
> +		init(width, height, bpp, stride, texture_unit, texture_unit_uniform_id);
> +	}
> +
> +	eGLImage(uint32_t width, uint32_t height, uint32_t bpp, GLenum texture_unit, uint32_t texture_unit_uniform_id)
> +	{
> +		uint32_t stride = ALIGN_TO(width * bpp, 256);
> +
> +		init(width, height, bpp, stride, texture_unit, texture_unit_uniform_id);
> +	}
> +
> +	~eGLImage()
> +	{
> +		glDeleteFramebuffers(1, &fbo_);
> +		glDeleteTextures(1, &texture_);
> +	}
> +
> +	uint32_t width_;
> +	uint32_t height_;
> +	uint32_t stride_;
> +	uint32_t offset_;
> +	uint32_t framesize_;
> +	uint32_t bpp_;
> +	uint32_t texture_unit_uniform_id_;
> +	GLenum texture_unit_;
> +	GLuint texture_;
> +	GLuint fbo_;
> +	EGLImageKHR image_;
> +
> +private:
> +	void init(uint32_t width, uint32_t height, uint32_t bpp, uint32_t stride, GLenum texture_unit, uint32_t texture_unit_uniform_id)
> +	{
> +		image_ = EGL_NO_IMAGE_KHR;
> +		width_ = width;
> +		height_ = height;
> +		bpp_ = bpp;
> +		stride_ = stride;
> +		framesize_ = stride_ * height_;
> +		texture_unit_ = texture_unit;
> +		texture_unit_uniform_id_ = texture_unit_uniform_id;
> +
> +		glGenTextures(1, &texture_);
> +		glGenFramebuffers(1, &fbo_);
> +	}
> +};
> +
> +class eGL
> +{
> +public:
> +	eGL();
> +	~eGL();
> +
> +	int initEGLContext(GBM *gbmContext);
> +	void cleanUp();
> +	int createInputDMABufTexture2D(eGLImage *eglImage, int fd);
> +	int createOutputDMABufTexture2D(eGLImage *eglImage, int fd);
> +	void destroyDMABufTexture(eGLImage *eglImage);
> +	void createTexture2D(eGLImage *eglImage, GLint format, uint32_t width, uint32_t height, void *data);
> +	void createTexture1D(eGLImage *eglImage, GLint format, uint32_t width, void *data);
> +
> +	void pushEnv(std::vector<std::string> &shaderEnv, const char *str);
> +	void makeCurrent();
> +	void swapBuffers();
> +
> +	int compileVertexShader(GLuint &shaderId, unsigned char *shaderData,
> +				unsigned int shaderDataLen,
> +				std::vector<std::string> shaderEnv);
> +	int compileFragmentShader(GLuint &shaderId, unsigned char *shaderData,
> +				  unsigned int shaderDataLen,
> +				  std::vector<std::string> shaderEnv);
> +	int linkProgram(GLuint &programIdd, GLuint fragmentshaderId, GLuint vertexshaderId);
> +	void dumpShaderSource(GLuint shaderId);
> +	void useProgram(GLuint programId);
> +	int syncOutput();
> +
> +private:
> +	int fd_;
> +
> +	EGLDisplay display_;
> +	EGLContext context_;
> +	EGLSurface surface_;
> +	EGLSyncKHR sync_;
> +
> +	int compileShader(int shaderType, GLuint &shaderId, unsigned char *shaderData,
> +			  unsigned int shaderDataLen,
> +			  std::vector<std::string> shaderEnv);
> +
> +	int createDMABufTexture2D(eGLImage *eglImage, int fd, bool output);
> +
> +	PFNEGLEXPORTDMABUFIMAGEMESAPROC eglExportDMABUFImageMESA;
> +	PFNGLEGLIMAGETARGETTEXTURE2DOESPROC glEGLImageTargetTexture2DOES;
> +
> +	PFNEGLCREATEIMAGEKHRPROC eglCreateImageKHR;
> +	PFNEGLDESTROYIMAGEKHRPROC eglDestroyImageKHR;
> +
> +	PFNEGLCREATESYNCKHRPROC eglCreateSyncKHR;
> +	PFNEGLDESTROYSYNCKHRPROC eglDestroySyncKHR;
> +	PFNEGLCLIENTWAITSYNCKHRPROC eglClientWaitSyncKHR;
> +};
> +} //namespace libcamera
> diff --git a/src/libcamera/egl.cpp b/src/libcamera/egl.cpp
> new file mode 100644
> index 0000000000000000000000000000000000000000..b56c65a33837bb31a3e19613f4abb52d77880301
> --- /dev/null
> +++ b/src/libcamera/egl.cpp
> @@ -0,0 +1,408 @@
> +/* SPDX-License-Identifier: LGPL-2.1-or-later */
> +/*
> + * Copyright (C) 2024, Linaro Ltd.
> + *
> + * Authors:
> + * Bryan O'Donoghue<bryan.odonoghue@linaro.org>
> + *
> + * egl.cpp - Helper class for managing eGL interactions.
> + */
> +
> +#include "libcamera/internal/egl.h"
> +
> +#include <fcntl.h>
> +#include <sys/ioctl.h>
> +#include <sys/mman.h>
> +#include <unistd.h>
> +
> +#include <libdrm/drm_fourcc.h>
> +#include <linux/dma-buf.h>
> +#include <linux/dma-heap.h>
> +
> +namespace libcamera {
> +
> +LOG_DEFINE_CATEGORY(eGL)
> +
> +eGL::eGL()
> +{
> +}
> +
> +eGL::~eGL()
> +{
> +}
> +
> +int eGL::syncOutput(void)
> +{
> +	glFlush();
> +	eglClientWaitSyncKHR(display_, sync_, 0, EGL_FOREVER_KHR);
> +
> +	return 0;
> +}
> +
> +// Create linear image attached to previous BO object
> +int eGL::createDMABufTexture2D(eGLImage *eglImage, int fd, bool output)
> +{
> +	int ret = 0;
> +
> +	EGLint image_attrs[] = {
> +		EGL_WIDTH, (EGLint)eglImage->width_,
> +		EGL_HEIGHT, (EGLint)eglImage->height_,
> +		EGL_LINUX_DRM_FOURCC_EXT, DRM_FORMAT_ARGB8888,
> +		EGL_DMA_BUF_PLANE0_FD_EXT, fd,
> +		EGL_DMA_BUF_PLANE0_OFFSET_EXT, 0,
> +		EGL_DMA_BUF_PLANE0_PITCH_EXT, (EGLint)eglImage->stride_,
> +		EGL_NONE, EGL_NONE,	/* modifier lo */
> +		EGL_NONE, EGL_NONE,	/* modifier hi */

These two cause eglCreateImageKHR() to fail on this platform. Simply 
replacing it with

         EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT, 0,
         EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT, 0,

does the trick, though.

> +		EGL_NONE,
> +	};
> +
> +	eglImage->image_ = eglCreateImageKHR(display_, EGL_NO_CONTEXT,
> +					     EGL_LINUX_DMA_BUF_EXT,
> +					     NULL, image_attrs);
> +
> +	if (eglImage->image_ == EGL_NO_IMAGE_KHR) {
> +		LOG(eGL, Error) << "eglCreateImageKHR fail";
> +		ret = -ENODEV;
> +		goto done;
> +	}
> +
> +	// Bind texture unit and texture
> +	glActiveTexture(eglImage->texture_unit_);
> +	glBindTexture(GL_TEXTURE_2D, eglImage->texture_);
> +
> +	// Generate texture with filter semantics
> +	glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, eglImage->image_);
> +
> +	// Nearest filtering
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
> +
> +	// Wrap to edge to avoid edge artifacts
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
> +
> +	if (output) {
> +		// Generate a framebuffer from our texture direct to dma-buf handle buffer
> +		glBindFramebuffer(GL_FRAMEBUFFER, eglImage->fbo_);
> +		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, eglImage->texture_, 0);
> +
> +		GLenum err = glCheckFramebufferStatus(GL_FRAMEBUFFER);
> +		if (err!= GL_FRAMEBUFFER_COMPLETE) {
> +			LOG(eGL, Error) << "glFrameBufferTexture2D error " << err;
> +			ret = -ENODEV;
> +			goto done;
> +		}
> +	}
> +done:
> +	return ret;
> +}
> +
> +int eGL::createInputDMABufTexture2D(eGLImage *eglImage, int fd)
> +{
> +	return createDMABufTexture2D(eglImage, fd, false);
> +}
> +int eGL::createOutputDMABufTexture2D(eGLImage *eglImage, int fd)
> +{
> +	return createDMABufTexture2D(eglImage, fd, true);
> +}
> +
> +void eGL::destroyDMABufTexture(eGLImage *eglImage)
> +{
> +	eglDestroyImage(display_, eglImage->image_);
> +}
> +
> +// Generate a 2D texture from an input buffer directly
> +void eGL::createTexture2D(eGLImage *eglImage, GLint format, uint32_t width, uint32_t height, void *data)
> +{
> +	glActiveTexture(eglImage->texture_unit_);
> +	glBindTexture(GL_TEXTURE_2D, eglImage->texture_);
> +
> +	// Generate texture, bind, associate image to texture, configure, unbind
> +	glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
> +
> +	// Nearest filtering
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
> +
> +	// Wrap to edge to avoid edge artifacts
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
> +}
> +
> +int eGL::initEGLContext(GBM *gbmContext)
> +{
> +	EGLint configAttribs[] = {
> +		EGL_RED_SIZE, 8,
> +		EGL_GREEN_SIZE, 8,
> +		EGL_BLUE_SIZE, 8,
> +		EGL_ALPHA_SIZE, 8,
> +		EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
> +		EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
> +		EGL_NONE
> +	};
> +
> +	EGLint contextAttribs[] = {
> +		EGL_CONTEXT_MAJOR_VERSION, 2,
> +		EGL_NONE
> +	};
> +
> +	EGLint numConfigs;
> +	EGLConfig config;
> +	EGLint major;
> +	EGLint minor;
> +
> +	if (!eglBindAPI(EGL_OPENGL_ES_API)) {
> +		LOG(eGL, Error) << "API bind fail";
> +		goto fail;
> +	}
> +
> +	display_ = eglGetDisplay(gbmContext->getDevice());
> +	if (display_ == EGL_NO_DISPLAY) {
> +		LOG(eGL, Error) << "Unable to get EGL display";
> +		goto fail;
> +	}
> +
> +	if (eglInitialize(display_, &major, &minor) != EGL_TRUE) {
> +		LOG(eGL, Error) << "eglInitialize fail";
> +		goto fail;
> +	}
> +
> +	LOG(eGL, Info) << "EGL: version " << major << "." << minor;
> +	LOG(eGL, Info) << "EGL: EGL_VERSION: " << eglQueryString(display_, EGL_VERSION);
> +	LOG(eGL, Info) << "EGL: EGL_VENDOR: " << eglQueryString(display_, EGL_VENDOR);
> +	LOG(eGL, Info) << "EGL: EGL_CLIENT_APIS: " << eglQueryString(display_, EGL_CLIENT_APIS);
> +	LOG(eGL, Info) << "EGL: EGL_EXTENSIONS: " << eglQueryString(display_, EGL_EXTENSIONS);
> +
> +	eglCreateImageKHR = (PFNEGLCREATEIMAGEKHRPROC)eglGetProcAddress("eglCreateImageKHR");
> +	if (!eglCreateImageKHR) {
> +		LOG(eGL, Error) << "eglCreateImageKHR not found";
> +		goto fail;
> +	}
> +
> +	eglDestroyImageKHR = (PFNEGLDESTROYIMAGEKHRPROC)eglGetProcAddress("eglDestroyImageKHR");
> +	if (!eglDestroyImageKHR) {
> +		LOG(eGL, Error) << "eglDestroyImageKHR not found";
> +		goto fail;
> +	}
> +
> +	glEGLImageTargetTexture2DOES = (PFNGLEGLIMAGETARGETTEXTURE2DOESPROC)eglGetProcAddress("glEGLImageTargetTexture2DOES");
> +	if (!glEGLImageTargetTexture2DOES) {
> +		LOG(eGL, Error) << "glEGLImageTargetTexture2DOES not found";
> +		goto fail;
> +	}
> +
> +	eglCreateSyncKHR = (PFNEGLCREATESYNCKHRPROC)eglGetProcAddress("eglCreateSyncKHR");
> +	if (!eglCreateSyncKHR) {
> +		LOG(eGL, Error) << "eglCreateSyncKHR not found";
> +		goto fail;
> +	}
> +
> +	eglDestroySyncKHR = (PFNEGLDESTROYSYNCKHRPROC)eglGetProcAddress("eglDestroySyncKHR");
> +	if (!eglDestroySyncKHR) {
> +		LOG(eGL, Error) << "eglDestroySyncKHR not found";
> +		goto fail;
> +	}
> +
> +	eglClientWaitSyncKHR = (PFNEGLCLIENTWAITSYNCKHRPROC)eglGetProcAddress("eglClientWaitSyncKHR");
> +	if (!eglClientWaitSyncKHR) {
> +		LOG(eGL, Error) << "eglClientWaitSyncKHR not found";
> +		goto fail;
> +	}
> +
> +	if (eglChooseConfig(display_, configAttribs, &config, 1, &numConfigs) != EGL_TRUE) {
> +		LOG(eGL, Error) << "eglChooseConfig fail";
> +		goto fail;
> +	}
> +
> +	context_ = eglCreateContext(display_, config, EGL_NO_CONTEXT, contextAttribs);
> +	if (context_ == EGL_NO_CONTEXT) {
> +		LOG(eGL, Error) << "eglContext returned EGL_NO_CONTEXT";
> +		goto fail;
> +	}
> +
> +	makeCurrent();
> +
> +	sync_ = eglCreateSyncKHR(display_, EGL_SYNC_FENCE_KHR, NULL);
> +	if (sync_ == EGL_NO_SYNC_KHR) {
> +		LOG(eGL, Error) << "eglCreateSyncKHR fail";
> +		goto fail;
> +	}
> +
> +	return 0;
> +fail:
> +
> +	return -ENODEV;
> +}
> +
> +void eGL::cleanUp(void)
> +{
> +	if (sync_) {
> +		makeCurrent();
> +		eglDestroySyncKHR(display_, sync_);
> +	}
> +
> +}
> +void eGL::makeCurrent(void)
> +{
> +	if (eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, context_) != EGL_TRUE) {
> +		LOG(eGL, Error) << "eglMakeCurrent fail";
> +	}
> +}
> +
> +void eGL::swapBuffers(void)
> +{
> +	if (eglSwapBuffers(display_, surface_) != EGL_TRUE) {
> +		LOG(eGL, Error) << "eglSwapBuffers fail";
> +	}
> +}
> +
> +void eGL::useProgram(GLuint programId)
> +{
> +	glUseProgram(programId);
> +}
> +
> +void eGL::pushEnv(std::vector<std::string> &shaderEnv, const char *str)
> +{
> +	std::string addStr = str;
> +
> +	addStr.push_back('\n');
> +	shaderEnv.push_back(addStr);
> +}
> +
> +int eGL::compileVertexShader(GLuint &shaderId, unsigned char *shaderData,
> +			     unsigned int shaderDataLen,
> +			     std::vector<std::string> shaderEnv)
> +{
> +	return compileShader(GL_VERTEX_SHADER, shaderId, shaderData, shaderDataLen, shaderEnv);
> +}
> +
> +int eGL::compileFragmentShader(GLuint &shaderId, unsigned char *shaderData,
> +			       unsigned int shaderDataLen,
> +			       std::vector<std::string> shaderEnv)
> +{
> +	return compileShader(GL_FRAGMENT_SHADER, shaderId, shaderData, shaderDataLen, shaderEnv);
> +}
> +
> +int eGL::compileShader(int shaderType, GLuint &shaderId, unsigned char *shaderData,
> +		       unsigned int shaderDataLen,
> +		       std::vector<std::string> shaderEnv)
> +{
> +	GLchar **shaderSourceData;
> +	GLint *shaderDataLengths;
> +	GLint success;
> +	GLsizei count;
> +	size_t i;
> +
> +	count = 1 + shaderEnv.size();
> +	shaderSourceData = new GLchar *[count];
> +	shaderDataLengths = new GLint[count];
> +
> +	// Prefix defines before main body of shader
> +	for (i = 0; i < shaderEnv.size(); i++) {
> +		shaderSourceData[i] = (GLchar *)shaderEnv[i].c_str();
> +		shaderDataLengths[i] = shaderEnv[i].length();
> +	}
> +
> +	// Now the main body of the shader program
> +	shaderSourceData[i] = (GLchar *)shaderData;
> +	shaderDataLengths[i] = shaderDataLen;
> +
> +	// And create the shader
> +	shaderId = glCreateShader(shaderType);
> +	glShaderSource(shaderId, count, shaderSourceData, shaderDataLengths);
> +	glCompileShader(shaderId);
> +
> +	// Check status
> +	glGetShaderiv(shaderId, GL_COMPILE_STATUS, &success);
> +	if (success == GL_FALSE) {
> +		GLint sizeLog = 0;
> +		GLchar *infoLog;
> +
> +		glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &sizeLog);
> +		infoLog = new GLchar[sizeLog];
> +
> +		glGetShaderInfoLog(shaderId, sizeLog, &sizeLog, infoLog);
> +		LOG(eGL, Error) << infoLog;
> +
> +		delete[] infoLog;
> +	}
> +
> +	delete[] shaderSourceData;
> +	delete[] shaderDataLengths;
> +
> +	return !(success == GL_TRUE);
> +}
> +
> +void eGL::dumpShaderSource(GLuint shaderId)
> +{
> +	GLint shaderLength = 0;
> +	GLchar *shaderSource;
> +
> +	glGetShaderiv(shaderId, GL_SHADER_SOURCE_LENGTH, &shaderLength);
> +
> +	LOG(eGL, Debug) << "Shader length is " << shaderLength;
> +
> +	if (shaderLength > 0) {
> +		shaderSource = new GLchar[shaderLength];
> +		if (!shaderSource)
> +			return;
> +
> +		glGetShaderSource(shaderId, shaderLength, &shaderLength, shaderSource);
> +		if (shaderLength) {
> +			LOG(eGL, Debug) << "Shader source = " << shaderSource;
> +		}
> +		delete[] shaderSource;
> +	}
> +}
> +
> +int eGL::linkProgram(GLuint &programId, GLuint vertexshaderId, GLuint fragmentshaderId)
> +{
> +	GLint success;
> +	GLenum err;
> +
> +	programId = glCreateProgram();
> +	if (!programId)
> +		goto fail;
> +
> +	glAttachShader(programId, vertexshaderId);
> +	if ((err = glGetError()) != GL_NO_ERROR) {
> +		LOG(eGL, Error) << "Attach compute vertex shader fail";
> +		goto fail;
> +	}
> +
> +	glAttachShader(programId, fragmentshaderId);
> +	if ((err = glGetError()) != GL_NO_ERROR) {
> +		LOG(eGL, Error) << "Attach compute vertex shader fail";
> +		goto fail;
> +	}
> +
> +	glLinkProgram(programId);
> +	if ((err = glGetError()) != GL_NO_ERROR) {
> +		LOG(eGL, Error) << "Link program fail";
> +		goto fail;
> +	}
> +
> +	glDetachShader(programId, fragmentshaderId);
> +	glDetachShader(programId, vertexshaderId);
> +
> +	// Check status
> +	glGetProgramiv(programId, GL_LINK_STATUS, &success);
> +	if (success == GL_FALSE) {
> +		GLint sizeLog = 0;
> +		GLchar *infoLog;
> +
> +		glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &sizeLog);
> +		infoLog = new GLchar[sizeLog];
> +
> +		glGetProgramInfoLog(programId, sizeLog, &sizeLog, infoLog);
> +		LOG(eGL, Error) << infoLog;
> +
> +		delete[] infoLog;
> +		goto fail;
> +	}
> +
> +	return 0;
> +fail:
> +	return -ENODEV;
> +}
> +} // namespace libcamera
> diff --git a/src/libcamera/meson.build b/src/libcamera/meson.build
> index 64270b571cea2ece8d4dfea8a23b8edf60de70d3..705c328a27f68377573916a77573335f4f4ab3cc 100644
> --- a/src/libcamera/meson.build
> +++ b/src/libcamera/meson.build
> @@ -78,6 +78,27 @@ if libgbm.found() and gbm_works
>       ])
>   endif
>   
> +libegl = cc.find_library('EGL', required : false)
> +libglesv2 = cc.find_library('GLESv2', required : false)
> +mesa_works = cc.check_header('EGL/egl.h', required: false)
> +
> +if libegl.found() and mesa_works
> +    config_h.set('HAVE_LIBEGL', 1)
> +endif
> +
> +if libglesv2.found() and mesa_works
> +    config_h.set('HAVE_GLESV2', 1)
> +endif
> +
> +if mesa_works and gbm_works
> +    libcamera_internal_sources += files([
> +        'egl.cpp',
> +    ])
> +    gles_headless_enabled = true
> +else
> +    gles_headless_enabled = false
> +endif
> +
>   subdir('base')
>   subdir('converter')
>   subdir('ipa')
> @@ -191,7 +212,9 @@ libcamera_deps += [
>       libcamera_base_private,
>       libcrypto,
>       libdl,
> +    libegl,
>       libgbm,
> +    libglesv2,
>       liblttng,
>       libudev,
>       libyaml,
>