yta-video-opengl 0.0.19__py3-none-any.whl → 0.0.21__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,267 @@
+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 _PartWithAudio(_Part):
+    """
+    TODO: Explain
+    """
+
+    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_instance_of('media', media, [AudioOnTrack, VideoOnTrack])
+
+        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.
+        """
+        frames = []
+        if not self.is_empty_part:
+            # TODO: What do we do in this case (?)
+            frames = list(self.media.get_audio_frames_at(t))
+
+            if len(frames) == 0:
+                print(f'   [ERROR] Audio frame {str(float(t))} was not obtained')
+            else:
+                frames = [
+                    AudioFrameWrapped(
+                        frame = frame,
+                        is_from_empty_part = False
+                    )
+                    for frame in frames
+                ]
+
+        # This could be because is empty part or
+        # because we couldn't obtain the frames
+        if len(frames) == 0:
+            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 _PartWithVideo(_Part):
+    """
+    TODO: Explain
+    """
+
+    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.
+        """
+
+    def get_frame_at(
+        self,
+        t: Union[int, float, Fraction]
+    ) -> 'VideoFrameWrapped':
+        """
+        Get the frame that must be displayed at 
+        the given 't' time moment.
+        """
+        is_from_empty_part = False
+        if self.is_empty_part:
+            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
+        else:
+            # TODO: This can be None, why? I don't know...
+            frame = self.media.get_frame_at(t)
+
+            if frame is None:
+                print(f'   [ERROR] Frame {str(float(t))} was not obtained')
+
+            frame = (
+                # I'm using a red full frame to be able to detect
+                # fast the frames that were not available, but
+                # I need to find the error and find a real solution
+                self._video_frame_generator.background.full_red(
+                    size = self._track.size,
+                    time_base = fps_to_time_base(self._track.fps)
+                )
+                if frame is None else
+                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
+        frame = VideoFrameWrapped(
+            frame = frame,
+            is_from_empty_part = is_from_empty_part
+        )
+
+        # 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
+
+class _AudioPart(_PartWithAudio):
+    """
+    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
+        )
+
+class _VideoPart(_PartWithAudio, _PartWithVideo):
+    """
+    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
+        )

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/__init__.py

@@ -155,11 +155,15 @@ class FrameCache(ABC):
         seek and start decoding frames from that
         keyframe.
         """
-        return max([
-            key_frame_pts
-            for key_frame_pts in self.key_frames_pts
-            if key_frame_pts <= pts
-        ])
+        return max(
+            (
+                key_frame_pts
+                for key_frame_pts in self.key_frames_pts
+                if key_frame_pts <= pts
+            ),
+            # If no key frames, just 0
+            default = 0
+        )
 
     def _store_frame_in_cache(
         self,

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)))