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

yta_video_opengl/complete/{video_on_track.py → track/media/__init__.py}

@@ -13,17 +13,21 @@ at `t=2` and it has been playing during 1s
 it started at `t=2`, lasting 2s, so it
 finished at `t=4`
 """
+from yta_video_opengl.audio import Audio
 from yta_video_opengl.video import Video
 from yta_validation.parameter import ParameterValidator
-from av.video.frame import VideoFrame
 from av.audio.frame import AudioFrame
+from av.video.frame import VideoFrame
 from quicktions import Fraction
 from typing import Union
+from abc import ABC
 
 
-class VideoOnTrack:
+class _MediaOnTrack(ABC):
     """
-    A video in the timeline.
+    Class to be inherited by any media class
+    that will be placed on a track and should
+    manage this condition.
     """
 
     @property
@@ -31,50 +35,49 @@ class VideoOnTrack:
         self
     ) -> Fraction:
         """
-        The end time moment 't' of the video once
+        The end time moment 't' of the audio once
         once its been placed on the track, which
-        is affected by the video duration and its
+        is affected by the audio duration and its
         start time moment on the track.
 
-        This end is different from the video end.
+        This end is different from the audio end.
         """
-        return self.start + self.video.duration
+        return self.start + self.media.duration
 
     def __init__(
         self,
-        video: Video,
+        media: Union[Audio, Video],
         start: Union[int, float, Fraction] = 0.0
     ):
-        ParameterValidator.validate_mandatory_instance_of('video', video, Video)
+        ParameterValidator.validate_mandatory_instance_of('media', media, [Audio, Video])
         ParameterValidator.validate_mandatory_positive_number('start', start, do_include_zero = True)
 
-        self.video: Video = video
+        self.media: Union[Audio, Video] = media
         """
-        The video source, with all its properties,
+        The media source, with all its properties,
         that is placed in the timeline.
         """
         self.start: Fraction = Fraction(start)
         """
-        The time moment in which the video should
+        The time moment in which the media should
         start playing, within the timeline.
 
         This is the time respect to the timeline
-        and its different from the video `start`
+        and its different from the media `start`
         time, which is related to the file.
         """
 
-    def _get_video_t(
+    def _get_t(
         self,
         t: Union[int, float, Fraction]
     ) -> float:
         """
-        The video 't' time moment for the given
+        The media 't' time moment for the given
         global 't' time moment. This 't' is the one
-        to use inside the video content to display
+        to use inside the media content to display
         its frame.
         """
-        # TODO: Use 'T' here to be precise or the
-        # argument itself must be precise (?)
+        # TODO: Should we make sure 't' is truncated (?)
         return t - self.start
 
     def is_playing(
@@ -82,48 +85,48 @@ class VideoOnTrack:
         t: Union[int, float, Fraction]
     ) -> bool:
         """
-        Check if this video is playing at the general
+        Check if this media is playing at the general
         't' time moment, which is a global time moment
         for the whole project.
         """
-        # TODO: Use 'T' here to be precise or the
-        # argument itself must be precise (?)
+        # TODO: Should we make sure 't' is truncated (?)
         return self.start <= t < self.end
+    
+class _MediaOnTrackWithAudio(_MediaOnTrack):
+    """
+    Class that implements the ability of
+    getting audio frames. This class must
+    be inherited by any other class that
+    has this same ability.
+    """
 
-    def get_frame_at(
+    def __init__(
         self,
-        t: Union[int, float, Fraction]
-    ) -> Union[VideoFrame, None]:
-        """
-        Get the frame for the 't' time moment provided,
-        that could be None if the video is not playing
-        in that moment.
-        """
-        # TODO: Use 'T' here to be precise or the
-        # argument itself must be precise (?)
-        return (
-            self.video.get_frame_from_t(self._get_video_t(t))
-            if self.is_playing(t) else
-            None
+        media: Union[Audio, Video],
+        start: Union[int, float, Fraction] = 0.0
+    ):
+        super().__init__(
+            media = media,
+            start = start
         )
-    
+
     def get_audio_frame_at(
         self,
         t: Union[int, float, Fraction]
     ) -> Union[AudioFrame, None]:
         """
         Get the audio frame for the 't' time moment
-        provided, that could be None if the video
+        provided, that could be None if the media
         is not playing in that moment.
         """
         # TODO: Use 'T' here to be precise or the
         # argument itself must be precise (?)
         return (
-            self.video.get_audio_frame_from_t(self._get_video_t(t))
+            self.media.get_audio_frame_from_t(self._get_t(t))
             if self.is_playing(t) else
             None
         )
-    
+
     def get_audio_frames_at(
         self,
         t: Union[int, float, Fraction]
@@ -131,7 +134,7 @@ class VideoOnTrack:
         """
         Get the audio frames that must be played at
         the 't' time moment provided, that could be
-        None if the video is not playing at that
+        None if the audio is not playing at that
         moment.
 
         This method will return None if no audio
@@ -141,7 +144,7 @@ class VideoOnTrack:
         # TODO: Use 'T' here to be precise or the
         # argument itself must be precise (?)
         frames = (
-            self.video.get_audio_frames_from_t(self._get_video_t(t))
+            self.media.get_audio_frames_from_t(self._get_t(t))
             if self.is_playing(t) else
             []
         )
@@ -149,9 +152,71 @@ class VideoOnTrack:
         for frame in frames:
             yield frame
 
-        # # TODO: This was a simple return before
-        # return (
-        #     self.video.reader.get_audio_frames_from_t(self._get_video_t(t))
-        #     if self.is_playing(t) else
-        #     None
-        # )
+class _MediaOnTrackWithVideo(_MediaOnTrack):
+    """
+    Class that implements the ability of
+    getting video frames. This class must
+    be inherited by any other class that
+    has this same ability.
+    """
+
+    def __init__(
+        self,
+        media: Video,
+        start: Union[int, float, Fraction] = 0.0
+    ):
+        super().__init__(
+            media = media,
+            start = start
+        )
+
+    def get_frame_at(
+        self,
+        t: Union[int, float, Fraction]
+    ) -> Union[VideoFrame, None]:
+        """
+        Get the frame for the 't' time moment provided,
+        that could be None if the video is not playing
+        in that moment.
+        """
+        # TODO: Use 'T' here to be precise or the
+        # argument itself must be precise (?)
+        return (
+            self.media.get_frame_from_t(self._get_t(t))
+            if self.is_playing(t) else
+            None
+        )
+    
+class AudioOnTrack(_MediaOnTrackWithAudio):
+    """
+    A video in the timeline.
+    """
+
+    def __init__(
+        self,
+        media: Audio,
+        start: Union[int, float, Fraction] = 0.0
+    ):
+        ParameterValidator.validate_mandatory_instance_of('media', media, Audio)
+
+        super().__init__(
+            media = media,
+            start = start
+        )
+
+class VideoOnTrack(_MediaOnTrackWithAudio, _MediaOnTrackWithVideo):
+    """
+    A video in the timeline.
+    """
+
+    def __init__(
+        self,
+        media: Video,
+        start: Union[int, float, Fraction] = 0.0
+    ):
+        ParameterValidator.validate_mandatory_instance_of('media', media, Video)
+
+        super().__init__(
+            media = media,
+            start = start
+        )

yta_video_opengl/complete/track/parts.py

@@ -0,0 +1,230 @@
+from yta_video_opengl.complete.track.media import AudioOnTrack, VideoOnTrack
+from yta_video_opengl.complete.track.utils import generate_silent_frames
+from yta_video_opengl.complete.frame_wrapper import AudioFrameWrapped
+from yta_video_opengl.complete.frame_wrapper import VideoFrameWrapped
+from yta_video_opengl.complete.frame_generator import VideoFrameGenerator, AudioFrameGenerator
+from yta_video_opengl.t import fps_to_time_base
+from yta_validation.parameter import ParameterValidator
+from quicktions import Fraction
+from typing import Union
+from abc import ABC
+
+
+NON_LIMITED_EMPTY_PART_END = 999
+"""
+A value to indicate that the empty part
+has no end because it is in the last
+position and there is no video after it.
+"""
+
+class _Part(ABC):
+    """
+    Abstract class to represent an element
+    that is on the track, that can be an
+    empty space or a vide or audio. This
+    class must be inherited by our own
+    custom part classes.
+    """
+
+    @property
+    def is_empty_part(
+        self
+    ) -> bool:
+        """
+        Flag to indicate if the part is an empty part,
+        which means that there is no media associated
+        but an empty space.
+        """
+        return self.media is None
+
+    def __init__(
+        self,
+        track: Union['AudioTrack', 'VideoTrack'],
+        start: Union[int, float, Fraction],
+        end: Union[int, float, Fraction],
+        media: Union[AudioOnTrack, VideoOnTrack, None] = None
+    ):
+        ParameterValidator.validate_mandatory_positive_number('start', start, do_include_zero = True)
+        ParameterValidator.validate_mandatory_positive_number('end', end, do_include_zero = False)
+        ParameterValidator.validate_instance_of('audimediao', media, [AudioOnTrack, VideoOnTrack])
+
+        self._track: Union['AudioTrack', 'VideoTrack'] = track
+        """
+        The instance of the track this part belongs
+        to.
+        """
+        self.start: Fraction = Fraction(start)
+        """
+        The start 't' time moment of the part.
+        """
+        self.end: Fraction = Fraction(end)
+        """
+        The end 't' time moment of the part.
+        """
+        self.media: Union[AudioOnTrack, VideoOnTrack, None] = media
+        """
+        The media associated, if existing, or
+        None if it is an empty space that we need
+        to fulfill.
+        """
+
+class _AudioPart(_Part):
+    """
+    Class to represent an element that is on the
+    track, that can be an empty space or an audio.
+    """
+
+    def __init__(
+        self,
+        track: 'AudioTrack',
+        start: Union[int, float, Fraction],
+        end: Union[int, float, Fraction],
+        media: Union[AudioOnTrack, None] = None
+    ):
+        ParameterValidator.validate_instance_of('media', media, AudioOnTrack)
+
+        super().__init__(
+            track = track,
+            start = start,
+            end = end,
+            media = media
+        )
+
+        # TODO: Can I refactor this below (?)
+        self._audio_frame_generator: AudioFrameGenerator = AudioFrameGenerator()
+        """
+        Useful internal tool to generate silent
+        audio frames for the empty parts.
+        """
+
+    def get_audio_frames_at(
+        self,
+        t: Union[int, float, Fraction]
+    ):
+        """
+        Iterate over all the audio frames that
+        exist at the time moment 't' provided.
+        """
+        if not self.is_empty_part:
+            for frame in self.media.get_audio_frames_at(t):
+                yield AudioFrameWrapped(
+                    frame = frame,
+                    is_from_empty_part = False
+                )
+        else:
+            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
+            )
+
+            for frame in frames:
+                yield frame
+
+class _VideoPart(_Part):
+    """
+    Class to represent an element that is on the
+    track, that can be an empty space or a video.
+    """
+
+    def __init__(
+        self,
+        track: 'VideoTrack',
+        start: Union[int, float, Fraction],
+        end: Union[int, float, Fraction],
+        media: Union[VideoOnTrack, None] = None
+    ):
+        ParameterValidator.validate_instance_of('media', media, VideoOnTrack)
+
+        super().__init__(
+            track = track,
+            start = start,
+            end = end,
+            media = media
+        )
+
+        # TODO: Can I refactor this below (?)
+        self._video_frame_generator: VideoFrameGenerator = VideoFrameGenerator()
+        """
+        Useful internal tool to generate background
+        frames for the empty parts.
+        """
+        # TODO: Can I refactor this below (?)
+        self._audio_frame_generator: AudioFrameGenerator = AudioFrameGenerator()
+        """
+        Useful internal tool to generate silent
+        audio frames for the empty parts.
+        """
+
+    def get_frame_at(
+        self,
+        t: Union[int, float, Fraction]
+    ) -> 'VideoFrameWrapped':
+        """
+        Get the frame that must be displayed at 
+        the given 't' time moment.
+        """
+        frame = (
+            # TODO: What about the 'format' (?)
+            # TODO: Maybe I shouldn't set the 'time_base'
+            # here and do it just in the Timeline 'render'
+            #return get_black_background_video_frame(self._track.size)
+            # TODO: This 'time_base' maybe has to be related
+            # to a Timeline general 'time_base' and not the fps
+            VideoFrameWrapped(
+                frame = self._video_frame_generator.background.full_black(
+                    size = self._track.size,
+                    time_base = fps_to_time_base(self._track.fps)
+                ),
+                is_from_empty_part = True
+            )
+            if self.is_empty_part else
+            VideoFrameWrapped(
+                frame = self.media.get_frame_at(t),
+                is_from_empty_part = False
+            )
+        )
+
+        # TODO: This should not happen because of
+        # the way we handle the videos here but the
+        # video could send us a None frame here, so
+        # do we raise exception (?)
+        if frame._frame is None:
+            #frame = get_black_background_video_frame(self._track.size)
+            # TODO: By now I'm raising exception to check if
+            # this happens or not because I think it would
+            # be malfunctioning
+            raise Exception(f'Video is returning None video frame at t={str(t)}.')
+        
+        return frame
+
+    def get_audio_frames_at(
+        self,
+        t: Union[int, float, Fraction]
+    ):
+        """
+        Iterate over all the audio frames that
+        exist at the time moment 't' provided.
+        """
+        if not self.is_empty_part:
+            for frame in self.media.get_audio_frames_at(t):
+                yield AudioFrameWrapped(
+                    frame = frame,
+                    is_from_empty_part = False
+                )
+        else:
+            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
+            )
+
+            for frame in frames:
+                yield frame
+

yta_video_opengl/complete/track/utils.py

@@ -0,0 +1,78 @@
+from yta_video_opengl.complete.frame_wrapper import AudioFrameWrapped
+from yta_video_opengl.complete.frame_generator import AudioFrameGenerator
+from yta_video_opengl.utils import audio_frames_and_remainder_per_video_frame
+
+
+# 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/reader/__init__.py

@@ -696,25 +696,6 @@ class VideoReader:
         self.container.close()
 
 
-# TODO: I think I'm not using this...
-# Remove it please
-def audio_ts_for_video_t(
-    t: float,
-    video_fps: float,
-    audio_fps: float
-):
-    # Remember, from [t_start, t_end), the last one
-    # is not included
-    audio_t_start = int(t * audio_fps)
-    audio_t_end = int((t + 1.0 / video_fps) * audio_fps)
-
-    return [
-        i / audio_fps
-        for i in range(audio_t_start, audio_t_end)
-    ]
-
-
-
 """
 When reading packets directly from the stream
 we can receive packets with size=0, but we need

yta_video_opengl/reader/cache/utils.py

@@ -40,7 +40,7 @@ def trim_audio_frame(
         layout = frame.layout
     )
 
-    # Set attributes
+    # Set needed attributes
     new_frame.sample_rate = frame.sample_rate
     new_frame.time_base = time_base
     new_frame.pts = int(round(cut_start / float(time_base)))

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

yta_video_opengl/video.py

@@ -9,7 +9,8 @@ from typing import Union
 # TODO: Where can I obtain this dynamically (?)
 PIXEL_FORMAT = 'yuv420p'
 
-# TODO: Maybe rename to 'Media' (?)
+# TODO: Maybe create a _Media(ABC) to put
+# some code shared with the Audio class
 class Video:
     """
     Class to wrap the functionality related to
@@ -107,11 +108,6 @@ class Video:
         The iterator will iterate first over the
         video frames, and once finished over the
         audio frames.
-
-        This method returns a tuple of 3 elements:
-        - `frame` as a `VideoFrame` instance
-        - `t` as the frame time moment
-        - `index` as the frame index
         """
         for frame in self.reader.get_frames(self.start, self.end):
             yield frame
@@ -155,7 +151,7 @@ class Video:
     # methods because this Video can be subclipped
     # and have a 'start' and' end' that are 
     # different from [0, end)
-    def _get_real_t(
+    def _get_t(
         self,
         t: Union[int, float, Fraction]
     ) -> Fraction:
@@ -183,9 +179,9 @@ class Video:
         Get the video frame with the given 't' time
         moment, using the video cache system.
         """
-        print(f'Getting frame from {str(float(t))} that is actually {str(float(self._get_real_t(t)))}')
-        return self.reader.get_frame(self._get_real_t(t))
-        #return self.reader.video_cache.get_frame(self._get_real_t(t))
+        print(f'Getting frame from {str(float(t))} that is actually {str(float(self._get_t(t)))}')
+        return self.reader.get_frame(self._get_t(t))
+        #return self.reader.video_cache.get_frame(self._get_t(t))
 
     def get_audio_frame_from_t(
         self,
@@ -200,7 +196,7 @@ class Video:
 
         TODO: Is this actually necessary (?)
         """
-        return self.reader.get_audio_frame_from_t(self._get_real_t(t))
+        return self.reader.get_audio_frame_from_t(self._get_t(t))
     
     def get_audio_frames_from_t(
         self,
@@ -217,8 +213,8 @@ class Video:
         (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_real_t(t)))}')
-        for frame in self.reader.get_audio_frames_from_t(self._get_real_t(t)):
+        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(