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

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

@@ -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.2 → yta_video_opengl-0.0.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yta-video-opengl"
-version = "0.0.2"
+version = "0.0.4"
 description = "Youtube Autonomous Video OpenGL Module"
 authors = [
     {name = "danialcala94",email = "danielalcalavalera@gmail.com"}
@@ -10,10 +10,9 @@ requires-python = "==3.9"
 dependencies = [
     "yta_validation (>=0.0.1,<1.0.0)",
     "yta_video_frame_time (>=0.0.1,<1.0.0)",
+    "yta_timer (>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)",
-    "pillow (>=0.0.1,<19.0.0)",
     "numpy (>=0.0.1,<9.0.0)",
 ]
 

yta_video_opengl-0.0.4/src/yta_video_opengl/__init__.py

@@ -0,0 +1,11 @@
+"""
+Module to include video handling with OpenGL.
+"""
+def main():
+    from yta_video_opengl.tests import video_modified_stored
+
+    video_modified_stored()
+
+
+if __name__ == '__main__':
+    main()

yta_video_opengl-0.0.4/src/yta_video_opengl/reader.py

@@ -0,0 +1,419 @@
+"""
+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
+
+
+@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:
+    """
+    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 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(
+        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
+    ) -> '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)
+
+
+
+
+"""
+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.4/src/yta_video_opengl/tests.py

@@ -0,0 +1,175 @@
+"""
+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
+
+import av
+import moderngl
+import numpy as np
+
+
+def video_modified_stored():
+    VIDEO_PATH = "test_files/test_1.mp4"
+    OUTPUT_PATH = "test_files/output.mp4"
+    AMP = 0.05
+    FREQ = 10.0
+    SPEED = 2.0
+
+    # ModernGL context without window
+    context = moderngl.create_standalone_context()
+
+    # Wave shader vertex and fragment
+    program = context.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);
+        }
+        '''
+    )
+
+    # Quad
+    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 = context.buffer(vertices.tobytes())
+    vao = context.simple_vertex_array(program, vbo, 'in_pos', 'in_uv')
+
+    video = VideoReader(VIDEO_PATH)
+
+    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()
+
+    # 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
+    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_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-0.0.4/src/yta_video_opengl/writer.py

@@ -0,0 +1,213 @@
+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:
+    """
+    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
+
+    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/src/yta_video_opengl/__init__.py

@@ -1,12 +0,0 @@
-"""
-Module to include video handling with OpenGL.
-"""
-def main():
-    from yta_video_opengl.tests import video_modified_displayed_on_window, video_modified_stored
-
-    #video_modified_displayed_on_window()
-    video_modified_stored()
-
-
-if __name__ == '__main__':
-    main()

yta_video_opengl-0.0.2/src/yta_video_opengl/reader.py

@@ -1,137 +0,0 @@
-"""
-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.2/src/yta_video_opengl/tests.py

@@ -1,262 +0,0 @@
-"""
-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
-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"
-    OUTPUT_PATH = "test_files/output.mp4"
-    AMP = 0.05
-    FREQ = 10.0
-    SPEED = 2.0
-
-    # Crear contexto ModernGL sin ventana
-    ctx = moderngl.create_standalone_context()
-
-    # Shader de onda
-    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);
-        }
-        '''
-    )
-
-    # Quad
-    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')
-
-    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)
-    fbo.use()
-
-    # Decodificar primer frame y crear textura
-    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
-    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
-
-    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}")

yta_video_opengl-0.0.2/src/yta_video_opengl/writer.py

@@ -1,28 +0,0 @@
-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