wip video device

2025-09-21 17:46:19 +02:00
parent 724eec9241
commit 2be15dc7c9
12 changed files with 3319 additions and 28 deletions
@@ -1,5 +1,3 @@
-#include <GLFW/glfw3.h>
-#include <glad/gl.h>
 #include <linmath.h>
 #include <stddef.h>
 #include <stdio.h>
@@ -14,7 +12,24 @@
 #define GLAD_GL_IMPLEMENTATION
 #include <glad/gl.h>

-static void init_gl() { gladLoadGL(glfwGetProcAddress); }
+#define GLAD_EGL_IMPLEMENTATION
+#include <glad/egl.h>
+
+#include <GLFW/glfw3.h>
+#include <GLFW/glfw3native.h>
+
+static void init_gl(ShaderProgram *program) {
+  gladLoadGL(glfwGetProcAddress);
+
+  program->egl_display = glfwGetEGLDisplay();
+  if (program->egl_display == EGL_NO_DISPLAY) {
+    log_error("error: glfwGetEGLDisplay no EGLDisplay returned");
+    program->error = true;
+    return;
+  }
+
+  gladLoadEGL(program->egl_display, glfwGetProcAddress);
+}

 static void init_textures(ShaderProgram *program, Context context) {
  unsigned int i;
@@ -56,6 +71,41 @@ static void rebind_textures(ShaderProgram *program) {
  }
 }

+static void link_video_to_texture(ShaderProgram *program, VideoDevice *device,
+                                  unsigned int texture_index) {
+  device->dma_image = EGL_NO_IMAGE_KHR;
+
+  const EGLint attrib_list[] = {EGL_WIDTH,
+                                device->width,
+                                EGL_HEIGHT,
+                                device->height,
+                                EGL_LINUX_DRM_FOURCC_EXT,
+                                device->pixelformat,
+                                EGL_DMA_BUF_PLANE0_FD_EXT,
+                                device->exp_fd,
+                                EGL_DMA_BUF_PLANE0_OFFSET_EXT,
+                                0,
+                                EGL_DMA_BUF_PLANE0_PITCH_EXT,
+                                device->bytesperline,
+                                EGL_NONE};
+
+  device->dma_image = eglCreateImageKHR(program->egl_display, EGL_NO_CONTEXT,
+                                        EGL_LINUX_DMA_BUF_EXT,
+                                        (EGLClientBuffer)NULL, attrib_list);
+
+  if (device->dma_image == EGL_NO_IMAGE_KHR) {
+    log_error("(%s) eglCreateImageKHR failed", device->name);
+    program->error = true;
+    return;
+  }
+
+  // https://registry.khronos.org/OpenGL/extensions/EXT/EXT_EGL_image_storage.txt
+  glEGLImageTargetTextureStorageEXT(program->textures[texture_index],
+                                    (GLeglImageOES)device->dma_image, NULL);
+
+  log_success("Texture %d linked to %s", texture_index, device->name);
+}
+
 static void init_framebuffers(ShaderProgram *program,
                              ConfigFile shader_config) {
  unsigned int i;
@@ -95,8 +145,6 @@ static void init_framebuffers(ShaderProgram *program,
 }

 static void init_vertices(ShaderProgram *program) {
-  unsigned int i;
-
  glGenBuffers(1, &program->vertex_buffer);
  glBindBuffer(GL_ARRAY_BUFFER, program->vertex_buffer);
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
@@ -290,7 +338,7 @@ ShaderProgram shaders_init(File *fragment_shaders, ConfigFile shader_config,
    program.sub_variant_count =
        config_file_get_int(shader_config, "SUB_VARIANT_COUNT", 1);

-    init_gl();
+    init_gl(&program);

    init_shaders(&program, fragment_shaders);

@@ -305,6 +353,9 @@ ShaderProgram shaders_init(File *fragment_shaders, ConfigFile shader_config,
    init_programs(&program, shader_config);

    init_vertices(&program);
+
+    log_debug("Error after init: %04x",
+              glGetError()); // TODO check error at each step
  } else {
    program = *previous;
  }
@@ -455,4 +506,10 @@ void shaders_free(ShaderProgram program) {

 void shaders_free_window(ShaderProgram program, bool secondary) {
  glDeleteVertexArrays(1, &program.vertex_array[secondary ? 1 : 0]);
+}
+
+void shaders_free_video(ShaderProgram program, VideoDevice device) {
+  if (!device.error && device.dma_image != EGL_NO_IMAGE_KHR) {
+    eglDestroyImageKHR(program.egl_display, device.dma_image);
+  }
 }
@@ -16,4 +16,6 @@ void shaders_free(ShaderProgram program);

 void shaders_free_window(ShaderProgram program, bool secondary);

+void shaders_free_video(ShaderProgram program, VideoDevice device);
+
 #endif /* SHADERS_H */
@@ -1,7 +1,9 @@
 #include <GLFW/glfw3.h>
+#include <glad/egl.h>
 #include <glad/gl.h>
 #include <hashmap.h>
 #include <linmath.h>
+#include <linux/videodev2.h>
 #include <stdbool.h>
 #include <sys/time.h>
 #include <time.h>
@@ -72,8 +74,23 @@ typedef struct ShaderProgram {
  unsigned int sub_type_count;
  unsigned int sub_variant_count;
  GLuint *sub_locations;
+
+  EGLDisplay egl_display;
 } ShaderProgram;

+typedef struct VideoDevice {
+  char *name;
+  bool error;
+  int fd;
+  int exp_fd;
+  unsigned int width;
+  unsigned int height;
+  unsigned int pixelformat;
+  unsigned int bytesperline;
+  struct v4l2_buffer buf;
+  EGLImageKHR dma_image;
+} VideoDevice;
+
 typedef GLFWwindow Window;

 typedef struct Context {
@@ -0,0 +1,207 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <linux/videodev2.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+
+#include "logs.h"
+#include "types.h"
+#include "video.h"
+
+static VideoDevice open_device(char *name) {
+  VideoDevice device;
+
+  device.name = name;
+  device.error = false;
+  device.fd = -1;
+
+  device.fd = open(name, O_RDWR);
+  if (device.fd == -1) {
+    log_warn("(%s) Cannot open device", name);
+    device.error = true;
+  }
+
+  return device;
+}
+
+static bool check_device_caps(VideoDevice *device) {
+  struct v4l2_capability cap;
+
+  memset(&cap, 0, sizeof(cap));
+
+  if (ioctl(device->fd, VIDIOC_QUERYCAP, &cap) == -1) {
+    if (EINVAL == errno) {
+      log_warn("(%s) Not a V4L2 device", device->name);
+    } else {
+      log_error("(%s) VIDIOC_QUERYCAP unkown error", device->name);
+    }
+    device->error = true;
+    return false;
+  }
+
+  if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
+    log_warn("(%s) Not a video capture device", device->name);
+    device->error = true;
+    return false;
+  }
+
+  if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
+    log_warn("(%s) No streaming i/o support", device->name);
+    device->error = true;
+    return false;
+  }
+
+  return true;
+}
+
+static bool set_device_format(VideoDevice *device, unsigned int preferred_width,
+                              unsigned int preferred_height) {
+  struct v4l2_format fmt;
+
+  memset(&fmt, 0, sizeof(fmt));
+
+  fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  fmt.fmt.pix.width = preferred_width;
+  fmt.fmt.pix.height = preferred_height;
+  fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_BGRX32;
+  fmt.fmt.pix.field = V4L2_FIELD_NONE;
+
+  if (ioctl(device->fd, VIDIOC_S_FMT, &fmt) == -1) {
+    log_warn("(%s) Format set failed", device->name);
+    device->error = true;
+    return false;
+  }
+
+  device->width = fmt.fmt.pix.width;
+  device->height = fmt.fmt.pix.height;
+  device->pixelformat = fmt.fmt.pix.pixelformat;
+  device->bytesperline = fmt.fmt.pix.bytesperline;
+
+  log_info("(%s) Format fourcc:  %c%c%c%c", device->name,
+           fmt.fmt.pix.pixelformat, fmt.fmt.pix.pixelformat >> 8,
+           fmt.fmt.pix.pixelformat >> 16, fmt.fmt.pix.pixelformat >> 24);
+  log_info("(%s) Resolution:  %dx%d", device->name, fmt.fmt.pix.width,
+           fmt.fmt.pix.height);
+
+  return true;
+}
+
+static bool request_buffers(VideoDevice *device) {
+  struct v4l2_requestbuffers reqbuf;
+
+  memset(&reqbuf, 0, sizeof(reqbuf));
+
+  reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  reqbuf.memory = V4L2_MEMORY_MMAP;
+  reqbuf.count = 1;
+
+  if (ioctl(device->fd, VIDIOC_REQBUFS, &reqbuf) == -1) {
+    if (errno == EINVAL) {
+      log_info("(%s) Video capturing or DMABUF streaming is not supported",
+               device->name);
+    } else {
+      log_error("(%s) VIDIOC_REQBUFS unkown error", device->name);
+    }
+    device->error = true;
+    return false;
+  }
+
+  log_info("(%s) V4L2 Buffer Count:  %d", device->name, reqbuf.count);
+
+  return true;
+}
+
+static bool export_buffer(VideoDevice *device) {
+  struct v4l2_exportbuffer expbuf;
+
+  device->exp_fd = -1;
+
+  memset(&expbuf, 0, sizeof(expbuf));
+
+  expbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  expbuf.index = 0; /// '0' for one buffer
+  expbuf.flags = O_RDONLY;
+
+  if (ioctl(device->fd, VIDIOC_EXPBUF, &expbuf) == -1) {
+    log_error("(%s) VIDIOC_EXPBUF error", device->name);
+    device->error = true;
+    return false;
+  }
+
+  device->exp_fd = expbuf.fd;
+
+  return true;
+}
+
+static const enum v4l2_buf_type buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+static bool open_stream(VideoDevice *device) {
+  if (ioctl(device->fd, VIDIOC_STREAMON, &buf_type) == -1) {
+    log_error("(%s) VIDIOC_STREAMON error", device->name);
+    device->error = true;
+    return false;
+  }
+
+  return true;
+}
+
+static void create_image_buffer(VideoDevice *device) {
+  memset(&device->buf, 0, sizeof(device->buf));
+
+  device->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  device->buf.memory = V4L2_MEMORY_MMAP;
+  device->buf.index = 0;
+
+  ioctl(device->fd, VIDIOC_QBUF, &device->buf);
+}
+
+static void close_stream(VideoDevice device) {
+  ioctl(device.fd, VIDIOC_STREAMOFF, &buf_type);
+}
+
+VideoDevice video_init(char *name, unsigned int preferred_width,
+                       unsigned int preferred_height) {
+  VideoDevice device;
+
+  device = open_device(name);
+
+  if (device.error) {
+    return device;
+  }
+
+  if (!check_device_caps(&device)) {
+    return device;
+  }
+
+  if (!set_device_format(&device, preferred_width, preferred_height)) {
+    return device;
+  }
+
+  if (!request_buffers(&device)) {
+    return device;
+  }
+
+  if (!export_buffer(&device)) {
+    return device;
+  }
+
+  if (!open_stream(&device)) {
+    return device;
+  }
+
+  create_image_buffer(&device);
+
+  return device;
+}
+
+void video_read(VideoDevice device) {
+  ioctl(device.fd, VIDIOC_DQBUF, &device.buf);
+  ioctl(device.fd, VIDIOC_QBUF, &device.buf);
+  // TODO check for error and close
+}
+
+void video_free(VideoDevice device) {
+  close_stream(device);
+  close(device.exp_fd);
+  close(device.fd);
+}
@@ -0,0 +1,13 @@
+#include "types.h"
+
+#ifndef VIDEO_H
+#define VIDEO_H
+
+VideoDevice video_init(char *name, unsigned int preferred_width,
+                       unsigned int preferred_height);
+
+void video_read(VideoDevice device);
+
+void video_free(VideoDevice device);
+
+#endif /* VIDEO_H */