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

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

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

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

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

yta_video_opengl-0.0.20/src/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-0.0.19 → yta_video_opengl-0.0.20}/src/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
@@ -62,7 +61,9 @@ class Timeline:
         # 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.
         """
@@ -100,6 +101,8 @@ class Timeline:
         # 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
@@ -129,9 +132,9 @@ class Timeline:
                 if track.index >= index:
                     track.index += 1
 
-        self.tracks.append(Track(
-            size = self.size,
+        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
@@ -161,7 +164,7 @@ class Timeline:
         """
         ParameterValidator.validate_mandatory_number_between('track_index', track_index, 0, len(self.tracks))
 
-        self.tracks[track_index].add_video(video, t)
+        self.tracks[track_index].add_media(video, t)
 
         return self