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

yta_video_opengl/reader.py

@@ -12,95 +12,94 @@ 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.
+    frame, and has been decoded.
     """
 
     @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(
+    def is_video(
         self
     ):
         """
         Flag to indicate if the instance is a video
         frame.
         """
-        return PythonValidator.is_instance_of(self.frame, VideoFrame)
+        return PythonValidator.is_instance_of(self.data, VideoFrame)
     
     @property
-    def is_audio_frame(
+    def is_audio(
         self
     ):
         """
         Flag to indicate if the instance is an audio
         frame.
         """
-        return PythonValidator.is_instance_of(self.frame, AudioFrame)
+        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_packet(
+    def is_video(
         self
     ) -> bool:
         """
-        Flag to indicate if the instance is a packet
-        containing video frames.
+        Flag to indicate if the packet includes video
+        frames or not.
         """
-        return (
-            self.is_packet and
-            self.frame.stream.type == 'video'
-        )
-
+        return self.data.stream.type == 'video'
+    
     @property
-    def is_audio_packet(
+    def is_audio(
         self
     ) -> bool:
         """
-        Flag to indicate if the instance is a packet
-        containing audio frames.
+        Flag to indicate if the packet includes audio
+        frames or not.
         """
-        return (
-            self.is_packet and
-            self.frame.stream.type == 'audio'
-        )
-    
+        return self.data.stream.type == 'audio'
+
     def __init__(
         self,
-        # TODO: Add the type, please
-        frame: any
+        data: Packet
     ):
-        self.frame: Union[AudioFrame, VideoFrame, Packet] = frame
+        self.data: Packet = data
         """
-        The frame content, that can be audio or video
-        frame, or a packet of more than one frame.
+        The packet, that can include video or audio
+        frames and can be decoded.
         """
 
-    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
+    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:
@@ -124,30 +123,93 @@ class VideoReader:
         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)
     
-    # TODO: Maybe rename (?)
     @property
-    def frame_with_audio_iterator(
+    def packet_with_audio_iterator(
         self
     ) -> 'Iterator[Packet]':
         """
         Iterator to iterate over all the video frames
-        decodified, including also the audio.
+        as packets (not decodified) including also the
+        audio as packets.
         """
         return self.container.demux((self.video_stream, self.audio_stream))
 
     @property
-    def next_frame_with_audio(
+    def next_packet_with_audio(
         self
     ) -> Union[Packet, None]:
         """
-        Get the next frame of the iterator that includes
-        the audio.
+        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.frame_with_audio_iterator)
+        return next(self.packet_with_audio_iterator)
 
     @property
     def codec_name(
@@ -166,6 +228,24 @@ class VideoReader:
         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(
@@ -248,48 +328,63 @@ class VideoReader:
 
     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
-    ):
-        for frame_or_packet in self.frame_with_audio_iterator:
-            yield VideoReaderFrame(frame_or_packet)
-
+        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.
+        """
+        for packet in self.packet_with_audio_iterator:
+            is_video = packet.stream.type == 'video'
 
+            do_decode = (
+                (
+                    is_video and
+                    do_decode_video
+                ) or
+                (
+                    not is_video and
+                    do_decode_audio
+                )
+            )
 
-"""
-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).
+            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)
 
-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
+"""
+When reading packets directly from the stream
+we can receive packets with size=0, but we need
+to process them and decode (or yield them). It
+is only when we are passing packets to the mux
+when we need to ignore teh ones thar are empty
+(size=0).
 
-Esto es lo más usado para pipeline de vídeo en tiempo real.
+TODO: Do we need to ignore all? By now, ignoring
+not is causing exceptions, and ignoring them is
+making it work perfectly.
 """

yta_video_opengl/tests.py

@@ -3,6 +3,7 @@ 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
@@ -78,6 +79,13 @@ def video_modified_stored():
 
     # Decode first frame and use as texture
     first_frame = video.next_frame
+    # We need to reset it to being again pointing
+    # to the first frame...
+    # TODO: Improve this by, maybe, storing the first
+    # frame in memory so we can append it later, or
+    # using the '.seek(0)' even when it could be not
+    # accurate
+    video = VideoReader(VIDEO_PATH)
 
     # Most of OpenGL textures expect origin in lower
     # left corner
@@ -100,109 +108,32 @@ def video_modified_stored():
     )
 
     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:
+    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)
@@ -226,42 +157,23 @@ def video_modified_stored():
                     )
 
                     # To VideoFrame and to buffer
-                    out_frame = av.VideoFrame.from_ndarray(processed_data, format = NUMPY_FORMAT)
+                    frame = av.VideoFrame.from_ndarray(processed_data, format = NUMPY_FORMAT)
                     # TODO: What is this for (?)
                     #out_frame.pict_type = 'NONE'
+                    return frame
 
-                    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')
+                video_writer.mux_video_frame(process_frame(frame_or_packet))
 
-        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)
+            print(f'Frame {str(frame_index)}: {timer.time_elapsed_str}s')
+            frame_index += 1
 
-    # 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)
+    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}".')
+    print(f'Saved as "{OUTPUT_PATH}".')

yta_video_opengl/writer.py

@@ -1,4 +1,9 @@
+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
@@ -101,6 +106,107 @@ class VideoWriter:
 
         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.3.dist-info → yta_video_opengl-0.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: yta-video-opengl
-Version: 0.0.3
+Version: 0.0.5
 Summary: Youtube Autonomous Video OpenGL Module
 Author: danialcala94
 Author-email: danielalcalavalera@gmail.com

yta_video_opengl-0.0.5.dist-info/RECORD

@@ -0,0 +1,8 @@
+yta_video_opengl/__init__.py,sha256=ycAx_XYMVDfkuObSvtW6irQ0Wo-fgxEz3fjIRMe8PpY,205
+yta_video_opengl/reader.py,sha256=ROjx5jSi_M2KWcp1Fksi4y-apb1IvItPhpLF32u5DpU,9869
+yta_video_opengl/tests.py,sha256=7a_n-xW2xBVYR1sj-IuGm8c8F6It2LHZ8GqCH_SeY-U,6081
+yta_video_opengl/writer.py,sha256=9i1SSaOxWF-uBTWvpToP8juIqSWhbIh_Nfyi69adWIw,6356
+yta_video_opengl-0.0.5.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+yta_video_opengl-0.0.5.dist-info/METADATA,sha256=hH7uBbRBkNQ44kIEi1oKB_s3fGLtwcnd0rdZB_M3bVw,670
+yta_video_opengl-0.0.5.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+yta_video_opengl-0.0.5.dist-info/RECORD,,

yta_video_opengl-0.0.3.dist-info/RECORD

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