yta-video-opengl 0.0.20__py3-none-any.whl → 0.0.22__py3-none-any.whl

yta_video_opengl/audio.py

@@ -1,3 +1,8 @@
+"""
+TODO: This class has not been refactored nor
+tested. I need to put some love on it to make
+it work and test that it is working properly.
+"""
 from yta_video_opengl.reader import VideoReader
 from yta_video_opengl.writer import VideoWriter
 from yta_video_opengl.t import T

yta_video_opengl/complete/frame_combinator.py

@@ -201,93 +201,4 @@ class AudioFrameCombinator:
         )
         out.sample_rate = sample_rate
 
-        return out
-
-# TODO: This method below has been refactored
-# to the 'sum_tracks_frames', so delete it 
-# when the one above is working well
-def mix_audio_frames_by_index(
-    tracks_frames,
-    sample_rate: int,
-    layout = 'stereo',
-):
-    """
-    Combine all the columns of the given
-    matrix of audio frames 'tracks_frames'.
-    The rows are the different tracks and
-    the columns are the frame at that 't'
-    moment of each of those tracks.
-
-    The 'tracks_frames' matrix needs to be
-    pre-processed to have only 1 single
-    frame to combine, so we concatenate
-    all the frames if more than 1 per 
-    column.
-    """
-    # TODO: Please, improve and clean all this
-    # code is so sh*tty, and make utils to
-    # combine and those things, not here...
-    # Also the formats, make them dynamic and
-    # based on the output that is defined here
-    # in the Timeline class.
-    mixed_frames = []
-
-    # Iterate by columns (each row is a track)
-    for frames_at_index in zip(*tracks_frames):
-        arrays = []
-        for f in frames_at_index:
-            # Resample to output expected values
-            # TODO: This must be dynamic depending
-            # on the track values
-            resampler = AudioResampler(format = 'fltp', layout = 'stereo', rate = sample_rate)
-            arr = resampler.resample(f)
-
-            arr = f.to_ndarray()
-
-            # TODO: This below must change depending
-            # on the expected output, for us and now
-            # it is float32, fltp, stereo, 44_100
-            # Same format
-            if arr.dtype == np.int16:
-                arr = arr.astype(np.float32) / 32768.0
-
-            # Same layout (number of channels)
-            if arr.shape[0] == 1:
-                return np.repeat(arr, 2, axis = 0)
-            # elif arr.dtype == np.float32:
-            #     # Ya está en [-1,1], no lo toques
-            #     pass
-
-            arrays.append(arr)
-
-        # Alinear longitudes
-        max_len = max(a.shape[1] for a in arrays)
-        stacked = []
-        for a in arrays:
-            buf = np.zeros((a.shape[0], max_len), dtype = np.float32)
-            buf[:, :a.shape[1]] = a
-            stacked.append(buf)
-
-        # Mezcla
-        mix = np.sum(stacked, axis = 0) / len(stacked)
-        #mix = np.sum(stacked, axis = 0) 
-
-        # Limitar al rango [-1,1]
-        mix = np.clip(mix, -1.0, 1.0)
-
-        # Crear frame de salida
-        # TODO: What about the 'format' if they
-        # are all different (?)
-        out = AudioFrame.from_ndarray(mix, format = 'fltp', layout = layout)
-        out.sample_rate = sample_rate
-        # TODO: This will be written later when
-        # encoding
-        # out.pts = frames_at_index[0].pts
-        # out.time_base = frames_at_index[0].time_base
-
-        print(mix.min(), mix.max())
-
-        mixed_frames.append(out)
-
-    return mixed_frames
-
+        return out

yta_video_opengl/complete/frame_generator.py

@@ -28,6 +28,9 @@ class _FrameGenerator:
     Class to generate frames as numpy arrays.
     """
 
+    # TODO: I have some library doing this with
+    # colors and numpy frames, so please refactor
+
     def full_black(
         self,
         size: tuple[int, int] = (1920, 1080),
@@ -57,8 +60,27 @@ class _FrameGenerator:
         """
         # TODO: I think 'ones' only work if dtype
         # is int
-        return np.ones(
+        return np.full(
+            shape = (size[1], size[0], 3),
+            fill_value = (255, 255, 255),
+            dtype = dtype
+        )
+
+    def full_red(
+        self,
+        size: tuple[int, int] = (1920, 1080),
+        dtype: np.dtype = np.uint8
+    ):
+        """
+        Get a numpy array that represents a full
+        red frame of the given 'size' and with
+        the given 'dtype'.
+        """
+        # TODO: I think 'ones' only work if dtype
+        # is int
+        return np.full(
             shape = (size[1], size[0], 3),
+            fill_value = (255, 0, 0),
             dtype = dtype
         )
 
@@ -115,6 +137,25 @@ class _BackgroundFrameGenerator:
             time_base = time_base
         )
 
+    def full_red(
+        self,
+        size: tuple[int, int] = (1920, 1080),
+        dtype: np.dtype = np.uint8,
+        format: str = 'rgb24',
+        pts: Union[int, None] = None,
+        time_base: Union['Fraction', None] = None   
+    ) -> VideoFrame:
+        """
+        Get a video frame that is completely red
+        and of the given 'size'.
+        """
+        return numpy_to_video_frame(
+            frame = self._frame_generator.full_red(size, dtype),
+            format = format,
+            pts = pts,
+            time_base = time_base
+        )
+
 class VideoFrameGenerator:
     """
     Class to wrap the functionality related to

yta_video_opengl/complete/frame_wrapper.py

@@ -5,6 +5,12 @@ from typing import Union
 
 
 IS_FROM_EMPTY_PART_METADATA = 'is_from_empty_part'
+"""
+Metadata key to indicate if the frame
+has been generated by an empty part
+and should be ignored when trying to
+combine with others.
+"""
 
 class _FrameWrappedBase:
     """
@@ -35,7 +41,14 @@ class _FrameWrappedBase:
         ParameterValidator.validate_mandatory_dict('metadata', metadata)
 
         self._frame: Union[VideoFrame, AudioFrame] = frame
+        """
+        The VideoFrame or AudioFrame pyav instance.
+        """
         self.metadata: dict = metadata or {}
+        """
+        The metadata we want to include with the
+        frame.
+        """
 
     def __getattr__(
         self,

yta_video_opengl/complete/timeline.py

@@ -10,12 +10,14 @@ an important property or will make ffmpeg
 become crazy and deny packets (that means no
 video written).
 """
-from yta_video_opengl.complete.track import VideoTrack
+from yta_video_opengl.complete.track import VideoTrack, AudioTrack
 from yta_video_opengl.video import Video
 from yta_video_opengl.t import get_ts, fps_to_time_base, T
-from yta_video_opengl.complete.frame_wrapper import VideoFrameWrapped, AudioFrameWrapped
+from yta_video_opengl.complete.frame_wrapper import AudioFrameWrapped
 from yta_video_opengl.complete.frame_combinator import AudioFrameCombinator
+from yta_video_opengl.writer import VideoWriter
 from yta_validation.parameter import ParameterValidator
+from yta_validation import PythonValidator
 from av.video.frame import VideoFrame
 from av.audio.frame import AudioFrame
 from quicktions import Fraction
@@ -45,6 +47,80 @@ class Timeline:
             track.end
             for track in self.tracks
         )
+    
+    @property
+    def tracks(
+        self
+    ) -> list[Union['AudioTrack', 'VideoTrack']]:
+        """
+        All the tracks we have but ordered by 
+        their indexes, from lower index (highest
+        priority) to highest index (lowest
+        priority).
+        """
+        return sorted(self._tracks, key = lambda track: track.index)
+    
+    @property
+    def video_tracks(
+        self
+    ) -> list['VideoTrack']:
+        """
+        All the video tracks we have but ordered
+        by their indexes, from lower index
+        (highest priority) to highest index
+        (lowest priority).
+        """
+        return [
+            track
+            for track in self.tracks
+            if PythonValidator.is_instance_of(track, 'VideoTrack')
+        ]
+    
+    @property
+    def audio_tracks(
+        self
+    ) -> list['AudioTrack']:
+        """
+        All the audio tracks we have but ordered
+        by their indexes, from lower index
+        (highest priority) to highest index
+        (lowest priority).
+        """
+        return [
+            track
+            for track in self.tracks
+            if PythonValidator.is_instance_of(track, 'AudioTrack')
+        ]
+    
+    @property
+    def number_of_tracks(
+        self
+    ) -> int:
+        """
+        The number of tracks we have in the
+        timeline.
+        """
+        return len(self.tracks)
+
+    @property
+    def number_of_video_tracks(
+        self
+    ) -> int:
+        """
+        The number of video tracks we have in the
+        timeline.
+        """
+        return len(self.video_tracks)
+    
+    @property
+    def number_of_audio_tracks(
+        self
+    ) -> int:
+        """
+        The number of audio tracks we have in the
+        timeline.
+        """
+        return len(self.audio_tracks)
 
     def __init__(
         self,
@@ -56,14 +132,14 @@ class Timeline:
         audio_samples_per_frame: int = 1024,
         video_codec: str = 'h264',
         video_pixel_format: str = 'yuv420p',
-        audio_codec: str = 'aac'
+        audio_codec: str = 'aac',
+        # TODO: What about this below (?)
+        # audio_layout = 'stereo',
+        # audio_format = 'fltp'
     ):
-        # TODO: We need to be careful with the
-        # priority, by now its defined by its
-        # position in the array
         # TODO: By now I'm having only video
         # tracks
-        self.tracks: list[VideoTrack] = []
+        self._tracks: list[VideoTrack] = []
         """
         All the video tracks we are handling.
         """
@@ -98,61 +174,112 @@ class Timeline:
         The audio codec for the audio exported.
         """
 
-        # We will have 2 tracks by now
-        self.add_track().add_track()
+        # We will have 2 video tracks by now
+        self.add_video_track().add_video_track()
 
-    # TODO: This has to be modified to accept
-    # adding an AudioTrack
-    def add_track(
+    def _add_track(
         self,
-        index: Union[int, None] = None
+        index: Union[int, None] = None,
+        is_audio: bool = False
     ) -> 'Timeline':
         """
-        Add a new track to the timeline, that will
-        be placed in the last position (last 
-        priority).
+        Add a new track to the timeline that will
+        be placed in the last position (highest 
+        index, lowest priority).
 
-        It will be a video track unless you provide
-        'is_audio_track' parameter as True.
+        It will be a video track unless you send
+        the 'is_audio' parameter as True.
         """
+        number_of_tracks = (
+            self.number_of_audio_tracks
+            if is_audio else
+            self.number_of_video_tracks
+        )
+
+        tracks = (
+            self.audio_tracks
+            if is_audio else
+            self.video_tracks
+        )
+
         index = (
             index
             if (
                 index is not None and
-                index <= len(self.tracks)
+                index <= number_of_tracks
             ) else
-            len(self.tracks)
+            number_of_tracks
         )
 
         # We need to change the index of the
         # affected tracks (the ones that are
         # in that index and after it)
-        if index < len(self.tracks):
-            for track in self.tracks:
+        if index < number_of_tracks:
+            for track in tracks:
                 if track.index >= index:
                     track.index += 1
 
-        self.tracks.append(VideoTrack(
-            index = index,
-            size = self.size,
-            fps = self.fps,
-            audio_fps = self.audio_fps,
-            # TODO: I need more info about the audio
-            # I think
-            audio_samples_per_frame = self.audio_samples_per_frame,
-            # TODO: Where do we obtain this from (?)
-            audio_layout = 'stereo',
-            audio_format = 'fltp'
-        ))
+        track = (
+            AudioTrack(
+                index = index,
+                fps = self.fps,
+                audio_fps = self.audio_fps,
+                audio_samples_per_frame = self.audio_samples_per_frame,
+                # TODO: Where do we obtain this from (?)
+                audio_layout = 'stereo',
+                audio_format = 'fltp'
+            )
+            if is_audio else
+            VideoTrack(
+                index = index,
+                size = self.size,
+                fps = self.fps,
+                audio_fps = self.audio_fps,
+                audio_samples_per_frame = self.audio_samples_per_frame,
+                # TODO: Where do we obtain this from (?)
+                audio_layout = 'stereo',
+                audio_format = 'fltp'
+            )
+        )
+            
+        self._tracks.append(track)
 
         return self
+
+    def add_video_track(
+        self,
+        index: Union[int, None] = None
+    ) -> 'Timeline':
+        """
+        Add a new video track to the timeline, that
+        will be placed in the last position (highest
+        index, lowest priority).
+        """
+        return self._add_track(
+            index = index,
+            is_audio = False
+        )
+    
+    def add_audio_track(
+        self,
+        index: Union[int, None] = None
+    ) -> 'Timeline':  
+        """
+        Add a new audio track to the timeline, that
+        will be placed in the last position (highest
+        index, lowest priority).
+        """  
+        return self._add_track(
+            index = index,
+            is_audio = True
+        )
     
     # TODO: Create a 'remove_track'
 
     def add_video(
         self,
         video: Video,
-        t: Union[int, float, Fraction],
+        t: Union[int, float, Fraction, None] = None,
         track_index: int = 0
     ) -> 'Timeline':
         """
@@ -162,17 +289,23 @@ class Timeline:
         TODO: The 'do_use_second_track' parameter
         is temporary.
         """
-        ParameterValidator.validate_mandatory_number_between('track_index', track_index, 0, len(self.tracks))
+        ParameterValidator.validate_mandatory_number_between('track_index', track_index, 0, self.number_of_tracks)
+
+        if track_index >= self.number_of_video_tracks:
+            raise Exception(f'The "track_index" {str(track_index)} provided does not exist in this timeline.')
 
-        self.tracks[track_index].add_media(video, t)
+        # TODO: This should be, maybe, looking for
+        # tracks by using the index property, not
+        # as array index, but by now it is like
+        # this as it is not very robust yet
+        self.video_tracks[track_index].add_media(video, t)
 
         return self
     
-    # TODO: Create a 'remove_video'
+    # TODO: Create a 'remove_video' 
+    # TODO: Create a 'add_audio'
+    # TODO: Create a 'remove_audio'
     
-    # TODO: This method is not for the Track but
-    # for the timeline, as one track can only
-    # have consecutive elements
     def get_frame_at(
         self,
         t: Union[int, float, Fraction]
@@ -183,26 +316,17 @@ class Timeline:
         """
         frames = list(
             track.get_frame_at(t)
-            for track in self.tracks
+            for track in self.video_tracks
         )
-        # TODO: Here I receive black frames because
-        # it was empty, but I don't have a way to
-        # detect those black empty frames because
-        # they are just VideoFrame instances... I
-        # need a way to know so I can skip them if
-        # other frame in other track, or to know if
-        # I want them as transparent or something
-
         # TODO: Combinate frames, we force them to
         # rgb24 to obtain them with the same shape,
         # but maybe we have to change this because
         # we also need to handle alphas
 
-        # TODO: We need to ignore the ones that are
-        # tagged with 
-        # .metadata['is_from_empty_part'] = 'True'
-
         """
+        We need to ignore the frames that are tagged
+        as coming from an empty part, so we can have:
+
         1. Only empty frames
             -> Black background, keep one
         2. Empty frames but other frames:
@@ -254,12 +378,16 @@ class Timeline:
         """
         # TODO: What if the different audio streams
         # have also different fps (?)
+        # We use both tracks because videos and
+        # audio tracks have both audios
         for track in self.tracks:
             # TODO: Make this work properly
             audio_frames.append(list(track.get_audio_frames_at(t)))
-            # TODO: We need to ignore the frames that
-            # are just empty black frames and use them
-            # not in the combination process
+
+        # TODO: I am receiving empty array here []
+        # that doesn't include any frame in a specific
+        # track that contains a video, why (?)
+        print(audio_frames)
 
         # We need only 1 single audio frame per column
         collapsed_frames = [
@@ -271,6 +399,7 @@ class Timeline:
         # things? They should be ok because they are
         # based on our output but I'm not completely
         # sure here..
+        print(collapsed_frames)
 
         # We keep only the non-silent frames because
         # we will sum them after and keeping them
@@ -299,9 +428,9 @@ class Timeline:
             
     def render(
         self,
-        filename: str,
+        output_filename: str = 'test_files/output_render.mp4',
         start: Union[int, float, Fraction] = 0.0,
-        end: Union[int, float, Fraction, None] = None
+        end: Union[int, float, Fraction, None] = None,
     ) -> 'Timeline':
         """
         Render the time range in between the given
@@ -311,122 +440,74 @@ class Timeline:
         If no 'start' and 'end' provided, the whole
         project will be rendered.
         """
-        ParameterValidator.validate_mandatory_string('filename', filename, do_accept_empty = False)
+        ParameterValidator.validate_mandatory_string('output_filename', output_filename, do_accept_empty = False)
         ParameterValidator.validate_mandatory_positive_number('start', start, do_include_zero = True)
         ParameterValidator.validate_positive_number('end', end, do_include_zero = False)
 
-        # TODO: Limitate 'end' a bit...
         end = (
             self.end
             if end is None else
             end
         )
 
+        # Limit 'end' a bit...
+        if end >= 300:
+            raise Exception('More than 5 minutes not supported yet.')
+
         if start >= end:
             raise Exception('The provided "start" cannot be greater or equal to the "end" provided.')
 
-        from yta_video_opengl.writer import VideoWriter
+        writer = VideoWriter(output_filename)
 
-        writer = VideoWriter('test_files/output_render.mp4')
         # TODO: This has to be dynamic according to the
-        # video we are writing
+        # video we are writing (?)
         writer.set_video_stream(
-            codec_name = 'h264',
+            codec_name = self.video_codec,
             fps = self.fps,
             size = self.size,
-            pixel_format = 'yuv420p'
+            pixel_format = self.video_pixel_format
         )
         
         writer.set_audio_stream(
-            codec_name = 'aac',
+            codec_name = self.audio_codec,
             fps = self.audio_fps
         )
 
         time_base = fps_to_time_base(self.fps)
         audio_time_base = fps_to_time_base(self.audio_fps)
 
-        """
-        We are trying to render this:
-        -----------------------------
-        [0 a 0.5) => Frames negros
-        [0.5 a 1.25) => [0.25 a 1.0) de Video1
-        [1.25 a 1.75) => Frames negros
-        [1.75 a 2.25) => [0.25 a 0.75) de Video1
-        [2.25 a 3.0) => Frames negros
-        [3.0 a 3.75) => [2.25 a 3.0) de Video2
-        """
-        
         audio_pts = 0
         for t in get_ts(start, end, self.fps):
             frame = self.get_frame_at(t)
 
             print(f'Getting t:{str(float(t))}')
-            #print(frame)
 
             # We need to adjust our output elements to be
             # consecutive and with the right values
             # TODO: We are using int() for fps but its float...
             frame.time_base = time_base
-            #frame.pts = int(video_frame_index / frame.time_base)
             frame.pts = T(t, time_base).truncated_pts
 
-            # TODO: We need to handle the audio
             writer.mux_video_frame(
                 frame = frame
             )
 
-            #print(f'    [VIDEO] Here in t:{str(t)} -> pts:{str(frame.pts)} - dts:{str(frame.dts)}')
-
-            # TODO: Uncomment all this below for the audio
-            num_of_audio_frames = 0
             for audio_frame in self.get_audio_frames_at(t):
-                # TODO: The track gives us empty (black)
-                # frames by default but maybe we need a
-                # @dataclass in the middle to handle if
-                # we want transparent frames or not and/or
-                # to detect them here because, if not,
-                # they are just simple VideoFrames and we
-                # don't know they are 'empty' frames
-
                 # We need to adjust our output elements to be
                 # consecutive and with the right values
                 # TODO: We are using int() for fps but its float...
                 audio_frame.time_base = audio_time_base
-                #audio_frame.pts = int(audio_frame_index / audio_frame.time_base)
                 audio_frame.pts = audio_pts
+
                 # We increment for the next iteration
                 audio_pts += audio_frame.samples
-                #audio_frame.pts = int(t + (audio_frame_index * audio_frame.time_base) / audio_frame.time_base)
-
-                #print(f'[AUDIO] Here in t:{str(t)} -> pts:{str(audio_frame.pts)} - dts:{str(audio_frame.dts)}')
 
-                #num_of_audio_frames += 1
-                #print(audio_frame)
                 writer.mux_audio_frame(audio_frame)
-            #print(f'Num of audio frames: {str(num_of_audio_frames)}')
 
         writer.mux_video_frame(None)
         writer.mux_audio_frame(None)
         writer.output.close()
 
-def _is_empty_part_frame(
-    frame: Union['VideoFrameWrapped', 'AudioFrameWrapped']
-) -> bool:
-    """
-    Flag to indicate if the frame comes from
-    an empty part or not.
-
-    TODO: The 'metadata' is included in our
-    wrapper class, not in VideoFrame or
-    AudioFrame classes. I should be sending
-    the wrapper in all the code, but by now
-    I'm doing it just in specific cases.
-    """
-    return (
-        hasattr(frame, 'metadata') and
-        frame.is_from_empty_part
-    )
-
 # TODO: Refactor and move please
 # TODO: This has to work for AudioFrame
 # also, but I need it working for Wrapped