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

yta_video_opengl/audio.py

@@ -0,0 +1,214 @@
+from yta_video_opengl.reader import VideoReader
+from yta_video_opengl.writer import VideoWriter
+from yta_video_opengl.t import T
+from yta_validation import PythonValidator
+from quicktions import Fraction
+from typing import Union
+
+
+# TODO: Where can I obtain this dynamically (?)
+PIXEL_FORMAT = 'yuv420p'
+
+# TODO: Maybe create a _Media(ABC) to put
+# some code shared with the Video class
+class Audio:
+    """
+    Class to wrap the functionality related to
+    handling and modifying a video.
+    """
+
+    @property
+    def audio_start_pts(
+        self
+    ) -> int:
+        """
+        The start packet time stamp (pts), needed 
+        to optimize the packet iteration process.
+        """
+        # TODO: What if 'audio_time_base' is None (?)
+        return T(self.start, self.reader.audio_time_base).truncated_pts
+    
+    @property
+    def audio_end_pts(
+        self
+    ) -> Union[int, None]:
+        """
+        The end packet time stamp (pts), needed to
+        optimize the packet iteration process.
+        """
+        return (
+            # TODO: What if 'audio_time_base' is None (?)
+            T(self.end, self.reader.audio_time_base).truncated_pts
+            # TODO: What do we do if no duration (?)
+            if self.duration is not None else
+            None
+        )
+    
+    @property
+    def duration(
+        self
+    ) -> Fraction:
+        """
+        The duration of the video.
+        """
+        return self.end - self.start
+    
+    @property
+    def frames(
+        self
+    ):
+        """
+        Iterator to yield all the frames, one by
+        one, within the range defined by the
+        'start' and 'end' parameters provided when
+        instantiating it.
+
+        The iterator will iterate first over the
+        audio frames.
+        """
+        for frame in self.reader.get_audio_frames(self.start, self.end):
+            yield frame
+
+    def __init__(
+        self,
+        filename: str,
+        start: Union[int, float, Fraction] = 0.0,
+        end: Union[int, float, Fraction, None] = None
+    ):
+        self.filename: str = filename
+        """
+        The filename of the original audio.
+        """
+        # TODO: Detect the 'pixel_format' from the
+        # extension (?)
+        self.reader: VideoReader = VideoReader(self.filename)
+        """
+        The pyav audio reader.
+        """
+        self.start: Fraction = Fraction(start)
+        """
+        The time moment 't' in which the audio
+        should start.
+        """
+        self.end: Union[Fraction, None] = Fraction(
+            # TODO: Is this 'end' ok (?)
+            self.reader.duration
+            if end is None else
+            end
+        )
+        """
+        The time moment 't' in which the audio
+        should end.
+        """
+
+    def _get_t(
+        self,
+        t: Union[int, float, Fraction]
+    ) -> Fraction:
+        """
+        Get the real 't' time moment based on the
+        audio 'start' and 'end'. If they were 
+        asking for the t=0.5s but our audio was
+        subclipped to [1.0, 2.0), the 0.5s must be
+        actually the 1.5s of the audio because of
+        the subclipped time range.
+        """
+        t += self.start
+        
+        print(f'Audio real t is {str(float(t))}')
+        if t >= self.end:
+            raise Exception(f'The "t" ({str(t)}) provided is out of range. This audio lasts from [{str(self.start)}, {str(self.end)}).')
+        
+        return t
+
+    def get_audio_frame_from_t(
+        self,
+        t: Union[int, float, Fraction]
+    ) -> 'AudioFrame':
+        """
+        Get the audio frame with the given 't' time
+        moment, using the audio cache system. This
+        method is useful when we need to combine 
+        many different frames so we can obtain them
+        one by one.
+
+        TODO: Is this actually necessary (?)
+        """
+        return self.reader.get_audio_frame_from_t(self._get_t(t))
+    
+    def get_audio_frames_from_t(
+        self,
+        t: Union[int, float, Fraction]
+    ):
+        """
+        Get the sequence of audio frames for a 
+        given video 't' time moment, using the
+        audio cache system.
+
+        This is useful when we want to write a
+        video frame with its audio, so we obtain
+        all the audio frames associated to it
+        (remember that a video frame is associated
+        with more than 1 audio frame).
+        """
+        print(f'Getting audio frames from {str(float(t))} that is actually {str(float(self._get_t(t)))}')
+        for frame in self.reader.get_audio_frames_from_t(self._get_t(t)):
+            yield frame
+
+    def save_as(
+        self,
+        filename: str
+    ) -> 'Video':
+        """
+        Save the audio locally as the given 'filename'.
+
+        TODO: By now we are doing tests inside so the
+        functionality is a manual test. Use it 
+        carefully.
+        """
+        writer = VideoWriter(filename)
+        writer.set_audio_stream_from_template(self.reader.audio_stream)
+
+        from yta_video_opengl.nodes.audio import VolumeAudioNode
+        # Audio from 0 to 1
+        # TODO: This effect 'fn' is shitty
+        def fade_in_fn(t, index, start=0.5, end=1.0):
+            if t < start or t > end:
+                # fuera de la franja: no tocar nada → volumen original (1.0)
+                progress = 1.0
+            else:
+                # dentro de la franja: interpolar linealmente entre 0 → 1
+                progress = (t - start) / (end - start)
+
+            return progress
+
+        #fade_in = SetVolumeAudioNode(lambda t, i: min(1, t / self.duration))
+        fade_in = VolumeAudioNode(lambda t, i: fade_in_fn(t, i, 0.5, 1.0))
+
+        for frame, t, index in self.frames:
+            if PythonValidator.is_instance_of(frame, 'VideoFrame'):
+                print(f'Saving video frame {str(index)}, with t = {str(t)}')
+
+                # TODO: Process any video frame change
+
+                writer.mux_video_frame(
+                    frame = frame
+                )
+            else:
+                print(f'Saving audio frame {str(index)} ({str(round(float(t * self.reader.fps), 2))}), with t = {str(t)}')
+
+                # TODO: Process any audio frame change
+                # Test setting audio
+                frame = fade_in.process(frame, t)
+
+                writer.mux_audio_frame(
+                    frame = frame
+                )
+
+        # Flush the remaining frames to write
+        writer.mux_audio_frame(None)
+        writer.mux_video_frame(None)
+
+        # TODO: Maybe move this to the '__del__' (?)
+        writer.output.close()
+        self.reader.container.close()

yta_video_opengl/complete/timeline.py

@@ -10,13 +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
 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_combinator import AudioFrameCombinator
 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
@@ -59,33 +58,16 @@ 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
-            )
-        ]
+        # TODO: By now I'm having only video
+        # tracks
+        self.tracks: list[VideoTrack] = []
         """
         All the video tracks we are handling.
         """
-        
+
         self.size: tuple[int, int] = size
         """
         The size that the final video must have.
@@ -116,15 +98,62 @@ 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()
+
+    # TODO: This has to be modified to accept
+    # adding an AudioTrack
+    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(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'
+        ))
+
+        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 +162,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_media(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 +275,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 +291,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: