From 12565aab08a8ca388883f105a850f6694247ef9b Mon Sep 17 00:00:00 2001 From: klemek Date: Mon, 22 Sep 2025 22:26:24 +0200 Subject: [PATCH] rename device -> video capture --- src/args.c | 3 +- src/forge.c | 40 ++++---- src/shaders.c | 52 +++++----- src/shaders.h | 6 +- src/types.h | 4 +- src/video.c | 255 ++++++++++++++++++++++++++------------------------ src/video.h | 6 +- 7 files changed, 192 insertions(+), 174 deletions(-) diff --git a/src/args.c b/src/args.c index b1c8fca..dc6b44a 100644 --- a/src/args.c +++ b/src/args.c @@ -40,7 +40,8 @@ static void print_help(int status_code) { " -f, --frag fragment shaders directory (default: TODO)\n" " -fc, --frag-config fragment shaders config file (default: " "TODO)\n" - " -v, --video-in path to video device (multiple allowed)\n" + " -v, --video-in path to video capture device (multiple " + "allowed)\n" " -is, --internal-size internal texture height (default: 720)\n" "(default: " "3)\n" diff --git a/src/forge.c b/src/forge.c index e51e0a2..e8032dd 100644 --- a/src/forge.c +++ b/src/forge.c @@ -19,7 +19,7 @@ static Context context; static ShaderProgram program; static Window *window_output; static Window *window_monitor; -static VideoDevice *devices; +static VideoCapture *video_captures; static File *fragment_shaders; static File common_shader_code; static Timer timer; @@ -145,37 +145,38 @@ static void free_files(unsigned int frag_count) { file_free(&common_shader_code, true); } -static void init_devices(char *video_in[MAX_VIDEO], unsigned int video_count, - unsigned int internal_size) { +static void init_video_captures(char *video_in[MAX_VIDEO], + unsigned int video_count, + unsigned int internal_size) { unsigned int i; - devices = malloc(video_count * sizeof(VideoDevice)); + video_captures = malloc(video_count * sizeof(VideoCapture)); for (i = 0; i < video_count; i++) { - devices[i] = video_init(video_in[i], internal_size); + video_captures[i] = video_init(video_in[i], internal_size); } } -static void start_devices(unsigned int video_count) { +static void start_video_captures(unsigned int video_count) { unsigned int i; for (i = 0; i < video_count; i++) { - if (!devices[i].error) { - video_background_read(&devices[i], &stop); + if (!video_captures[i].error) { + video_background_read(&video_captures[i], &stop); } } } -static void free_devices(unsigned int video_count) { +static void free_video_captures(unsigned int video_count) { unsigned int i; for (i = 0; i < video_count; i++) { - shaders_free_video(program, devices[i]); + shaders_free_video(program, video_captures[i]); - video_free(devices[i]); + video_free(video_captures[i]); } - free(devices); + free(video_captures); } static void error_callback(int error, const char *description) { @@ -243,7 +244,8 @@ void forge_run(Parameters params) { context.internal_height = params.internal_size; - init_devices(params.video_in, params.video_count, params.internal_size); + init_video_captures(params.video_in, params.video_count, + params.internal_size); if (params.output) { window_output = window_init(PACKAGE " " VERSION, params.output_screen, @@ -251,8 +253,8 @@ void forge_run(Parameters params) { window_use(window_output, &context); - program = shaders_init(fragment_shaders, shader_config, context, devices, - params.video_count, NULL); + program = shaders_init(fragment_shaders, shader_config, context, + video_captures, params.video_count, NULL); } else { window_output = NULL; } @@ -264,8 +266,8 @@ void forge_run(Parameters params) { window_use(window_monitor, &context); - program = shaders_init(fragment_shaders, shader_config, context, devices, - params.video_count, + program = shaders_init(fragment_shaders, shader_config, context, + video_captures, params.video_count, window_output != NULL ? &program : NULL); } else { window_monitor = NULL; @@ -280,7 +282,7 @@ void forge_run(Parameters params) { timer = timer_init(30); - start_devices(params.video_count); + start_video_captures(params.video_count); log_info("Initialized"); @@ -307,7 +309,7 @@ void forge_run(Parameters params) { shaders_free_window(program, params.output); } - free_devices(params.video_count); + free_video_captures(params.video_count); free_context(); diff --git a/src/shaders.c b/src/shaders.c index 6dc9d1f..f3ce44d 100644 --- a/src/shaders.c +++ b/src/shaders.c @@ -69,30 +69,31 @@ static void rebind_textures(ShaderProgram *program) { } } -static void link_video_to_texture(ShaderProgram *program, VideoDevice *device, +static void link_video_to_texture(ShaderProgram *program, + VideoCapture *video_capture, unsigned int texture_index) { - device->dma_image = EGL_NO_IMAGE_KHR; + video_capture->dma_image = EGL_NO_IMAGE_KHR; const EGLint attrib_list[] = {EGL_WIDTH, - device->width, + video_capture->width, EGL_HEIGHT, - device->height, + video_capture->height, EGL_LINUX_DRM_FOURCC_EXT, - device->pixelformat, + video_capture->pixelformat, EGL_DMA_BUF_PLANE0_FD_EXT, - device->exp_fd, + video_capture->exp_fd, EGL_DMA_BUF_PLANE0_OFFSET_EXT, 0, EGL_DMA_BUF_PLANE0_PITCH_EXT, - device->bytesperline, + video_capture->bytesperline, EGL_NONE}; - device->dma_image = eglCreateImageKHR(program->egl_display, EGL_NO_CONTEXT, - EGL_LINUX_DMA_BUF_EXT, - (EGLClientBuffer)NULL, attrib_list); + video_capture->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 %04x", device->name, + if (video_capture->dma_image == EGL_NO_IMAGE_KHR) { + log_error("(%s) eglCreateImageKHR failed %04x", video_capture->name, eglGetError()); return; } @@ -101,27 +102,28 @@ static void link_video_to_texture(ShaderProgram *program, VideoDevice *device, glBindTexture(GL_TEXTURE_2D, program->textures[texture_index]); - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, device->width, device->height, 0, - GL_RGB, GL_UNSIGNED_BYTE, 0); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, video_capture->width, + video_capture->height, 0, GL_RGB, GL_UNSIGNED_BYTE, 0); // https://registry.khronos.org/OpenGL/extensions/EXT/EXT_EGL_image_storage.txt glEGLImageTargetTextureStorageEXT(program->textures[texture_index], - (GLeglImageOES)device->dma_image, NULL); + (GLeglImageOES)video_capture->dma_image, + NULL); - log_info("Texture %d linked to %s", texture_index, device->name); + log_info("Texture %d linked to %s", texture_index, video_capture->name); } static void init_videos(ShaderProgram *program, ConfigFile shader_config, - VideoDevice *devices, unsigned int device_count) { + VideoCapture *video_captures, unsigned int count) { unsigned int i; unsigned tex_i; char name[32]; for (i = 0; i < program->in_count; i++) { - if (i < device_count && !devices[i].error) { + if (i < count && !video_captures[i].error) { sprintf(name, "IN_%d_OUT", i + 1); tex_i = config_file_get_int(shader_config, name, 0); - link_video_to_texture(program, &devices[i], tex_i); + link_video_to_texture(program, &video_captures[i], tex_i); } else { log_warn("Cannot link input %d", i + 1); } @@ -353,8 +355,8 @@ static void init_programs(ShaderProgram *program, ConfigFile shader_config) { } ShaderProgram shaders_init(File *fragment_shaders, ConfigFile shader_config, - Context context, VideoDevice *devices, - unsigned int device_count, ShaderProgram *previous) { + Context context, VideoCapture *video_captures, + unsigned int count, ShaderProgram *previous) { ShaderProgram program; if (previous == NULL) { @@ -383,7 +385,7 @@ ShaderProgram shaders_init(File *fragment_shaders, ConfigFile shader_config, init_textures(&program, context); - init_videos(&program, shader_config, devices, device_count); + init_videos(&program, shader_config, video_captures, count); init_framebuffers(&program, shader_config); @@ -548,8 +550,8 @@ 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); +void shaders_free_video(ShaderProgram program, VideoCapture video_capture) { + if (!video_capture.error && video_capture.dma_image != EGL_NO_IMAGE_KHR) { + eglDestroyImageKHR(program.egl_display, video_capture.dma_image); } } \ No newline at end of file diff --git a/src/shaders.h b/src/shaders.h index 66c73c3..5466685 100644 --- a/src/shaders.h +++ b/src/shaders.h @@ -4,8 +4,8 @@ #define SHADERS_H ShaderProgram shaders_init(File *fragment_shaders, ConfigFile shader_config, - Context context, VideoDevice *devices, - unsigned int device_count, ShaderProgram *previous); + Context context, VideoCapture *video_captures, + unsigned int count, ShaderProgram *previous); void shaders_update(ShaderProgram program, File *fragment_shaders, unsigned int i); @@ -17,6 +17,6 @@ void shaders_free(ShaderProgram program); void shaders_free_window(ShaderProgram program, bool secondary); -void shaders_free_video(ShaderProgram program, VideoDevice device); +void shaders_free_video(ShaderProgram program, VideoCapture video_capture); #endif /* SHADERS_H */ \ No newline at end of file diff --git a/src/types.h b/src/types.h index 3ca2a5a..cbad375 100644 --- a/src/types.h +++ b/src/types.h @@ -85,7 +85,7 @@ typedef struct ShaderProgram { EGLDisplay egl_display; } ShaderProgram; -typedef struct VideoDevice { +typedef struct VideoCapture { char *name; bool error; int fd; @@ -97,7 +97,7 @@ typedef struct VideoDevice { bool output; struct v4l2_buffer buf; EGLImageKHR dma_image; -} VideoDevice; +} VideoCapture; typedef GLFWwindow Window; diff --git a/src/video.c b/src/video.c index 4f781f2..bff7a81 100644 --- a/src/video.c +++ b/src/video.c @@ -11,89 +11,99 @@ #include "video.h" #include "window.h" -static void ioctl_error(VideoDevice *device, const char *operation, +static void ioctl_error(VideoCapture *video_capture, const char *operation, const char *default_msg) { if (errno == EINVAL) { - log_warn("(%s) %s -> EINVAL: %s", device->name, operation, default_msg); + log_warn("(%s) %s -> EINVAL: %s", video_capture->name, operation, + default_msg); } else if (errno == EAGAIN) { log_warn("(%s) %s -> EAGAIN: device state invalid", operation, - device->name); + video_capture->name); } else if (errno == EBADF) { log_warn("(%s) %s -> EBADF: file descriptor invalid", operation, - device->name); + video_capture->name); } else if (errno == EBUSY) { - log_warn("(%s) %s -> EBUSY: device is busy", device->name, operation); + log_warn("(%s) %s -> EBUSY: device is busy", video_capture->name, + operation); } else if (errno == EFAULT) { - log_warn("(%s) %s -> EFAULT: invalid pointer", device->name, operation); + log_warn("(%s) %s -> EFAULT: invalid pointer", video_capture->name, + operation); } else if (errno == ENODEV) { - log_warn("(%s) %s -> ENODEV: device not found", device->name, operation); + log_warn("(%s) %s -> ENODEV: device not found", video_capture->name, + operation); } else if (errno == ENOMEM) { - log_warn("(%s) %s -> ENOMEM: not enough memory", device->name, operation); + log_warn("(%s) %s -> ENOMEM: not enough memory", video_capture->name, + operation); } else if (errno == ENOTTY) { log_warn("(%s) %s -> ENOTTY: ioctl not supported by file descriptor", - device->name, operation); + video_capture->name, operation); } else if (errno == ENOSPC) { - log_warn("(%s) %s -> ENOSPC: USB bandwidth error", device->name, operation); + log_warn("(%s) %s -> ENOSPC: USB bandwidth error", video_capture->name, + operation); } else if (errno == EPERM) { - log_warn("(%s) %s -> EPERM: permission denied", device->name, operation); + log_warn("(%s) %s -> EPERM: permission denied", video_capture->name, + operation); } else if (errno == EIO) { - log_warn("(%s) %s -> EIO: I/O error", device->name, operation); + log_warn("(%s) %s -> EIO: I/O error", video_capture->name, operation); } else if (errno == ENXIO) { - log_warn("(%s) %s -> ENXIO: no device exists", device->name, operation); + log_warn("(%s) %s -> ENXIO: no device exists", video_capture->name, + operation); } else if (errno == EPIPE) { - log_warn("(%s) %s -> EPIPE: pipeline error", device->name, operation); + log_warn("(%s) %s -> EPIPE: pipeline error", video_capture->name, + operation); } else if (errno == ENOLINK) { log_warn("(%s) %s -> ENOLINK: pipeline configuration invalid for Media " "Controller interface", - device->name, operation); + video_capture->name, operation); } else { - log_error("(%s) %s unknown error %d", device->name, operation, errno); + log_error("(%s) %s unknown error %d", video_capture->name, operation, + errno); } - device->error = true; + video_capture->error = true; } -static VideoDevice open_device(char *name) { - VideoDevice device; +static VideoCapture open_device(char *name) { + VideoCapture video_capture; - device.name = name; - device.error = false; - device.fd = -1; + video_capture.name = name; + video_capture.error = false; + video_capture.fd = -1; - device.fd = open(name, O_RDWR); - if (device.fd == -1) { + video_capture.fd = open(name, O_RDWR); + if (video_capture.fd == -1) { log_warn("(%s) Cannot open device", name); - device.error = true; + video_capture.error = true; } - return device; + return video_capture; } -static bool check_device_caps(VideoDevice *device) { +static bool check_caps(VideoCapture *video_capture) { struct v4l2_capability cap; memset(&cap, 0, sizeof(cap)); - if (ioctl(device->fd, VIDIOC_QUERYCAP, &cap) == -1) { - ioctl_error(device, "VIDIOC_QUERYCAP", "Not a V4L2 device"); + if (ioctl(video_capture->fd, VIDIOC_QUERYCAP, &cap) == -1) { + ioctl_error(video_capture, "VIDIOC_QUERYCAP", "Not a V4L2 device"); return false; } if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) { - log_warn("(%s) Not a video capture device", device->name); - device->error = true; + log_warn("(%s) Not a video capture device", video_capture->name); + video_capture->error = true; return false; } if (!(cap.capabilities & V4L2_CAP_STREAMING)) { - log_warn("(%s) No streaming i/o support", device->name); - device->error = true; + log_warn("(%s) No streaming i/o support", video_capture->name); + video_capture->error = true; return false; } return true; } -static bool get_available_sizes(VideoDevice *device, +static bool get_available_sizes(VideoCapture *video_capture, unsigned int preferred_height) { struct v4l2_frmsizeenum fmt_enum; unsigned int index; @@ -104,23 +114,24 @@ static bool get_available_sizes(VideoDevice *device, fmt_enum.index = index; fmt_enum.pixel_format = V4L2_PIX_FMT_YUYV; - device->width = 0; - device->height = 0; + video_capture->width = 0; + video_capture->height = 0; - while (ioctl(device->fd, VIDIOC_ENUM_FRAMESIZES, &fmt_enum) == 0) { + while (ioctl(video_capture->fd, VIDIOC_ENUM_FRAMESIZES, &fmt_enum) == 0) { if (fmt_enum.type == V4L2_FRMSIZE_TYPE_DISCRETE) { - log_trace("(%s) %d: %dx%d", device->name, index, fmt_enum.discrete.width, - fmt_enum.discrete.height); + log_trace("(%s) %d: %dx%d", video_capture->name, index, + fmt_enum.discrete.width, fmt_enum.discrete.height); if (fmt_enum.discrete.height == preferred_height) { - device->height = preferred_height; - if (device->width == 0 || device->width < fmt_enum.discrete.width) { - device->width = fmt_enum.discrete.width; + video_capture->height = preferred_height; + if (video_capture->width == 0 || + video_capture->width < fmt_enum.discrete.width) { + video_capture->width = fmt_enum.discrete.width; } } else if (fmt_enum.discrete.height < preferred_height && - fmt_enum.discrete.height > device->height) { - device->height = fmt_enum.discrete.height; - device->width = fmt_enum.discrete.width; + fmt_enum.discrete.height > video_capture->height) { + video_capture->height = fmt_enum.discrete.height; + video_capture->width = fmt_enum.discrete.width; } } @@ -129,104 +140,104 @@ static bool get_available_sizes(VideoDevice *device, fmt_enum.pixel_format = V4L2_PIX_FMT_YUYV; } - if (device->height == 0) { - device->error = true; + if (video_capture->height == 0) { + video_capture->error = true; return false; } return true; } -static bool set_device_format(VideoDevice *device) { +static bool set_format(VideoCapture *video_capture) { struct v4l2_format fmt; - device->output = false; + video_capture->output = false; memset(&fmt, 0, sizeof(fmt)); fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - fmt.fmt.pix.width = device->width; - fmt.fmt.pix.height = device->height; + fmt.fmt.pix.width = video_capture->width; + fmt.fmt.pix.height = video_capture->height; fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; fmt.fmt.pix.field = V4L2_FIELD_INTERLACED; - if (ioctl(device->fd, VIDIOC_S_FMT, &fmt) == -1) { + if (ioctl(video_capture->fd, VIDIOC_S_FMT, &fmt) == -1) { fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; - device->output = true; + video_capture->output = true; - if (ioctl(device->fd, VIDIOC_S_FMT, &fmt) == -1) { - ioctl_error(device, "VIDIOC_S_FMT", + if (ioctl(video_capture->fd, VIDIOC_S_FMT, &fmt) == -1) { + ioctl_error(video_capture, "VIDIOC_S_FMT", "Requested buffer type not supported"); 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; + video_capture->width = fmt.fmt.pix.width; + video_capture->height = fmt.fmt.pix.height; + video_capture->pixelformat = fmt.fmt.pix.pixelformat; + video_capture->bytesperline = fmt.fmt.pix.bytesperline; - log_info("(%s) Format fourcc: %c%c%c%c", device->name, + log_info("(%s) Format fourcc: %c%c%c%c", video_capture->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, + log_info("(%s) Resolution: %dx%d", video_capture->name, fmt.fmt.pix.width, fmt.fmt.pix.height); return true; } -static bool request_buffers(VideoDevice *device) { +static bool request_buffers(VideoCapture *video_capture) { struct v4l2_requestbuffers reqbuf; memset(&reqbuf, 0, sizeof(reqbuf)); - reqbuf.type = - device->output ? V4L2_BUF_TYPE_VIDEO_OUTPUT : V4L2_BUF_TYPE_VIDEO_CAPTURE; + reqbuf.type = video_capture->output ? V4L2_BUF_TYPE_VIDEO_OUTPUT + : V4L2_BUF_TYPE_VIDEO_CAPTURE; reqbuf.memory = V4L2_MEMORY_MMAP; reqbuf.count = 1; - if (ioctl(device->fd, VIDIOC_REQBUFS, &reqbuf) == -1) { - ioctl_error(device, "VIDIOC_REQBUFS", + if (ioctl(video_capture->fd, VIDIOC_REQBUFS, &reqbuf) == -1) { + ioctl_error(video_capture, "VIDIOC_REQBUFS", "Buffer type or I/O method not supported"); return false; } - log_info("(%s) V4L2 Buffer Count: %d", device->name, reqbuf.count); + log_info("(%s) V4L2 Buffer Count: %d", video_capture->name, reqbuf.count); return true; } -static bool export_buffer(VideoDevice *device) { +static bool export_buffer(VideoCapture *video_capture) { struct v4l2_exportbuffer expbuf; - device->exp_fd = -1; + video_capture->exp_fd = -1; memset(&expbuf, 0, sizeof(expbuf)); - expbuf.type = - device->output ? V4L2_BUF_TYPE_VIDEO_OUTPUT : V4L2_BUF_TYPE_VIDEO_CAPTURE; + expbuf.type = video_capture->output ? V4L2_BUF_TYPE_VIDEO_OUTPUT + : V4L2_BUF_TYPE_VIDEO_CAPTURE; expbuf.index = 0; expbuf.flags = O_RDONLY; - if (ioctl(device->fd, VIDIOC_EXPBUF, &expbuf) == -1) { + if (ioctl(video_capture->fd, VIDIOC_EXPBUF, &expbuf) == -1) { ioctl_error( - device, "VIDIOC_EXPBUF", + video_capture, "VIDIOC_EXPBUF", "A queue is not in MMAP mode or DMABUF exporting is not supported"); return false; } - device->exp_fd = expbuf.fd; + video_capture->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) { +static bool open_stream(VideoCapture *video_capture) { + if (ioctl(video_capture->fd, VIDIOC_STREAMON, &buf_type) == -1) { ioctl_error( - device, "VIDIOC_STREAMON", + video_capture, "VIDIOC_STREAMON", "Buffer type not supported or no buffer allocated or enqueued yet"); return false; } @@ -234,69 +245,69 @@ static bool open_stream(VideoDevice *device) { return true; } -static void create_image_buffer(VideoDevice *device) { - memset(&device->buf, 0, sizeof(device->buf)); +static void create_image_buffer(VideoCapture *video_capture) { + memset(&video_capture->buf, 0, sizeof(video_capture->buf)); - device->buf.type = - device->output ? V4L2_BUF_TYPE_VIDEO_OUTPUT : V4L2_BUF_TYPE_VIDEO_CAPTURE; - device->buf.memory = V4L2_MEMORY_MMAP; - device->buf.index = 0; + video_capture->buf.type = video_capture->output ? V4L2_BUF_TYPE_VIDEO_OUTPUT + : V4L2_BUF_TYPE_VIDEO_CAPTURE; + video_capture->buf.memory = V4L2_MEMORY_MMAP; + video_capture->buf.index = 0; - ioctl(device->fd, VIDIOC_QBUF, &device->buf); + ioctl(video_capture->fd, VIDIOC_QBUF, &video_capture->buf); } -static void close_stream(VideoDevice device) { - ioctl(device.fd, VIDIOC_STREAMOFF, &buf_type); +static void close_stream(VideoCapture video_capture) { + ioctl(video_capture.fd, VIDIOC_STREAMOFF, &buf_type); } -VideoDevice video_init(char *name, unsigned int preferred_height) { - VideoDevice device; +VideoCapture video_init(char *name, unsigned int preferred_height) { + VideoCapture video_capture; - device = open_device(name); + video_capture = open_device(name); - if (device.error) { - return device; + if (video_capture.error) { + return video_capture; } - if (!check_device_caps(&device)) { - return device; + if (!check_caps(&video_capture)) { + return video_capture; } - if (!get_available_sizes(&device, preferred_height)) { - return device; + if (!get_available_sizes(&video_capture, preferred_height)) { + return video_capture; } - if (!set_device_format(&device)) { - return device; + if (!set_format(&video_capture)) { + return video_capture; } - if (!request_buffers(&device)) { - return device; + if (!request_buffers(&video_capture)) { + return video_capture; } - if (!export_buffer(&device)) { - return device; + if (!export_buffer(&video_capture)) { + return video_capture; } - if (!open_stream(&device)) { - return device; + if (!open_stream(&video_capture)) { + return video_capture; } - create_image_buffer(&device); + create_image_buffer(&video_capture); - return device; + return video_capture; } -static bool read_video(VideoDevice *device) { - if (ioctl(device->fd, VIDIOC_DQBUF, &device->buf) == -1) { - ioctl_error(device, "VIDIOC_DQBUF", +static bool read_video(VideoCapture *video_capture) { + if (ioctl(video_capture->fd, VIDIOC_DQBUF, &video_capture->buf) == -1) { + ioctl_error(video_capture, "VIDIOC_DQBUF", "buffer type not supported or no buffer allocated or the index " "is out of bounds"); return false; } - if (ioctl(device->fd, VIDIOC_QBUF, &device->buf) == -1) { - ioctl_error(device, "VIDIOC_QBUF", + if (ioctl(video_capture->fd, VIDIOC_QBUF, &video_capture->buf) == -1) { + ioctl_error(video_capture, "VIDIOC_QBUF", "buffer type not supported or no buffer allocated or the index " "is out of bounds"); return false; @@ -305,7 +316,7 @@ static bool read_video(VideoDevice *device) { return true; } -void video_background_read(VideoDevice *device, bool *stop) { +void video_background_read(VideoCapture *video_capture, bool *stop) { pid_t pid; pid = fork(); if (pid < 0) { @@ -315,23 +326,25 @@ void video_background_read(VideoDevice *device, bool *stop) { if (pid == 0) { return; } - log_info("%s background acquisition started (pid: %d)", device->name, pid); - while (!*stop && read_video(device)) { + log_info("%s background acquisition started (pid: %d)", video_capture->name, + pid); + while (!*stop && read_video(video_capture)) { // repeat infinitely } - log_info("%s background acquisition stopped (pid: %d)", device->name, pid); + log_info("%s background acquisition stopped (pid: %d)", video_capture->name, + pid); window_terminate(); exit(EXIT_SUCCESS); } -void video_free(VideoDevice device) { - if (!device.error) { - close_stream(device); +void video_free(VideoCapture video_capture) { + if (!video_capture.error) { + close_stream(video_capture); } - if (device.exp_fd != -1) { - close(device.exp_fd); + if (video_capture.exp_fd != -1) { + close(video_capture.exp_fd); } - if (device.fd != -1) { - close(device.fd); + if (video_capture.fd != -1) { + close(video_capture.fd); } } \ No newline at end of file diff --git a/src/video.h b/src/video.h index bb38d13..a9acde7 100644 --- a/src/video.h +++ b/src/video.h @@ -3,10 +3,10 @@ #ifndef VIDEO_H #define VIDEO_H -VideoDevice video_init(char *name, unsigned int preferred_height); +VideoCapture video_init(char *name, unsigned int preferred_height); -void video_background_read(VideoDevice *device, bool *stop); +void video_background_read(VideoCapture *video_capture, bool *stop); -void video_free(VideoDevice device); +void video_free(VideoCapture video_capture); #endif /* VIDEO_H */ \ No newline at end of file