yta-video-opengl 0.0.1__tar.gz → 0.0.2__tar.gz

{yta_video_opengl-0.0.1 → yta_video_opengl-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: yta-video-opengl
-Version: 0.0.1
+Version: 0.0.2
 Summary: Youtube Autonomous Video OpenGL Module
 Author: danialcala94
 Author-email: danielalcalavalera@gmail.com
@@ -13,6 +13,7 @@ Requires-Dist: moderngl (>=0.0.1,<9.0.0)
 Requires-Dist: numpy (>=0.0.1,<9.0.0)
 Requires-Dist: pillow (>=0.0.1,<19.0.0)
 Requires-Dist: yta_validation (>=0.0.1,<1.0.0)
+Requires-Dist: yta_video_frame_time (>=0.0.1,<1.0.0)
 Description-Content-Type: text/markdown
 
 # Youtube Autonomous Video OpenGL Module

{yta_video_opengl-0.0.1 → yta_video_opengl-0.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yta-video-opengl"
-version = "0.0.1"
+version = "0.0.2"
 description = "Youtube Autonomous Video OpenGL Module"
 authors = [
     {name = "danialcala94",email = "danielalcalavalera@gmail.com"}
@@ -9,6 +9,7 @@ readme = "README.md"
 requires-python = "==3.9"
 dependencies = [
     "yta_validation (>=0.0.1,<1.0.0)",
+    "yta_video_frame_time (>=0.0.1,<1.0.0)",
     "av (>=0.0.1,<19.0.0)",
     "moderngl (>=0.0.1,<9.0.0)",
     "glfw (>=0.0.1,<9.0.0)",

yta_video_opengl-0.0.2/src/yta_video_opengl/reader.py

@@ -0,0 +1,137 @@
+"""
+A video reader using the PyAv (av) library
+that, using ffmpeg, detects the video.
+"""
+from fractions import Fraction
+
+import av
+
+
+class VideoReader:
+    """
+    Class to read video files with the PyAv (av)
+    library that uses ffmpeg on the background.
+    """
+
+    @property
+    def frame_iterator(
+        self
+    ):
+        """
+        Iterator to iterate over all the video frames
+        decodified.
+        """
+        return self._container.decode(self._video_stream)
+    
+    @property
+    def next_frame(
+        self
+    ):
+        """
+        Get the next frame of the iterator.
+        """
+        return next(self.frame_iterator)
+    
+    @property
+    def fps(
+        self
+    ) -> Fraction:
+        """
+        The fps of the video.
+        """
+        # They return it as a Fraction but...
+        return self._video_stream.average_rate
+    
+    @property
+    def size(
+        self
+    ) -> tuple[int, int]:
+        """
+        The size of the video in a (width, height) format.
+        """
+        return (
+            self._video_stream.width,
+            self._video_stream.height
+        )
+    
+    @property
+    def width(
+        self
+    ) -> int:
+        """
+        The width of the video, in pixels.
+        """
+        return self.size[0]
+    
+    @property
+    def height(
+        self
+    ) -> int:
+        """
+        The height of the video, in pixels.
+        """
+        return self.size[1]
+    
+    # Any property related to audio has to
+    # start with 'audio_property_name'
+
+    def __init__(
+        self,
+        filename: str
+    ):
+        self.filename: str = filename
+        """
+        The filename of the video source.
+        """
+        self._container: av.InputContainer = av.open(filename)
+        """
+        The av input general container of the
+        video (that also includes the audio) we
+        are reading.
+        """
+        self._video_stream = self._container.streams.video[0]
+        """
+        The stream that includes the video.
+        """
+        self._video_stream.thread_type = "AUTO"
+        self._audio_stream = self._container.streams.audio[0]
+        """
+        The stream that includes the audio.
+        """
+        self._audio_stream.thread_type = "AUTO"
+
+
+
+
+"""
+Read this below if you can to combine videos
+that have not been written yet to the disk
+(maybe a composition in moviepy or I don't
+know).
+
+Usar un pipe (sin escribir archivo completo)
+Puedes lanzar un proceso FFmpeg que envíe el vídeo a PyAV por stdin como flujo sin codificar (por ejemplo en rawvideo), así no tienes que escribir el archivo final.
+Ejemplo:
+
+PYTHON_CODE:
+import subprocess
+import av
+
+# FFmpeg produce frames en crudo por stdout
+ffmpeg_proc = subprocess.Popen(
+    [
+        "ffmpeg",
+        "-i", "-",       # Lee de stdin
+        "-f", "rawvideo",
+        "-pix_fmt", "rgba",
+        "-"
+    ],
+    stdin=subprocess.PIPE,
+    stdout=subprocess.PIPE
+)
+
+# Aquí enviarías los datos combinados desde tu programa al ffmpeg_proc.stdin
+# y podrías leer con PyAV o directamente procesar arrays de píxeles
+
+Esto es lo más usado para pipeline de vídeo en tiempo real.
+"""

{yta_video_opengl-0.0.1 → yta_video_opengl-0.0.2}/src/yta_video_opengl/tests.py

@@ -3,14 +3,16 @@ Manual tests that are working and are interesting
 to learn about the code, refactor and build
 classes.
 """
+from yta_video_frame_time import T
+from PIL import Image
+
 import av
+# This 'glfw' is only needed to show in a window
 import glfw
 import moderngl
 import numpy as np
-from PIL import Image
 import time
 
-
 def video_modified_displayed_on_window():
     # -------- CONFIG --------
     VIDEO_PATH = "test_files/test_1.mp4"  # Cambia por tu vídeo
@@ -74,6 +76,7 @@ def video_modified_displayed_on_window():
     # Abrir vídeo con PyAV
     container = av.open(VIDEO_PATH)
     stream = container.streams.video[0]
+    fps = stream.average_rate
     stream.thread_type = "AUTO"
 
     # Decodificar primer frame para crear textura
@@ -87,17 +90,23 @@ def video_modified_displayed_on_window():
     prog['freq'].value = FREQ
     prog['speed'].value = SPEED
 
-    start_time = time.time()
-
     # Render loop
+    frame_index = 0
+    start_time = time.time()
     frame_iter = container.decode(stream)
     for frame in frame_iter:
         if glfw.window_should_close(window):
             break
 
-        # Tiempo
-        t = time.time() - start_time
-        prog['time'].value = t
+        # Time
+        """
+        When showing in the window the frames are very
+        slow if using the T, thats why I'm using the
+        time, but still not very fast... I think it
+        depends on my GPU.
+        """
+        prog['time'].value = time.time() - start_time
+        #prog['time'].value = T.video_frame_index_to_video_frame_time(frame_index, float(fps))
 
         # Convertir frame a textura
         img = frame.to_image().transpose(Image.FLIP_TOP_BOTTOM).convert("RGB")
@@ -110,6 +119,8 @@ def video_modified_displayed_on_window():
         glfw.swap_buffers(window)
         glfw.poll_events()
 
+        frame_index += 1
+
     glfw.terminate()
 
 def video_modified_stored():
@@ -161,21 +172,29 @@ def video_modified_stored():
     vbo = ctx.buffer(vertices.tobytes())
     vao = ctx.simple_vertex_array(prog, vbo, 'in_pos', 'in_uv')
 
-    # Abrir vídeo de entrada
-    container = av.open(VIDEO_PATH)
-    stream = container.streams.video[0]
-    fps = stream.average_rate
-    width = stream.width
-    height = stream.height
+    from yta_video_opengl.reader import VideoReader
+    from yta_video_opengl.writer import VideoWriter
+    video = VideoReader(VIDEO_PATH)
 
     # Framebuffer para renderizar
-    fbo = ctx.simple_framebuffer((width, height))
+    fbo = ctx.simple_framebuffer(video.size)
     fbo.use()
 
     # Decodificar primer frame y crear textura
-    first_frame = next(container.decode(stream))
-    img = first_frame.to_image().transpose(Image.FLIP_TOP_BOTTOM).convert("RGB")
-    tex = ctx.texture(img.size, 3, img.tobytes())
+    first_frame = video.next_frame
+
+    # This below is with numpy
+    # Most of OpenGL textures expect origin in lower
+    # left corner
+    # TODO: What if alpha (?)
+    image = np.flipud(first_frame.to_ndarray(format = "rgb24"))
+    tex = ctx.texture((image.shape[1], image.shape[0]), 3, image.tobytes())
+
+    # # This below is with Pillow
+    # # TODO: Why not to ndarray? It's faster
+    # img = first_frame.to_image().transpose(Image.FLIP_TOP_BOTTOM).convert("RGB")
+    # tex = ctx.texture(img.size, 3, img.tobytes())
+
     tex.build_mipmaps()
 
     # Uniforms
@@ -184,20 +203,27 @@ def video_modified_stored():
     prog['speed'].value = SPEED
 
     # Abrir salida con PyAV (codificador H.264)
-    output = av.open(OUTPUT_PATH, mode='w')
-    out_stream = output.add_stream("libx264", rate=fps)
-    out_stream.width = width
-    out_stream.height = height
-    out_stream.pix_fmt = "yuv420p"
+    video_writer = VideoWriter(OUTPUT_PATH, video.fps, video.size, 'yuv420p')
+    output_stream = video_writer._stream
 
-    start_time = time.time()
+    frame_index = 0
+    
+    for frame in video.frame_iterator:
+        prog['time'].value = T.video_frame_index_to_video_frame_time(frame_index, float(video.fps))
+
+        # This below is with numpy
+        # To numpy array and flip to OpenGL coordinates
+        img_array = np.flipud(
+            frame.to_ndarray(format = "rgb24")
+        )
 
-    for frame in container.decode(stream):
-        t = time.time() - start_time
-        prog['time'].value = t
+        # Subir a textura
+        tex = ctx.texture((img_array.shape[1], img_array.shape[0]), 3, img_array.tobytes())
 
+        # This bellow is with Pillow
         # Subir frame a textura
         img = frame.to_image().transpose(Image.FLIP_TOP_BOTTOM).convert("RGB")
+
         tex.write(img.tobytes())
 
         # Renderizar con shader al framebuffer
@@ -206,19 +232,31 @@ def video_modified_stored():
         vao.render(moderngl.TRIANGLE_STRIP)
 
         # Leer píxeles del framebuffer
-        data = fbo.read(components=3, alignment=1)
-        img_out = Image.frombytes("RGB", (width, height), data).transpose(Image.FLIP_TOP_BOTTOM)
-
-        # Convertir a frame de PyAV y escribir
-        video_frame = av.VideoFrame.from_image(img_out)
-        packet = out_stream.encode(video_frame)
+        data = fbo.read(components = 3, alignment = 1)
+
+        # To numpy array and flip to OpenGL coordinates
+        img_out = np.flipud(
+            np.frombuffer(data, dtype = np.uint8).reshape((video.height, video.width, 3))
+        )
+        # Turn into a frame
+        video_frame = av.VideoFrame.from_ndarray(img_out)
+
+        # # This below is with Pillow
+        # img_out = Image.frombytes("RGB", video.size, data).transpose(Image.FLIP_TOP_BOTTOM)
+        # # Trn into a frame
+        # video_frame = av.VideoFrame.from_image(img_out)
+
+        # Write
+        packet = output_stream.encode(video_frame)
         if packet:
-            output.mux(packet)
+            video_writer._output.mux(packet)
+
+        frame_index += 1
 
     # Vaciar buffers de codificación
-    packet = out_stream.encode(None)
+    packet = output_stream.encode(None)
     if packet:
-        output.mux(packet)
+        video_writer._output.mux(packet)
 
-    output.close()
+    video_writer._output.close()
     print(f"Vídeo guardado en {OUTPUT_PATH}")

yta_video_opengl-0.0.2/src/yta_video_opengl/writer.py

@@ -0,0 +1,28 @@
+from av.stream import Stream
+from av import open as av_open
+
+
+class VideoWriter:
+    """
+    Class to write video files with the PyAv (av)
+    library that uses ffmpeg on the background.
+    """
+
+    def __init__(
+        self,
+        filename: str,
+        fps: float,
+        size: tuple[int, int],
+        pixel_format: str = 'yuv420p'
+    ):
+        self.filename: str = filename
+        """
+        The filename we want to use to save the video
+        file.
+        """
+        # TODO: What about this 'libx264' (?)
+        self._output = av_open(filename, mode = 'w')
+        self._stream: Stream = self._output.add_stream("libx264", rate = fps)
+        self._stream.width = size[0]
+        self._stream.height = size[1]
+        self._stream.pix_fmt = pixel_format