yta-video-opengl 0.0.19__py3-none-any.whl → 0.0.21__py3-none-any.whl

yta_video_opengl/complete/timeline.py

@@ -10,11 +10,12 @@ an important property or will make ffmpeg
 become crazy and deny packets (that means no
 video written).
 """
-from yta_video_opengl.complete.track import Track
+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
@@ -46,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,
@@ -57,12 +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
-        self.tracks: list[Track] = []
+        # TODO: By now I'm having only video
+        # tracks
+        self._tracks: list[VideoTrack] = []
         """
         All the video tracks we are handling.
         """
@@ -97,59 +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()
 
-    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(Track(
-            size = self.size,
-            index = index,
-            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':
         """
@@ -159,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_video(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]
@@ -180,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:
@@ -251,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 = [
@@ -268,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
@@ -296,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
@@ -308,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