yta-video-opengl 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

yta_video_opengl/__init__.py

@@ -2,9 +2,8 @@
 Module to include video handling with OpenGL.
 """
 def main():
-    from yta_video_opengl.tests import video_modified_displayed_on_window, video_modified_stored
+    from yta_video_opengl.tests import video_modified_stored
 
-    #video_modified_displayed_on_window()
     video_modified_stored()
 
 

yta_video_opengl/reader.py

@@ -0,0 +1,295 @@
+"""
+A video reader using the PyAv (av) library
+that, using ffmpeg, detects the video.
+"""
+from yta_validation import PythonValidator
+from av.video.frame import VideoFrame
+from av.audio.frame import AudioFrame
+from av.packet import Packet
+from av.video.stream import VideoStream
+from av.audio.stream import AudioStream
+from av.container.input import InputContainer
+from fractions import Fraction
+from av import open as av_open
+from typing import Union
+
+
+class VideoReaderFrame:
+    """
+    Class to wrap a frame of a video that is
+    being read, that can be a video or audio
+    frame.
+    """
+
+    @property
+    def is_packet(
+        self
+    ) -> bool:
+        """
+        Flag to indicate if the frame is actually
+        a packet of frames.
+        """
+        return PythonValidator.is_instance_of(self.frame, Packet)
+
+    @property
+    def is_video_frame(
+        self
+    ):
+        """
+        Flag to indicate if the instance is a video
+        frame.
+        """
+        return PythonValidator.is_instance_of(self.frame, VideoFrame)
+    
+    @property
+    def is_audio_frame(
+        self
+    ):
+        """
+        Flag to indicate if the instance is an audio
+        frame.
+        """
+        return PythonValidator.is_instance_of(self.frame, AudioFrame)
+    
+    @property
+    def is_video_packet(
+        self
+    ) -> bool:
+        """
+        Flag to indicate if the instance is a packet
+        containing video frames.
+        """
+        return (
+            self.is_packet and
+            self.frame.stream.type == 'video'
+        )
+
+    @property
+    def is_audio_packet(
+        self
+    ) -> bool:
+        """
+        Flag to indicate if the instance is a packet
+        containing audio frames.
+        """
+        return (
+            self.is_packet and
+            self.frame.stream.type == 'audio'
+        )
+    
+    def __init__(
+        self,
+        # TODO: Add the type, please
+        frame: any
+    ):
+        self.frame: Union[AudioFrame, VideoFrame, Packet] = frame
+        """
+        The frame content, that can be audio or video
+        frame, or a packet of more than one frame.
+        """
+
+    def test():
+        # If packet we need to do this (if we want)
+        # to decode
+        #for frame in packet.decode():
+        
+        # In the output we need to 'mux' packets,
+        # always
+        pass
+
+    # The '.decode()' generates a list of Packet
+    # The '.encode()' receives a list of Packet
+    # The '.demux()' extract packets from a single input
+    # The '.mux()' mix packets into a single output
+        
+
+class VideoReader:
+    """
+    Class to read video files with the PyAv (av)
+    library that uses ffmpeg on the background.
+    """
+
+    @property
+    def frame_iterator(
+        self
+    ) -> 'Iterator[VideoFrame]':
+        """
+        Iterator to iterate over all the video frames
+        decodified.
+        """
+        return self.container.decode(self.video_stream)
+    
+    @property
+    def next_frame(
+        self
+    ) -> Union[VideoFrame, None]:
+        """
+        Get the next frame of the iterator.
+        """
+        return next(self.frame_iterator)
+    
+    # TODO: Maybe rename (?)
+    @property
+    def frame_with_audio_iterator(
+        self
+    ) -> 'Iterator[Packet]':
+        """
+        Iterator to iterate over all the video frames
+        decodified, including also the audio.
+        """
+        return self.container.demux((self.video_stream, self.audio_stream))
+
+    @property
+    def next_frame_with_audio(
+        self
+    ) -> Union[Packet, None]:
+        """
+        Get the next frame of the iterator that includes
+        the audio.
+        """
+        return next(self.frame_with_audio_iterator)
+
+    @property
+    def codec_name(
+        self
+    ) -> str:
+        """
+        Get the name of the video codec.
+        """
+        return self.video_stream.codec_context.name
+    
+    @property
+    def audio_codec_name(
+        self
+    ) -> str:
+        """
+        Get the name of the audio codec.
+        """
+        return self.audio_stream.codec_context.name
+    
+    @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 audio_fps(
+        self
+    ) -> Fraction:
+        """
+        The fps of the audio.
+        """
+        # TODO: What if no audio (?)
+        return self.audio_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: InputContainer = av_open(filename)
+        """
+        The av input general container of the
+        video (that also includes the audio) we
+        are reading.
+        """
+        self.video_stream: VideoStream = self.container.streams.video[0]
+        """
+        The stream that includes the video.
+        """
+        self.video_stream.thread_type = 'AUTO'
+        # TODO: What if no audio (?)
+        self.audio_stream: AudioStream = self.container.streams.audio[0]
+        """
+        The stream that includes the audio.
+        """
+        self.audio_stream.thread_type = 'AUTO'
+
+    def iterate(
+        self
+    ):
+        for frame in self.frame_iterator:
+            yield VideoReaderFrame(frame)
+
+    def iterate_with_audio(
+        self
+    ):
+        for frame_or_packet in self.frame_with_audio_iterator:
+            yield VideoReaderFrame(frame_or_packet)
+
+
+
+
+"""
+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/tests.py

@@ -3,114 +3,15 @@ Manual tests that are working and are interesting
 to learn about the code, refactor and build
 classes.
 """
+from yta_video_opengl.reader import VideoReader
+from yta_video_opengl.writer import VideoWriter
+from yta_timer import Timer
+from yta_video_frame_time import T
+
 import av
-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
-    AMP = 0.05
-    FREQ = 10.0
-    SPEED = 2.0
-    # ------------------------
-
-    # Inicializar ventana GLFW
-    if not glfw.init():
-        raise RuntimeError("No se pudo inicializar GLFW")
 
-    window = glfw.create_window(1280, 720, "Wave Shader Python", None, None)
-    if not window:
-        glfw.terminate()
-        raise RuntimeError("No se pudo crear ventana GLFW")
-
-    glfw.make_context_current(window)
-    ctx = moderngl.create_context()
-
-    # Shader GLSL
-    prog = ctx.program(
-        vertex_shader='''
-        #version 330
-        in vec2 in_pos;
-        in vec2 in_uv;
-        out vec2 v_uv;
-        void main() {
-            v_uv = in_uv;
-            gl_Position = vec4(in_pos, 0.0, 1.0);
-        }
-        ''',
-        fragment_shader='''
-        #version 330
-        uniform sampler2D tex;
-        uniform float time;
-        uniform float amp;
-        uniform float freq;
-        uniform float speed;
-        in vec2 v_uv;
-        out vec4 f_color;
-        void main() {
-            float wave = sin(v_uv.x * freq + time * speed) * amp;
-            vec2 uv = vec2(v_uv.x, v_uv.y + wave);
-            f_color = texture(tex, uv);
-        }
-        '''
-    )
-
-    # Cuadrado a pantalla completa
-    vertices = np.array([
-        -1, -1, 0.0, 0.0,
-        1, -1, 1.0, 0.0,
-        -1,  1, 0.0, 1.0,
-        1,  1, 1.0, 1.0,
-    ], dtype='f4')
-
-    vbo = ctx.buffer(vertices.tobytes())
-    vao = ctx.simple_vertex_array(prog, vbo, 'in_pos', 'in_uv')
-
-    # Abrir vídeo con PyAV
-    container = av.open(VIDEO_PATH)
-    stream = container.streams.video[0]
-    stream.thread_type = "AUTO"
-
-    # Decodificar primer frame para 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())
-    tex.build_mipmaps()
-
-    # Uniforms fijos
-    prog['amp'].value = AMP
-    prog['freq'].value = FREQ
-    prog['speed'].value = SPEED
-
-    start_time = time.time()
-
-    # Render loop
-    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
-
-        # Convertir frame a textura
-        img = frame.to_image().transpose(Image.FLIP_TOP_BOTTOM).convert("RGB")
-        tex.write(img.tobytes())
-
-        # Dibujar
-        ctx.clear(0.1, 0.1, 0.1)
-        tex.use()
-        vao.render(moderngl.TRIANGLE_STRIP)
-        glfw.swap_buffers(window)
-        glfw.poll_events()
-
-    glfw.terminate()
 
 def video_modified_stored():
     VIDEO_PATH = "test_files/test_1.mp4"
@@ -119,12 +20,12 @@ def video_modified_stored():
     FREQ = 10.0
     SPEED = 2.0
 
-    # Crear contexto ModernGL sin ventana
-    ctx = moderngl.create_standalone_context()
+    # ModernGL context without window
+    context = moderngl.create_standalone_context()
 
-    # Shader de onda
-    prog = ctx.program(
-        vertex_shader='''
+    # Wave shader vertex and fragment
+    program = context.program(
+        vertex_shader = '''
         #version 330
         in vec2 in_pos;
         in vec2 in_uv;
@@ -134,7 +35,7 @@ def video_modified_stored():
             gl_Position = vec4(in_pos, 0.0, 1.0);
         }
         ''',
-        fragment_shader='''
+        fragment_shader = '''
         #version 330
         uniform sampler2D tex;
         uniform float time;
@@ -157,68 +58,210 @@ def video_modified_stored():
         1, -1, 1.0, 0.0,
         -1,  1, 0.0, 1.0,
         1,  1, 1.0, 1.0,
-    ], dtype='f4')
-    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
-
-    # Framebuffer para renderizar
-    fbo = ctx.simple_framebuffer((width, height))
+    ], dtype = 'f4')
+    vbo = context.buffer(vertices.tobytes())
+    vao = context.simple_vertex_array(program, vbo, 'in_pos', 'in_uv')
+
+    video = VideoReader(VIDEO_PATH)
+
+    # TODO: This has to be dynamic, but
+    # according to what (?)
+    NUMPY_FORMAT = 'rgb24'
+    # TODO: Where do we obtain this from (?)
+    VIDEO_CODEC_NAME = 'libx264'
+    # TODO: Where do we obtain this from (?)
+    PIXEL_FORMAT = 'yuv420p'
+
+    # Framebuffer to render
+    fbo = context.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())
-    tex.build_mipmaps()
+    # Decode first frame and use as texture
+    first_frame = video.next_frame
+
+    # Most of OpenGL textures expect origin in lower
+    # left corner
+    # TODO: What if alpha (?)
+    image = np.flipud(first_frame.to_ndarray(format = NUMPY_FORMAT))
+    texture = context.texture((image.shape[1], image.shape[0]), 3, image.tobytes())
+
+    texture.build_mipmaps()
 
     # Uniforms
-    prog['amp'].value = AMP
-    prog['freq'].value = FREQ
-    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"
-
-    start_time = time.time()
-
-    for frame in container.decode(stream):
-        t = time.time() - start_time
-        prog['time'].value = t
-
-        # Subir frame a textura
-        img = frame.to_image().transpose(Image.FLIP_TOP_BOTTOM).convert("RGB")
-        tex.write(img.tobytes())
-
-        # Renderizar con shader al framebuffer
-        fbo.clear(0.0, 0.0, 0.0)
-        tex.use()
-        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)
-        if packet:
-            output.mux(packet)
-
-    # Vaciar buffers de codificación
-    packet = out_stream.encode(None)
-    if packet:
-        output.mux(packet)
-
-    output.close()
-    print(f"Vídeo guardado en {OUTPUT_PATH}")
+    program['amp'].value = AMP
+    program['freq'].value = FREQ
+    program['speed'].value = SPEED
+
+    # Writer with H.264 codec
+    video_writer = (
+        VideoWriter(OUTPUT_PATH)
+        .set_video_stream(VIDEO_CODEC_NAME, video.fps, video.size, PIXEL_FORMAT)
+        .set_audio_stream_from_template(video.audio_stream)
+    )
+
+    frame_index = 0
+    # for frame in video.frame_iterator:
+    #     with Timer(is_silent_as_context = True) as timer:
+    #         program['time'].value = T.video_frame_index_to_video_frame_time(frame_index, float(video.fps))
+
+    #         # To numpy array and flip to OpenGL coordinates
+    #         image_array = np.flipud(
+    #             frame.to_ndarray(format = 'rgb24')
+    #         )
+
+    #         # Create texture
+    #         texture = context.texture((image_array.shape[1], image_array.shape[0]), 3, image_array.tobytes())
+    #         # Add frame to texture
+    #         image = frame.to_image().transpose(Image.FLIP_TOP_BOTTOM).convert('RGB')
+    #         texture.write(image.tobytes())
+
+    #         # Render to framebuffer with shader
+    #         fbo.clear(0.0, 0.0, 0.0)
+    #         texture.use()
+    #         vao.render(moderngl.TRIANGLE_STRIP)
+
+    #         # Read pixels from framebuffer
+    #         data = fbo.read(components = 3, alignment = 1)
+
+    #         # To numpy array and flip from OpenGL coordinates
+    #         image_output = np.flipud(
+    #             np.frombuffer(data, dtype = np.uint8).reshape((video.height, video.width, 3))
+    #         )
+    #         # Turn into a frame
+    #         video_frame = av.VideoFrame.from_ndarray(image_output, format = 'rgb24')
+
+    #         # Write
+    #         packet = video_writer.stream.encode(video_frame)
+    #         if packet:
+    #             video_writer.output.mux(packet)
+
+    #         print(f'Frame {str(frame_index)}: {timer.time_elapsed_str}s')
+
+    #         frame_index += 1
+
+    # # Empty codification buffers
+    # packet = video_writer.stream.encode(None)
+    # if packet:
+    #     video_writer.output.mux(packet)
+
+    # # This below is the main workflow with frames
+    # # and packets when processing a video
+    # do_process_video: bool = False
+    # do_process_audio: bool = False
+    # for frame_or_packet in video.iterate_with_audio():
+    #     if frame_or_packet.is_video_frame:
+    #         if do_process_video:
+    #             # If we are processing it, we need to decode
+    #             frame_decoded = frame_or_packet.decode()
+    #         else:
+    #             # if we are not processing it, just copy
+    #             # video_writer.output.mux(frame_or_packet)
+    #             pass
+    #     elif frame_or_packet.is_audio_frame:
+    #         if do_process_audio:
+    #             # If we are processing it, we need to decode
+    #             frame_decoded = frame_or_packet.decode()
+    #         else:
+    #             # if we are not processing it, just copy
+    #             # video_writer.output.mux(frame_or_packet)
+    #             pass
+    #     elif frame_or_packet.is_video_packet:
+    #         if do_process_video:
+    #             # If we are processing it, we need to decode
+    #             # the packet, that will give us an array of
+    #             # frames
+    #             for frame_decoded in frame_or_packet.decode():
+    #                 pass
+    #         else:
+    #             # If we are not processing it, just copy
+    #             # video_writer.output.mux(packet)
+    #             pass
+    #     elif frame_or_packet.is_audio_packet:
+    #         if do_process_audio:
+    #             # If we are processing it, we need to decode
+    #             # the packet, that will give us an array of
+    #             # frames
+    #             for frame_decoded in frame_or_packet.decode():
+    #                 pass
+    #         else:
+    #             # If we are not processing it, just copy
+    #             # video_writer.output.mux(packet)
+    #             pass
+
+    
+    for packet in video.frame_with_audio_iterator:
+        # The frames don't come in a specific order.
+        # In this specific case we receive 1 or 2
+        # video frames per each audio frame, but
+        # they come always ordered.
+        if packet.stream.type == 'video':
+            for frame in packet.decode():
+                with Timer(is_silent_as_context = True) as timer:
+                    # Add some variables if we need, for the
+                    # opengl change we are applying (check the
+                    # program code)
+                    program['time'].value = T.video_frame_index_to_video_frame_time(frame_index, float(video.fps))
+                    
+                    
+                    # To numpy RGB inverted for OpenGL
+                    img_array = np.flipud(
+                        frame.to_ndarray(format = NUMPY_FORMAT)
+                    )
+
+                    # Create texture
+                    texture = context.texture((img_array.shape[1], img_array.shape[0]), 3, img_array.tobytes())
+                    texture.use()
+
+                    # Render with shader to frame buffer
+                    fbo.use()
+                    vao.render(moderngl.TRIANGLE_STRIP)
+
+                    # Processed GPU result to numpy
+                    processed_data = np.frombuffer(
+                        fbo.read(components = 3, alignment = 1), dtype = np.uint8
+                    )
+                    # Invert numpy to normal frame
+                    processed_data = np.flipud(
+                        processed_data.reshape((img_array.shape[0], img_array.shape[1], 3))
+                    )
+
+                    # To VideoFrame and to buffer
+                    out_frame = av.VideoFrame.from_ndarray(processed_data, format = NUMPY_FORMAT)
+                    # TODO: What is this for (?)
+                    #out_frame.pict_type = 'NONE'
+
+                    for v_packet in video_writer.video_stream.encode(out_frame):
+                        # Check that the packet received is not the
+                        # one that indicates the end (that must not
+                        # be passed to the mux)
+                        if v_packet.size > 0:
+                            video_writer.output.mux(v_packet)
+
+                    frame_index += 1
+                print(f'Frame {str(frame_index)}: {timer.time_elapsed_str}s')
+
+        elif packet.stream.type == "audio":
+            print('-- AUDIO --')
+            # Check that the packet received is not the
+            # one that indicates the end (that must not
+            # be passed to the mux)
+            if packet.size > 0:
+                # Copy audio as it is
+                video_writer.output.mux(packet)
+
+    # Empty buffers
+    # This '.encode()' with no params will tell the
+    # encoder that you will not send more packets, 
+    # so it can process the remaining ones, that
+    # are the ones obtained in the 'packet' var.
+    # While this code can be finished, the work in
+    # the muxer could be not finished and have some
+    # packets waiting to be written. Here we tell
+    # the muxer to process all those packets.
+    for packet in video_writer.video_stream.encode():
+        video_writer.output.mux(packet)
+
+    # TODO: Maybe move this to the '__del__' (?)
+    video_writer.output.close()
+    video.container.close()
+    print(f'Saved as "{OUTPUT_PATH}".')

yta_video_opengl/writer.py

@@ -0,0 +1,107 @@
+from av.stream import Stream
+from av.video.stream import VideoStream
+from av.audio.stream import AudioStream
+from av.container.output import OutputContainer
+from av import open as av_open
+from fractions import Fraction
+from typing import Union
+
+
+class VideoWriter:
+    """
+    Class to write video files with the PyAv (av)
+    library that uses ffmpeg on the background.
+    """
+
+    def __init__(
+        self,
+        filename: str,
+    ):
+        self.filename: str = filename
+        """
+        The filename we want to use to save the video
+        file.
+        """
+        # TODO: What about this 'libx264' (?)
+        self.output: OutputContainer = av_open(filename, mode = 'w')
+        """
+        An OutputContainer to control the writing process.
+        """
+        self.video_stream: VideoStream = None
+        """
+        The video stream.
+        """
+        self.audio_stream: AudioStream = None
+        """
+        The audio stream.
+        """
+
+    def set_video_stream(
+        self,
+        codec_name: Union[str, None],
+        fps: Union[Fraction, int, float, None],
+        size: Union[tuple[int, int], None] = None,
+        pixel_format: Union[str, None] = None,
+        options: Union[dict[str, str], None] = None
+    ) -> 'VideoWriter':
+        """
+        Set the video stream, that will overwrite any other
+        previous video stream set.
+        """
+        self.video_stream: VideoStream = self.output.add_stream(
+            # TODO: Maybe 'libx264' as default 'codec_name' (?)
+            codec_name = codec_name,
+            rate = fps,
+            options = options
+        )
+
+        if size is not None:
+            self.video_stream.width = size[0]
+            self.video_stream.height = size[1]
+
+        if pixel_format is not None:
+            # TODO: Maybe 'yuv420p' as default 'pixel_format' (?)
+            self.video_stream.pix_fmt = pixel_format
+
+        return self
+
+    # TODO: Maybe 'add_video_stream_from_template' (?)
+
+    def set_audio_stream(
+        self,
+        codec_name: Union[str, None]
+        # TODO: Add more if needed
+    ) -> 'VideoWriter':
+        """
+        Set the audio stream, that will overwrite any other
+        previous audio stream set.
+        """
+        self.audio_stream: AudioStream = self.output.add_stream(
+            codec_name = codec_name
+        )
+
+        # TODO: Add more if needed
+
+        return self
+
+    def set_audio_stream_from_template(
+        self,
+        template: Stream
+    ) -> 'VideoWriter':
+        """
+        Set the audio stream, that will overwrite any other
+        previous audio stream set.
+
+        You can pass the audio stream as it was
+        obtained from the reader.
+        """
+        self.audio_stream: AudioStream = self.output.add_stream_from_template(
+            template
+        )
+
+        return self
+
+"""
+# TODO: Check 'https://www.youtube.com/watch?v=OlNWCpFdVMA'
+# for ffmpeg with mp3 access
+"""

{yta_video_opengl-0.0.1.dist-info → yta_video_opengl-0.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: yta-video-opengl
-Version: 0.0.1
+Version: 0.0.3
 Summary: Youtube Autonomous Video OpenGL Module
 Author: danialcala94
 Author-email: danielalcalavalera@gmail.com
@@ -8,11 +8,11 @@ Requires-Python: ==3.9
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Requires-Dist: av (>=0.0.1,<19.0.0)
-Requires-Dist: glfw (>=0.0.1,<9.0.0)
 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_timer (>0.0.1,<1.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.3.dist-info/RECORD

@@ -0,0 +1,8 @@
+yta_video_opengl/__init__.py,sha256=ycAx_XYMVDfkuObSvtW6irQ0Wo-fgxEz3fjIRMe8PpY,205
+yta_video_opengl/reader.py,sha256=ffq_mliXUjz8N7_ZOoX97P2wTDeMjW2rhGceqItCvtM,7394
+yta_video_opengl/tests.py,sha256=MLLpIVtdAA1L7ZpaZE6AH5gUJpiPxmvg-pktUcubOmw,10015
+yta_video_opengl/writer.py,sha256=dSlzUvyuQsZvghs8-7QASVvejBtm1ysv4V84quNB9Sw,3033
+yta_video_opengl-0.0.3.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+yta_video_opengl-0.0.3.dist-info/METADATA,sha256=Om_IJ8JtdlnUATEkxVPTfO8Fs1eiDqVszPHsEnqZfj4,670
+yta_video_opengl-0.0.3.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+yta_video_opengl-0.0.3.dist-info/RECORD,,

yta_video_opengl-0.0.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-yta_video_opengl/__init__.py,sha256=Xb1dwLlYPh_sttMNyKsuP81ie5RXhuQf6AM_XvsUuWE,284
-yta_video_opengl/tests.py,sha256=INSGzF7EcYqtUdN4SN39KOmXsAME4Sg7eJFbMmfmXx4,6292
-yta_video_opengl-0.0.1.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-yta_video_opengl-0.0.1.dist-info/METADATA,sha256=W4DX2yB9bfprIBGH-wgd2B0CM8N6dZlupkkkkKtIirY,653
-yta_video_opengl-0.0.1.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-yta_video_opengl-0.0.1.dist-info/RECORD,,