yta-video-opengl 0.0.18__tar.gz → 0.0.19__tar.gz

{yta_video_opengl-0.0.18 → yta_video_opengl-0.0.19}/PKG-INFO

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

{yta_video_opengl-0.0.18 → yta_video_opengl-0.0.19}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yta-video-opengl"
-version = "0.0.18"
+version = "0.0.19"
 description = "Youtube Autonomous Video OpenGL Module"
 authors = [
     {name = "danialcala94",email = "danielalcalavalera@gmail.com"}

{yta_video_opengl-0.0.18 → yta_video_opengl-0.0.19}/src/yta_video_opengl/complete/timeline.py

@@ -59,33 +59,14 @@ class Timeline:
         video_pixel_format: str = 'yuv420p',
         audio_codec: str = 'aac'
     ):
-        # TODO: By now we are using just two video
-        # tracks to test the composition
         # TODO: We need to be careful with the
         # priority, by now its defined by its
         # position in the array
-        self.tracks: list[Track] = [
-            Track(
-                size = size,
-                fps = fps,
-                audio_fps = audio_fps,
-                # TODO: I need more info about the audio
-                # I think
-                audio_samples_per_frame = audio_samples_per_frame
-            ),
-            Track(
-                size = size,
-                fps = fps,
-                audio_fps = audio_fps,
-                # TODO: I need more info about the audio
-                # I think
-                audio_samples_per_frame = audio_samples_per_frame
-            )
-        ]
+        self.tracks: list[Track] = []
         """
         All the video tracks we are handling.
         """
-        
+
         self.size: tuple[int, int] = size
         """
         The size that the final video must have.
@@ -116,15 +97,60 @@ class Timeline:
         The audio codec for the audio exported.
         """
 
-    # TODO: Create 'add_track' method, but by now
-    # we hare handling only one
+        # We will have 2 tracks by now
+        self.add_track().add_track()
+
+    def add_track(
+        self,
+        index: Union[int, None] = None
+    ) -> 'Timeline':
+        """
+        Add a new track to the timeline, that will
+        be placed in the last position (last 
+        priority).
+
+        It will be a video track unless you provide
+        'is_audio_track' parameter as True.
+        """
+        index = (
+            index
+            if (
+                index is not None and
+                index <= len(self.tracks)
+            ) else
+            len(self.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 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'
+        ))
+
+        return self
+    
+    # TODO: Create a 'remove_track'
+
     def add_video(
         self,
         video: Video,
         t: Union[int, float, Fraction],
-        # TODO: This is for testing, it has to
-        # disappear
-        do_use_second_track: bool = False
+        track_index: int = 0
     ) -> 'Timeline':
         """
         Add the provided 'video' to the timeline,
@@ -133,16 +159,14 @@ class Timeline:
         TODO: The 'do_use_second_track' parameter
         is temporary.
         """
-        # TODO: This is temporary logic by now 
-        # just to be able to test mixing frames
-        # from 2 different tracks at the same
-        # time
-        index = 1 * do_use_second_track
+        ParameterValidator.validate_mandatory_number_between('track_index', track_index, 0, len(self.tracks))
 
-        self.tracks[index].add_video(video, t)
+        self.tracks[track_index].add_video(video, t)
 
         return self
     
+    # TODO: Create a 'remove_video'
+    
     # TODO: This method is not for the Track but
     # for the timeline, as one track can only
     # have consecutive elements
@@ -248,15 +272,15 @@ class Timeline:
         # We keep only the non-silent frames because
         # we will sum them after and keeping them
         # will change the results.
-        collapsed_frames = [
+        non_empty_collapsed_frames = [
             frame._frame
             for frame in collapsed_frames
             if not frame.is_from_empty_part
         ]
 
-        if len(collapsed_frames) == 0:
+        if len(non_empty_collapsed_frames) == 0:
             # If they were all silent, just keep one
-            collapsed_frames = [collapsed_frames[0]._frame]
+            non_empty_collapsed_frames = [collapsed_frames[0]._frame]
 
         # Now, mix column by column (track by track)
         # TODO: I do this to have an iterator, but 
@@ -264,7 +288,7 @@ class Timeline:
         # frame because of the size at the original
         # video or something...
         frames = [
-            AudioFrameCombinator.sum_tracks_frames(collapsed_frames, self.audio_fps)
+            AudioFrameCombinator.sum_tracks_frames(non_empty_collapsed_frames, self.audio_fps)
         ]
 
         for audio_frame in frames:

{yta_video_opengl-0.0.18 → yta_video_opengl-0.0.19}/src/yta_video_opengl/complete/track.py

@@ -139,62 +139,19 @@ class _Part:
                     is_from_empty_part = False
                 )
         else:
-            # TODO: Transform this below to a utils in
-            # which I obtain the array directly
-            # Check many full and partial silent frames we need
-            number_of_frames, number_of_remaining_samples = audio_frames_and_remainder_per_video_frame(
-                video_fps = self._track.fps,
-                sample_rate = self._track.audio_fps,
-                number_of_samples_per_audio_frame = self._track.audio_samples_per_frame
+            frames = generate_silent_frames(
+                fps = self._track.fps,
+                audio_fps = self._track.audio_fps,
+                audio_samples_per_frame = self._track.audio_samples_per_frame,
+                # TODO: Where do this 2 formats come from (?)
+                layout = self._track.audio_layout,
+                format = self._track.audio_format
             )
 
-            # TODO: I need to set the pts, but here (?)
-            # The complete silent frames we need
-            silent_frame = self._audio_frame_generator.silent(
-                sample_rate = self._track.audio_fps,
-                # TODO: Check where do we get this value from
-                layout = 'stereo',
-                number_of_samples = self._track.audio_samples_per_frame,
-                # TODO: Check where do we get this value from
-                format = 'fltp',
-                pts = None,
-                time_base = None
-            )
-            
-            frames = (
-                [
-                    AudioFrameWrapped(
-                        frame = silent_frame,
-                        is_from_empty_part = True
-                    )
-                ] * number_of_frames
-                if number_of_frames > 0 else
-                []
-            )
-
-            # The remaining partial silent frames we need
-            if number_of_remaining_samples > 0:
-                silent_frame = self._audio_frame_generator.silent(
-                    sample_rate = self._track.audio_fps,
-                    # TODO: Check where do we get this value from
-                    layout = 'stereo',
-                    number_of_samples = number_of_remaining_samples,
-                    # TODO: Check where do we get this value from
-                    format = 'fltp',
-                    pts = None,
-                    time_base = None
-                )
-                
-                frames.append(
-                    AudioFrameWrapped(
-                        frame = silent_frame,
-                        is_from_empty_part = True
-                    )
-                )
-
             for frame in frames:
                 yield frame
 
+
 # TODO: I don't like using t as float,
 # we need to implement fractions.Fraction
 # TODO: This is called Track but it is
@@ -256,27 +213,50 @@ class Track:
         from first to last.
         """
         return sorted(self._videos, key = lambda video: video.start)
+    
+    @property
+    def is_muted(
+        self
+    ) -> bool:
+        """
+        Flag to indicate if the track is muted or
+        not. Being muted means that no audio frames
+        will be retured from this track.
+        """
+        return self._is_muted
 
     def __init__(
         self,
         # TODO: I need the general settings of the
         # project to be able to make audio also, not
         # only the empty frames
+        index: int,
         size: tuple[int, int],
         fps: float,
         audio_fps: float,
         # TODO: Where does it come from (?)
-        audio_samples_per_frame: int
+        audio_samples_per_frame: int,
+        audio_layout: str = 'stereo',
+        audio_format: str = 'fltp'
     ):
         self._videos: list[VideoOnTrack] = []
         """
         The list of 'VideoOnTrack' instances that
         must play on this track.
         """
+        self._is_muted: bool = False
+        """
+        Internal flag to indicate if the track is
+        muted or not.
+        """
         self.size: tuple[int, int] = size
         """
         The size of the videos of this track.
         """
+        self.index: int = index
+        """
+        The index of the track within the timeline.
+        """
         self.fps: float = float(fps)
         """
         The fps of the track, needed to calculate
@@ -292,6 +272,16 @@ class Track:
         """
         The number of samples per audio frame.
         """
+        self.audio_layout: str = audio_layout
+        """
+        The layout of the audio, that can be 'mono'
+        or 'stereo'.
+        """
+        self.audio_format: str = audio_format
+        """
+        The format of the audio, that can be 's16',
+        'flt', 'fltp', etc.
+        """
 
     def _is_free(
         self,
@@ -305,8 +295,8 @@ class Track:
         """
         return not any(
             (
-                video.video.start < end and
-                video.video.end > start
+                video.start < end and
+                video.end > start
             )
             for video in self.videos
         )
@@ -332,6 +322,24 @@ class Track:
         raise Exception('NON_LIMITED_EMPTY_PART_END exceeded.')
         return None
 
+    def mute(
+        self
+    ) -> 'Track':
+        """
+        Set the track as muted so no audio frame will
+        be played from this track.
+        """
+        self._is_muted = True
+
+    def unmute(
+        self
+    ) -> 'Track':
+        """
+        Set the track as unmuted so the audio frames
+        will be played as normal.
+        """
+        self._is_muted = False
+
     def get_frame_at(
         self,
         t: Union[int, float, Fraction]
@@ -375,7 +383,19 @@ class Track:
         (remember that a video frame is associated
         with more than 1 audio frame).
         """
-        for frame in self._get_part_at_t(t).get_audio_frames_at(t):
+        frames = (
+            generate_silent_frames(
+                fps = self.fps,
+                audio_fps = self.audio_fps,
+                audio_samples_per_frame = self.audio_samples_per_frame,
+                layout = self.audio_layout,
+                format = self.audio_format
+            )
+            if self.is_muted else
+            self._get_part_at_t(t).get_audio_frames_at(t)
+        )
+
+        for frame in frames:
             yield frame
     
     def add_video(
@@ -404,7 +424,8 @@ class Track:
             # TODO: We can have many different strategies
             # that we could define in the '__init__' maybe
             t: T = T.from_fps(t, self.fps)
-            if not self._is_free(t.truncated, t.next(1).truncated):
+            #if not self._is_free(t.truncated, t.next(1).truncated):
+            if not self._is_free(t.truncated, t.truncated + video.duration):
                 raise Exception('The video cannot be added at the "t" time moment, something blocks it.')
             t = t.truncated
         else:
@@ -464,4 +485,78 @@ class Track:
 
         self._parts = parts
 
-        return self
+        return self
+    
+# TODO: Is this method here ok (?)
+def generate_silent_frames(
+    fps: int,
+    audio_fps: int,
+    audio_samples_per_frame: int,
+    layout: str = 'stereo',
+    format: str = 'fltp'
+) -> list[AudioFrameWrapped]:
+    """
+    Get the audio silent frames we need for
+    a video with the given 'fps', 'audio_fps'
+    and 'audio_samples_per_frame', using the
+    also provided 'layout' and 'format' for
+    the audio frames.
+
+    This method is used when we have empty
+    parts on our tracks and we need to 
+    provide the frames, that are passed as
+    AudioFrameWrapped instances and tagged as
+    coming from empty parts.
+    """
+    audio_frame_generator: AudioFrameGenerator = AudioFrameGenerator()
+
+    # Check how many full and partial silent
+    # audio frames we need
+    number_of_frames, number_of_remaining_samples = audio_frames_and_remainder_per_video_frame(
+        video_fps = fps,
+        sample_rate = audio_fps,
+        number_of_samples_per_audio_frame = audio_samples_per_frame
+    )
+
+    # The complete silent frames we need
+    silent_frame = audio_frame_generator.silent(
+        sample_rate = audio_fps,
+        layout = layout,
+        number_of_samples = audio_samples_per_frame,
+        format = format,
+        pts = None,
+        time_base = None
+    )
+    
+    frames = (
+        [
+            AudioFrameWrapped(
+                frame = silent_frame,
+                is_from_empty_part = True
+            )
+        ] * number_of_frames
+        if number_of_frames > 0 else
+        []
+    )
+
+    # The remaining partial silent frames we need
+    if number_of_remaining_samples > 0:
+        silent_frame = audio_frame_generator.silent(
+            sample_rate = audio_fps,
+            # TODO: Check where do we get this value from
+            layout = layout,
+            number_of_samples = number_of_remaining_samples,
+            # TODO: Check where do we get this value from
+            format = format,
+            pts = None,
+            time_base = None
+        )
+        
+        frames.append(
+            AudioFrameWrapped(
+                frame = silent_frame,
+                is_from_empty_part = True
+            )
+        )
+
+    return frames

{yta_video_opengl-0.0.18 → yta_video_opengl-0.0.19}/src/yta_video_opengl/tests.py

@@ -601,15 +601,25 @@ def video_modified_stored():
     # must be played at the same time
     video = Video(VIDEO_PATH, 0.25, 0.75)
     timeline = Timeline()
-    timeline.add_video(Video(VIDEO_PATH, 0.25, 1.0), 0.75)
-    timeline.add_video(Video('C:/Users/dania/Downloads/Y2meta.app-10 Smooth Transitions Green Screen Template For Kinemaster, Alight Motion, Filmora, premiere pro-(1080p).mp4', 1.5, 2.0), 3.0)
-    timeline.add_video(Video(VIDEO_PATH, 0.5, 1.0), 2.0)
-    timeline.add_video(Video(VIDEO_PATH, 0.5, 1.0), 2.1, do_use_second_track = True)
+
+    transitions_30fps = 'C:/Users/dania/Downloads/Y2meta.app-10 Smooth Transitions Green Screen Template For Kinemaster, Alight Motion, Filmora, premiere pro-(1080p).mp4'
+    simpsons_60fps = 'C:/Users/dania/Downloads/Y_una_porra_los_simpsons_castellano_60fps.mp4'
+
+    # Track 1
+    timeline.add_video(Video(VIDEO_PATH, 0.25, 1.0), 0.75, track_index = 0)
+    timeline.add_video(Video(simpsons_60fps, 1.5, 2.0), 3.0, track_index = 0)
+    timeline.add_video(Video(VIDEO_PATH, 0.5, 1.0), 2.0, track_index = 0)
+
+    timeline.tracks[0].mute()
+
+    # Track 2
+    timeline.add_video(Video(VIDEO_PATH, 0.5, 1.0), 2.7, track_index = 1)
+    timeline.add_video(Video(simpsons_60fps, 5.8, 7.8), 0.6, track_index = 1)
     # 30fps
     # timeline.add_video(Video('C:/Users/dania/Downloads/Y2meta.app-TOP 12 SIMPLE LIQUID TRANSITION _ GREEN SCREEN TRANSITION PACK-(1080p60).mp4', 0.25, 1.5), 0.25, do_use_second_track = True)
     # 29.97fps
     # timeline.add_video(Video('C:/Users/dania/Downloads/Y_una_porra_los_simpsons_castellano.mp4', 5.8, 6.8), 3.6, do_use_second_track = True)
-    timeline.add_video(Video('C:/Users/dania/Downloads/Y_una_porra_los_simpsons_castellano_60fps.mp4', 5.8, 7.8), 3.6, do_use_second_track = True)
+    
     timeline.render(OUTPUT_PATH)
 
     return