Merge pull request #81 from tiagocoutinho/video-gl

Video opengl

Author: tiagocoutinho

examples/video/gl/common.py

@@ -0,0 +1,116 @@
+import argparse
+import logging
+import selectors
+
+from OpenGL import GL
+
+from linuxpy.video.device import Device, PixelFormat, VideoCapture
+
+OPENCV_FORMATS = {
+    PixelFormat.MJPEG,
+    PixelFormat.YUYV,
+    PixelFormat.YVYU,
+    PixelFormat.UYVY,
+    PixelFormat.YUV420,
+    PixelFormat.NV12,
+    PixelFormat.NV21,
+}
+
+
+def opencv_decode_frame(frame):
+    import cv2
+
+    data, fmt = frame.array, frame.pixel_format
+    if fmt == PixelFormat.MJPEG:
+        result = cv2.imdecode(data, cv2.IMREAD_COLOR)
+    else:
+        YUV_MAP = {
+            PixelFormat.YUYV: cv2.COLOR_YUV2RGB_YUYV,
+            PixelFormat.YVYU: cv2.COLOR_YUV2RGB_YVYU,
+            PixelFormat.UYVY: cv2.COLOR_YUV2RGB_UYVY,
+            PixelFormat.YUV420: cv2.COLOR_YUV2RGB_I420,
+            PixelFormat.NV12: cv2.COLOR_YUV2RGB_NV12,
+            PixelFormat.NV21: cv2.COLOR_YUV2RGB_NV21,
+        }
+        data = frame.array
+        if fmt in {PixelFormat.NV12, PixelFormat.NV21, PixelFormat.YUV420}:
+            data.shape = frame.height * 3 // 2, frame.width, -1
+        else:
+            data.shape = frame.height, frame.width, -1
+        result = cv2.cvtColor(data, YUV_MAP[fmt])
+    return result, GL.GL_BGR
+
+
+def decode_frame(frame):
+    fmt = frame.pixel_format
+    if fmt == PixelFormat.RGB24:
+        return frame.data, GL.GL_RGB
+    elif fmt == PixelFormat.BGR24:
+        return frame.data, GL.GL_BGR
+    elif fmt in OPENCV_FORMATS:
+        return opencv_decode_frame(frame)
+
+
+def maybe_frames(capture):
+    device = capture.device
+    selector = selectors.DefaultSelector()
+    selector.register(device, selectors.EVENT_READ)
+    stream = iter(capture)
+    try:
+        while True:
+            if selector.select(0):
+                frame = next(stream)
+                frame.user_data = decode_frame(frame)
+                yield frame
+            else:
+                yield None
+    finally:
+        selector.unregister(device)
+
+
+def device_text(text):
+    try:
+        return Device.from_id(int(text))
+    except ValueError:
+        return Device(text)
+
+
+def frame_size(text):
+    w, h = text.split("x", 1)
+    return int(w), int(h)
+
+
+def frame_format(text):
+    return PixelFormat[text]
+
+
+def cli():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--log-level", choices=["debug", "info", "warning", "error"], default="info")
+    parser.add_argument("--nb-buffers", type=int, default=2)
+    parser.add_argument("--frame-rate", type=float, default=10)
+    parser.add_argument("--frame-size", type=frame_size, default="640x480")
+    parser.add_argument("--frame-format", type=frame_format, default="RGB24")
+    parser.add_argument("device", type=device_text)
+    return parser
+
+
+def main(run, args=None):
+    parser = cli()
+    args = parser.parse_args(args=args)
+    fmt = "%(threadName)-10s %(asctime)-15s %(levelname)-5s %(name)s: %(message)s"
+    logging.basicConfig(level=args.log_level.upper(), format=fmt)
+    width, height = args.frame_size
+    aspect = height / width
+    try:
+        with args.device as device:
+            device.set_input(0)
+            capture = VideoCapture(device, size=args.nb_buffers)
+            capture.set_fps(args.frame_rate)
+            capture.set_format(width, height, args.frame_format)
+            fmt = capture.get_format()
+            window_width = 1980
+            window_height = int(window_width * aspect)
+            run(capture, fmt, window_width, window_height)
+    except KeyboardInterrupt:
+        logging.info("Ctrl-C pressed. Bailing out")

examples/video/gl/common_gl.py

@@ -0,0 +1,85 @@
+from OpenGL import GL
+
+TEXTURE_2D = GL.GL_TEXTURE_2D
+RGB = GL.GL_RGB
+UBYTE = GL.GL_UNSIGNED_BYTE
+
+
+def create_texture(width, height):
+    texture_id = GL.glGenTextures(1)
+    GL.glBindTexture(TEXTURE_2D, texture_id)
+    GL.glTexParameteri(TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR)
+    GL.glTexParameteri(TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR)
+    GL.glTexParameteri(TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE)
+    GL.glTexParameteri(TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE)
+    # Initial upload (use glTexImage2D only once)
+    GL.glTexImage2D(
+        TEXTURE_2D,
+        0,
+        RGB,
+        width,
+        height,
+        0,
+        RGB,
+        UBYTE,
+        None,
+    )
+    return texture_id
+
+
+def destroy_texture(texture_id):
+    GL.glDeleteTextures(1, [texture_id])
+
+
+def draw_canvas():
+    GL.glBegin(GL.GL_QUADS)
+    GL.glTexCoord2f(0.0, 1.0)
+    GL.glVertex3f(-1.0, -1.0, 0.0)
+
+    GL.glTexCoord2f(1.0, 1.0)
+    GL.glVertex3f(1.0, -1.0, 0.0)
+
+    GL.glTexCoord2f(1.0, 0.0)
+    GL.glVertex3f(1.0, 1.0, 0.0)
+
+    GL.glTexCoord2f(0.0, 0.0)
+    GL.glVertex3f(-1.0, 1.0, 0.0)
+    GL.glEnd()
+
+
+def update_texture(texture_id, frame):
+    data, format = frame.user_data
+    GL.glTextureSubImage2D(
+        texture_id,
+        0,
+        0,
+        0,
+        frame.width,
+        frame.height,
+        format,
+        UBYTE,
+        data,
+    )
+
+
+def init_gl():
+    GL.glEnable(TEXTURE_2D)
+
+
+class View:
+    def __init__(self):
+        self.texture = None
+
+    def __enter__(self):
+        init_gl()
+        return self
+
+    def render(self, frame):
+        if frame:
+            if self.texture is None:
+                self.texture = create_texture(frame.width, frame.height)
+            update_texture(self.texture, frame)
+        draw_canvas()
+
+    def __exit__(self, *args):
+        destroy_texture(self.texture)

examples/video/gl/common_glfw.py

@@ -0,0 +1,28 @@
+import glfw
+from common import maybe_frames
+
+
+class GLFWWindow:
+    def __init__(self, name, width, height):
+        self.name = name
+        self.width = width
+        self.height = height
+        self.win = None
+
+    def __enter__(self):
+        glfw.init()
+        self.win = glfw.create_window(self.width, self.height, self.name, None, None)
+        glfw.make_context_current(self.win)
+        return self
+
+    def __exit__(self, *args):
+        pass
+
+
+def frames(win, capture):
+    with capture:
+        stream = maybe_frames(capture)
+        while not glfw.window_should_close(win.win):
+            yield next(stream)
+            glfw.swap_buffers(win.win)
+            glfw.poll_events()

examples/video/gl/common_moderngl.py

@@ -0,0 +1,70 @@
+import struct
+
+import moderngl as mgl
+from OpenGL import GL
+
+VS = """
+#version 330 core
+in vec2 pos;
+in vec2 tex;
+out vec2 fragTex;
+
+void main() {
+    gl_Position = vec4(pos, 0.0, 1.0);
+    fragTex = tex;
+}
+"""
+
+FS = """
+#version 330 core
+in vec2 fragTex;
+out vec4 fragColor;
+uniform sampler2D texS;
+
+void main() {
+    fragColor = texture(texS, fragTex);
+}
+"""
+
+# point:2f uv:2f
+VERTICES = (-1, -1, 0, 1, 1, -1, 1, 1, 1, 1, 1, 0, -1, 1, 0, 0)
+
+
+def create_vertex_array(prog):
+    vertices = struct.pack("16f", *VERTICES)
+    vbo = prog.ctx.buffer(vertices)
+    return prog.ctx.vertex_array(prog, [(vbo, "2f 2f", "pos", "tex")])
+
+
+class View:
+    def __init__(self, width, height):
+        self.ctx = None
+        self.texture = None
+        self.width = width
+        self.height = height
+
+    def __enter__(self):
+        self.ctx = mgl.create_context()
+        self.ctx.enable(mgl.DEPTH_TEST)
+        self.ctx.viewport = (0, 0, self.width, self.height)
+        self.program = self.ctx.program(vertex_shader=VS, fragment_shader=FS)
+        self.vao = create_vertex_array(self.program)
+        return self
+
+    def render(self, frame):
+        self.ctx.clear(0, 0, 1, 1)
+        if frame:
+            if self.texture is None:
+                self.texture = self.ctx.texture((frame.width, frame.height), 3)
+            data, fmt = frame.user_data
+            self.texture.swizzle = "rgb1" if fmt == GL.GL_RGB else "bgr1"
+            self.texture.write(data)
+            self.texture.use()
+        self.vao.render(mgl.TRIANGLE_FAN)
+
+    def __exit__(self, *args):
+        if self.texture:
+            self.texture.release()
+            self.texture = None
+        self.vao.release()
+        self.program.release()

examples/video/gl/common_rgfw.py

@@ -0,0 +1,33 @@
+import RGFW
+from common import maybe_frames
+
+
+class RGFWWindow:
+    def __init__(self, name, width, height):
+        self.name = name
+        self.rect = RGFW.rect(0, 0, width, height)
+        self.win = None
+
+    def handle_events(self):
+        while self.win.checkEvent():
+            if self.win.event.type == RGFW.quit or RGFW.isPressed(self.win, RGFW.Escape):
+                return False
+        return True
+
+    def __enter__(self):
+        self.win = RGFW.createWindow(self.name, self.rect, RGFW.CENTER)
+        return self
+
+    def __exit__(self, *args):
+        self.win.close()
+        self.win = None
+
+
+def frames(win, capture):
+    with capture:
+        stream = maybe_frames(capture)
+        while True:
+            if not win.handle_events():
+                break
+            yield next(stream)
+            win.win.swapBuffers()

examples/video/gl/video_glfw_gl.py

@@ -0,0 +1,14 @@
+from common import main
+from common_gl import View
+from common_glfw import GLFWWindow, frames
+
+
+def run(capture, fmt, width, height):
+    with GLFWWindow("Video GLFW GL", width, height) as win:
+        with View() as view:
+            for frame in frames(win, capture):
+                view.render(frame)
+
+
+if __name__ == "__main__":
+    main(run)

examples/video/gl/video_glfw_moderngl.py

@@ -0,0 +1,14 @@
+from common import main
+from common_glfw import GLFWWindow, frames
+from common_moderngl import View
+
+
+def run(capture, fmt, width, height):
+    with GLFWWindow("Video GLFW GL", width, height) as win:
+        with View(width, height) as view:
+            for frame in frames(win, capture):
+                view.render(frame)
+
+
+if __name__ == "__main__":
+    main(run)

examples/video/gl/video_rgfw_gl.py

@@ -0,0 +1,14 @@
+from common import main
+from common_gl import View
+from common_rgfw import RGFWWindow, frames
+
+
+def run(capture, fmt, width, height):
+    with RGFWWindow("Video RGFW GL", width, height) as win:
+        with View() as view:
+            for frame in frames(win, capture):
+                view.render(frame)
+
+
+if __name__ == "__main__":
+    main(run)

examples/video/gl/video_rgfw_moderngl.py

@@ -0,0 +1,14 @@
+from common import main
+from common_moderngl import View
+from common_rgfw import RGFWWindow, frames
+
+
+def run(capture, fmt, width, height):
+    with RGFWWindow(f"RGFW ModernGL capture on {capture.device.filename}", width, height) as win:
+        with View(width, height) as view:
+            for frame in frames(win, capture):
+                view.render(frame)
+
+
+if __name__ == "__main__":
+    main(run)