yta-video-opengl 0.0.2__py3-none-any.whl → 0.0.4__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

@@ -2,10 +2,105 @@
 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
+from dataclasses import dataclass
 
-import av
 
+@dataclass
+class VideoReaderFrame:
+    """
+    Class to wrap a frame of a video that is
+    being read, that can be a video or audio
+    frame, and has been decoded.
+    """
+
+    @property
+    def is_video(
+        self
+    ):
+        """
+        Flag to indicate if the instance is a video
+        frame.
+        """
+        return PythonValidator.is_instance_of(self.data, VideoFrame)
+    
+    @property
+    def is_audio(
+        self
+    ):
+        """
+        Flag to indicate if the instance is an audio
+        frame.
+        """
+        return PythonValidator.is_instance_of(self.data, AudioFrame)
+    
+    def __init__(
+        self,
+        # TODO: Add the type, please
+        data: any
+    ):
+        self.data: Union[AudioFrame, VideoFrame] = data
+        """
+        The frame content, that can be audio or video
+        frame.
+        """
+
+@dataclass
+class VideoReaderPacket:
+    """
+    Class to wrap a packet of a video that is
+    being read, that can contain video or audio
+    frames.
+    """
+
+    @property
+    def is_video(
+        self
+    ) -> bool:
+        """
+        Flag to indicate if the packet includes video
+        frames or not.
+        """
+        return self.data.stream.type == 'video'
+    
+    @property
+    def is_audio(
+        self
+    ) -> bool:
+        """
+        Flag to indicate if the packet includes audio
+        frames or not.
+        """
+        return self.data.stream.type == 'audio'
+
+    def __init__(
+        self,
+        data: Packet
+    ):
+        self.data: Packet = data
+        """
+        The packet, that can include video or audio
+        frames and can be decoded.
+        """
+
+    def decode(
+        self
+    ) -> list['SubtitleSet']:
+        """
+        Get the frames but decoded, perfect to make
+        modifications and encode to save them again.
+        """
+        return self.data.decode()
+        
 
 class VideoReader:
     """
@@ -16,21 +111,141 @@ class VideoReader:
     @property
     def frame_iterator(
         self
-    ):
+    ) -> 'Iterator[VideoFrame]':
         """
         Iterator to iterate over all the video frames
         decodified.
         """
-        return self._container.decode(self._video_stream)
+        return self.container.decode(self.video_stream)
     
     @property
     def next_frame(
         self
-    ):
+    ) -> Union[VideoFrame, None]:
         """
-        Get the next frame of the iterator.
+        Get the next video frame (decoded) from the
+        iterator.
         """
         return next(self.frame_iterator)
+
+    @property
+    def audio_frame_iterator(
+        self
+    ) -> 'Iterator[AudioFrame]':
+        """
+        Iterator to iterate over all the audio frames
+        decodified.
+        """
+        return self.container.decode(self.audio_stream)
+        
+    @property
+    def next_audio_frame(
+        self
+    ) -> Union[AudioFrame, None]:
+        """
+        Get the next audio frame (decoded) from the
+        iterator.
+        """
+        return next(self.audio_frame_iterator)
+    
+    @property
+    def packet_iterator(
+        self
+    ) -> 'Iterator[Packet]':
+        """
+        Iterator to iterate over all the video frames
+        as packets (not decodified).
+        """
+        return self.container.demux(self.video_stream)
+    
+    @property
+    def next_packet(
+        self
+    ) -> Union[Packet, None]:
+        """
+        Get the next video packet (not decoded) from
+        the iterator.
+        """
+        return next(self.packet_iterator)
+    
+    @property
+    def audio_packet_iterator(
+        self
+    ) -> 'Iterator[Packet]':
+        """
+        Iterator to iterate over all the audio frames
+        as packets (not decodified).
+        """
+        return self.container.demux(self.audio_stream)
+    
+    @property
+    def next_audio_packet(
+        self
+    ) -> Union[Packet, None]:
+        """
+        Get the next audio packet (not decoded) from
+        the iterator.
+        """
+        return next(self.packet_iterator)
+    
+    @property
+    def packet_with_audio_iterator(
+        self
+    ) -> 'Iterator[Packet]':
+        """
+        Iterator to iterate over all the video frames
+        as packets (not decodified) including also the
+        audio as packets.
+        """
+        return self.container.demux((self.video_stream, self.audio_stream))
+
+    @property
+    def next_packet_with_audio(
+        self
+    ) -> Union[Packet, None]:
+        """
+        Get the next video frames packet (or audio
+        frames packet) from the iterator. Depending
+        on the position, the packet can be video or
+        audio.
+        """
+        return next(self.packet_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 number_of_frames(
+        self
+    ) -> int:
+        """
+        The number of frames in the video.
+        """
+        return self.video_stream.frames
+    
+    @property
+    def number_of_audio_frames(
+        self
+    ) -> int:
+        """
+        The number of frames in the audio.
+        """
+        return self.audio_stream.frames
     
     @property
     def fps(
@@ -40,7 +255,17 @@ class VideoReader:
         The fps of the video.
         """
         # They return it as a Fraction but...
-        return self._video_stream.average_rate
+        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(
@@ -50,8 +275,8 @@ class VideoReader:
         The size of the video in a (width, height) format.
         """
         return (
-            self._video_stream.width,
-            self._video_stream.height
+            self.video_stream.width,
+            self.video_stream.height
         )
     
     @property
@@ -83,22 +308,79 @@ class VideoReader:
         """
         The filename of the video source.
         """
-        self._container: av.InputContainer = av.open(filename)
+        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 = self._container.streams.video[0]
+        self.video_stream: VideoStream = 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]
+        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"
+        self.audio_stream.thread_type = 'AUTO'
+
+    def iterate(
+        self
+    ) -> 'Iterator[Union[VideoFrame, AudioFrame]]':
+        """
+        Iterator to iterate over the video frames
+        (already decoded).
+        """
+        for frame in self.frame_iterator:
+            yield VideoReaderFrame(frame)
+
+    def iterate_with_audio(
+        self,
+        do_decode_video: bool = True,
+        do_decode_audio: bool = False
+    ) -> 'Iterator[Union[VideoReaderFrame, VideoReaderPacket, None]]':
+        """
+        Iterator to iterate over the video and audio
+        packets, decoded only if the parameters are
+        set as True.
+
+        If the packet is decoded, it will return each
+        frame individually as a VideoReaderFrame 
+        instance. If not, the whole packet as a
+        VideoReaderPacket instance.
+
+        If the frame is the last one, with size == 0,
+        it will return None as it must not be passed
+        to the muxer '.mux()' method.
+        """
+        for packet in self.packet_with_audio_iterator:
+            if packet.size == 0:
+                # End packet, not for muxer
+                yield None
+                continue
+
+            is_video = packet.stream.type == 'video'
+
+            do_decode = (
+                (
+                    is_video and
+                    do_decode_video
+                ) or
+                (
+                    not is_video and
+                    do_decode_audio
+                )
+            )
+
+            if do_decode:
+                for frame in packet.decode():
+                    # Return each frame decoded
+                    yield VideoReaderFrame(frame)
+            else:
+                # Return the packet as it is
+                yield VideoReaderPacket(packet)
 
 
 

yta_video_opengl/tests.py

@@ -3,125 +3,16 @@ Manual tests that are working and are interesting
 to learn about the code, refactor and build
 classes.
 """
+from yta_validation import PythonValidator
+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
-from PIL import Image
 
 import av
-# This 'glfw' is only needed to show in a window
-import glfw
 import moderngl
 import numpy as np
-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]
-    fps = stream.average_rate
-    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
-
-    # 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
-
-        # 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")
-        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()
-
-        frame_index += 1
-
-    glfw.terminate()
 
 def video_modified_stored():
     VIDEO_PATH = "test_files/test_1.mp4"
@@ -130,12 +21,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;
@@ -145,7 +36,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;
@@ -168,95 +59,117 @@ 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')
+    ], dtype = 'f4')
+    vbo = context.buffer(vertices.tobytes())
+    vao = context.simple_vertex_array(program, vbo, 'in_pos', 'in_uv')
 
-    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(video.size)
+    print(video.number_of_frames)
+    print(video.number_of_audio_frames)
+
+    # 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
+    # Decode first frame and use as texture
     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())
+    image = np.flipud(first_frame.to_ndarray(format = NUMPY_FORMAT))
+    texture = context.texture((image.shape[1], image.shape[0]), 3, image.tobytes())
 
-    tex.build_mipmaps()
+    texture.build_mipmaps()
 
     # Uniforms
-    prog['amp'].value = AMP
-    prog['freq'].value = FREQ
-    prog['speed'].value = SPEED
-
-    # Abrir salida con PyAV (codificador H.264)
-    video_writer = VideoWriter(OUTPUT_PATH, video.fps, video.size, 'yuv420p')
-    output_stream = video_writer._stream
+    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:
-        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")
-        )
-
-        # 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
-        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)
-
-        # 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:
-            video_writer._output.mux(packet)
-
-        frame_index += 1
-
-    # Vaciar buffers de codificación
-    packet = output_stream.encode(None)
-    if packet:
-        video_writer._output.mux(packet)
-
-    video_writer._output.close()
-    print(f"Vídeo guardado en {OUTPUT_PATH}")
+    for frame_or_packet in video.iterate_with_audio(
+        do_decode_video = True,
+        do_decode_audio = False
+    ):
+        # This below is because of the parameters we
+        # passed to the method
+        is_video_frame = PythonValidator.is_instance_of(frame_or_packet, 'VideoReaderFrame')
+        is_audio_packet = PythonValidator.is_instance_of(frame_or_packet, 'VideoReaderPacket')
+
+        # To simplify the process
+        if frame_or_packet is not None:
+            frame_or_packet = frame_or_packet.data
+
+        if is_audio_packet:
+            video_writer.mux(frame_or_packet)
+        elif is_video_frame:
+            with Timer(is_silent_as_context = True) as timer:
+
+                def process_frame(
+                    frame: 'VideoFrame'
+                ):
+                    # 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
+                    frame = av.VideoFrame.from_ndarray(processed_data, format = NUMPY_FORMAT)
+                    # TODO: What is this for (?)
+                    #out_frame.pict_type = 'NONE'
+                    return frame
+
+                video_writer.mux_video_frame(process_frame(frame_or_packet))
+
+            print(f'Frame {str(frame_index)}: {timer.time_elapsed_str}s')
+            frame_index += 1
+
+    # 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.
+    video_writer.mux_video_frame(None)
+
+    # 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

@@ -1,5 +1,15 @@
+from yta_validation import PythonValidator
+from yta_validation.parameter import ParameterValidator
 from av.stream import Stream
+from av.packet import Packet
+from av.video.frame import VideoFrame
+from av.audio.frame import AudioFrame
+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:
@@ -11,9 +21,6 @@ class VideoWriter:
     def __init__(
         self,
         filename: str,
-        fps: float,
-        size: tuple[int, int],
-        pixel_format: str = 'yuv420p'
     ):
         self.filename: str = filename
         """
@@ -21,8 +28,186 @@ class VideoWriter:
         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
+        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
+
+    def encode_video_frame(
+        self,
+        frame: Union[VideoFrame, None] = None
+    ) -> list[Packet]:
+        """
+        Get the provided 'frame' but encoded for the
+        video stream, or the remaining packets if the
+        'frame' parameter given is None.
+
+        The `.encode()` method with a `None` parameter
+        will tell the encoder that we will not send
+        more frames to encode so the remaining ones can
+        be processed, emptying the buffers.
+        """
+        ParameterValidator.validate_instance_of('frame', frame, VideoFrame)
+
+        return self.video_stream.encode(frame)
+    
+    def encode_audio_frame(
+        self,
+        frame: Union[AudioFrame, None] = None
+    ) -> list[Packet]:
+        """
+        Get the provided 'frame' but encoded for the
+        audio stream, or the remaining packets if the
+        'frame' parameter given is None.
+
+        The `.encode()` method with a `None` parameter
+        will tell the encoder that we will not send
+        more frames to encode so the remaining ones can
+        be processed, emptying the buffers.
+        """
+        ParameterValidator.validate_instance_of('frame', frame, AudioFrame)
+
+        return self.audio_stream.encode(frame)
+    
+    def mux(
+        self,
+        packet: Packet
+    ) -> 'VideoWriter':
+        """
+        Add the provided video or audio 'packet'
+        to the mux.
+
+        Packets with a size of 0 will be discarded,
+        as they are indicators of the end.
+        """
+        ParameterValidator.validate_mandatory_instance_of('packet', packet, Packet)
+
+        if packet.size > 0:
+            self.output.mux(packet)
+
+        return self
+    
+    def mux_video_frame(
+        self,
+        frame: Union[VideoFrame, None] = None
+    ) -> 'VideoWriter':
+        """
+        Encode the provided 'frame' and add the
+        obtained packets to the multiplexing (mux)
+        process.
+
+        If `None` provided, it will obtain the
+        remaining packets and add those ones to
+        the multiplexing (mux) process.
+
+        Packets with a size of 0 will be discarded,
+        as they are indicators of the end.
+        """
+        ParameterValidator.validate_instance_of('frame', frame, VideoFrame)
+
+        for packet in self.encode_video_frame(frame):
+            self.mux(packet)
+
+        return self
+
+    def mux_audio_frame(
+        self,
+        frame: Union[AudioFrame, None] = None
+    ) -> 'VideoWriter':
+        """
+        Encode the provided 'frame' and add the
+        obtained packets to the multiplexing (mux)
+        process.
+
+        If `None` provided, it will obtain the
+        remaining packets and add those ones to
+        the multiplexing (mux) process.
+
+        Packets with a size of 0 will be discarded,
+        as they are indicators of the end.
+        """
+        ParameterValidator.validate_instance_of('frame', frame, AudioFrame)
+
+        for packet in self.encode_audio_frame(frame):
+            self.mux(packet)
+
+        return self
+        
+
+"""
+# TODO: Check 'https://www.youtube.com/watch?v=OlNWCpFdVMA'
+# for ffmpeg with mp3 access
+"""

{yta_video_opengl-0.0.2.dist-info → yta_video_opengl-0.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: yta-video-opengl
-Version: 0.0.2
+Version: 0.0.4
 Summary: Youtube Autonomous Video OpenGL Module
 Author: danialcala94
 Author-email: danielalcalavalera@gmail.com
@@ -8,10 +8,9 @@ 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

yta_video_opengl-0.0.4.dist-info/RECORD

@@ -0,0 +1,8 @@
+yta_video_opengl/__init__.py,sha256=ycAx_XYMVDfkuObSvtW6irQ0Wo-fgxEz3fjIRMe8PpY,205
+yta_video_opengl/reader.py,sha256=Mfhx4DHLfpmRXZYgkCcrzLbEsxGoKIj7RteHu4gOp8c,10691
+yta_video_opengl/tests.py,sha256=YnvSxxqWigTefUtc4IM0gUd3ovZKk8MwS6uyDqO42xA,5864
+yta_video_opengl/writer.py,sha256=9i1SSaOxWF-uBTWvpToP8juIqSWhbIh_Nfyi69adWIw,6356
+yta_video_opengl-0.0.4.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+yta_video_opengl-0.0.4.dist-info/METADATA,sha256=bvLctvd0BL3lUflS8K39Dtl0ubHRIeqLSzOeuo0MlMw,670
+yta_video_opengl-0.0.4.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+yta_video_opengl-0.0.4.dist-info/RECORD,,

yta_video_opengl-0.0.2.dist-info/RECORD

@@ -1,8 +0,0 @@
-yta_video_opengl/__init__.py,sha256=Xb1dwLlYPh_sttMNyKsuP81ie5RXhuQf6AM_XvsUuWE,284
-yta_video_opengl/reader.py,sha256=PcbQiQLrPDDrcRLw_UyuMBVmjFvbH7XF-V-LNF9fUAU,3276
-yta_video_opengl/tests.py,sha256=Jxg5ysCkVsxYOsJBsutsnnfB9F0mquMswQ9UWxHpsxQ,7741
-yta_video_opengl/writer.py,sha256=_GrJnqyejQXiSN7iAG_MN85tQllcidZa3iwR4PYNhNg,799
-yta_video_opengl-0.0.2.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-yta_video_opengl-0.0.2.dist-info/METADATA,sha256=R-a5c_sSfovpHSXyA0eVbM6q9dx2QVdh0i02nqYSsfU,706
-yta_video_opengl-0.0.2.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-yta_video_opengl-0.0.2.dist-info/RECORD,,