yta-video-opengl 0.0.12__py3-none-any.whl → 0.0.14__py3-none-any.whl

yta_video_opengl/complete/timeline.py

@@ -12,9 +12,10 @@ video written).
 """
 from yta_video_opengl.complete.track import Track
 from yta_video_opengl.video import Video
+from yta_video_opengl.t import get_ts, fps_to_time_base, T
 from yta_validation.parameter import ParameterValidator
+from quicktions import Fraction
 from typing import Union
-from fractions import Fraction
 
 
 class Timeline:
@@ -27,7 +28,7 @@ class Timeline:
     @property
     def end(
         self
-    ) -> float:
+    ) -> Fraction:
         """
         The end of the last video of the track
         that lasts longer. This is the last time
@@ -41,11 +42,11 @@ class Timeline:
     def __init__(
         self,
         size: tuple[int, int] = (1_920, 1_080),
-        fps: float = 60.0,
-        audio_fps: float = 44_100.0, # 48_000.0 for aac
+        fps: Union[int, float, Fraction] = 60.0,
+        audio_fps: Union[int, Fraction] = 44_100.0, # 48_000.0 for aac
         # TODO: I don't like this name
         # TODO: Where does this come from (?)
-        audio_nb_samples: int = 1024
+        audio_samples_per_frame: int = 1024
     ):
         # TODO: By now we are using just two video
         # tracks to test the composition
@@ -59,7 +60,7 @@ class Timeline:
                 audio_fps = audio_fps,
                 # TODO: I need more info about the audio
                 # I think
-                audio_nb_samples = audio_nb_samples
+                audio_samples_per_frame = audio_samples_per_frame
             ),
             Track(
                 size = size,
@@ -67,7 +68,7 @@ class Timeline:
                 audio_fps = audio_fps,
                 # TODO: I need more info about the audio
                 # I think
-                audio_nb_samples = audio_nb_samples
+                audio_samples_per_frame = audio_samples_per_frame
             )
         ]
         """
@@ -83,7 +84,7 @@ class Timeline:
     def add_video(
         self,
         video: Video,
-        t: float,
+        t: Union[int, float, Fraction],
         # TODO: This is for testing, it has to
         # disappear
         do_use_second_track: bool = False
@@ -110,7 +111,7 @@ class Timeline:
     # have consecutive elements
     def get_frame_at(
         self,
-        t: float
+        t: Union[int, float, Fraction]
     ) -> 'VideoFrame':
         """
         Get all the frames that are played at the
@@ -155,8 +156,8 @@ class Timeline:
     def render(
         self,
         filename: str,
-        start: float = 0.0,
-        end: Union[float, None] = None
+        start: Union[int, float, Fraction] = 0.0,
+        end: Union[int, float, Fraction, None] = None
     ) -> 'Timeline':
         """
         Render the time range in between the given
@@ -167,8 +168,10 @@ class Timeline:
         project will be rendered.
         """
         ParameterValidator.validate_mandatory_string('filename', filename, do_accept_empty = False)
-        ParameterValidator.validate_mandatory_positive_number('start', start, do_include_zero = True)
-        ParameterValidator.validate_positive_number('end', end, do_include_zero = False)
+        # TODO: We need to accept Fraction as number
+        #ParameterValidator.validate_mandatory_positive_number('start', start, do_include_zero = True)
+        # TODO: We need to accept Fraction as number
+        #ParameterValidator.validate_positive_number('end', end, do_include_zero = False)
 
         # TODO: Limitate 'end' a bit...
         end = (
@@ -181,7 +184,6 @@ class Timeline:
             raise Exception('The provided "start" cannot be greater or equal to the "end" provided.')
 
         from yta_video_opengl.writer import VideoWriter
-        from yta_video_opengl.utils import get_black_background_video_frame, get_silent_audio_frame
 
         writer = VideoWriter('test_files/output_render.mp4')
         # TODO: This has to be dynamic according to the
@@ -197,17 +199,34 @@ class Timeline:
             codec_name = 'aac',
             fps = self.audio_fps
         )
+
+        time_base = fps_to_time_base(self.fps)
+        audio_time_base = fps_to_time_base(self.audio_fps)
+
+        """
+        We are trying to render this:
+        -----------------------------
+        [0 a 0.5) => Frames negros
+        [0.5 a 1.25) => [0.25 a 1.0) de Video1
+        [1.25 a 1.75) => Frames negros
+        [1.75 a 2.25) => [0.25 a 0.75) de Video1
+        [2.25 a 3.0) => Frames negros
+        [3.0 a 3.75) => [2.25 a 3.0) de Video2
+        """
         
         audio_pts = 0
         for t in get_ts(start, end, self.fps):
             frame = self.get_frame_at(t)
 
+            print(f'Getting t:{str(float(t))}')
+            #print(frame)
+
             # We need to adjust our output elements to be
             # consecutive and with the right values
             # TODO: We are using int() for fps but its float...
-            frame.time_base = Fraction(1, int(self.fps))
+            frame.time_base = time_base
             #frame.pts = int(video_frame_index / frame.time_base)
-            frame.pts = int(t / frame.time_base)
+            frame.pts = T(t, time_base).truncated_pts
 
             # TODO: We need to handle the audio
             writer.mux_video_frame(
@@ -216,6 +235,7 @@ class Timeline:
 
             #print(f'    [VIDEO] Here in t:{str(t)} -> pts:{str(frame.pts)} - dts:{str(frame.dts)}')
 
+            # TODO: Uncomment all this below for the audio
             num_of_audio_frames = 0
             for audio_frame in self.get_audio_frames_at(t):
                 # TODO: The track gives us empty (black)
@@ -229,7 +249,7 @@ class Timeline:
                 # We need to adjust our output elements to be
                 # consecutive and with the right values
                 # TODO: We are using int() for fps but its float...
-                audio_frame.time_base = Fraction(1, int(self.audio_fps))
+                audio_frame.time_base = audio_time_base
                 #audio_frame.pts = int(audio_frame_index / audio_frame.time_base)
                 audio_frame.pts = audio_pts
                 # We increment for the next iteration
@@ -238,34 +258,11 @@ class Timeline:
 
                 #print(f'[AUDIO] Here in t:{str(t)} -> pts:{str(audio_frame.pts)} - dts:{str(audio_frame.dts)}')
 
-                num_of_audio_frames += 1
-                print(audio_frame)
+                #num_of_audio_frames += 1
+                #print(audio_frame)
                 writer.mux_audio_frame(audio_frame)
-            print(f'Num of audio frames: {str(num_of_audio_frames)}')
+            #print(f'Num of audio frames: {str(num_of_audio_frames)}')
 
         writer.mux_video_frame(None)
         writer.mux_audio_frame(None)
-        writer.output.close()
-
-
-# TODO: I don't want to have this here
-def get_ts(
-    start: float,
-    end: float,
-    fps: int
-):
-    """
-    Obtain, without using a Progression class and
-    importing the library, a list of 't' time
-    moments from the provided 'start' to the also
-    given 'end', with the 'fps' given as parameter.
-    """
-    dt = 1.0 / fps
-    times = []
-
-    t = start
-    while t <= end:
-        times.append(t + 0.000001)
-        t += dt
-
-    return times
+        writer.output.close()

yta_video_opengl/complete/track.py

@@ -1,8 +1,10 @@
 from yta_video_opengl.complete.video_on_track import VideoOnTrack
 from yta_video_opengl.video import Video
-from yta_video_frame_time import T
+from yta_video_opengl.t import T
 from yta_video_opengl.utils import get_black_background_video_frame, get_silent_audio_frame, audio_frames_and_remainder_per_video_frame
+from yta_video_opengl.t import fps_to_time_base
 from yta_validation.parameter import ParameterValidator
+from quicktions import Fraction
 from typing import Union
 
 
@@ -33,12 +35,14 @@ class _Part:
     def __init__(
         self,
         track: 'Track',
-        start: float,
-        end: float,
+        start: Union[int, float, Fraction],
+        end: Union[int, float, Fraction],
         video: Union[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)
+        # TODO: We need to accept Fraction as number
+        # ParameterValidator.validate_mandatory_positive_number('start', start, do_include_zero = True)
+        # TODO: We need to accept Fraction as number
+        # ParameterValidator.validate_mandatory_positive_number('end', end, do_include_zero = False)
         ParameterValidator.validate_instance_of('video', video, VideoOnTrack)
 
         self._track: Track = track
@@ -46,11 +50,11 @@ class _Part:
         The instance of the track this part belongs
         to.
         """
-        self.start: float = float(start)
+        self.start: Fraction = Fraction(start)
         """
         The start 't' time moment of the part.
         """
-        self.end: float = float(end)
+        self.end: Fraction = Fraction(end)
         """
         The end 't' time moment of the part.
         """
@@ -64,7 +68,7 @@ class _Part:
 
     def get_frame_at(
         self,
-        t: float
+        t: Union[int, float, Fraction]
     ) -> 'VideoFrame':
         """
         Get the frame that must be displayed at 
@@ -72,7 +76,12 @@ class _Part:
         """
         if self.is_empty_part:
             # TODO: What about the 'format' (?)
-            return get_black_background_video_frame(self._track.size)
+            # 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
+            return get_black_background_video_frame(self._track.size, time_base = fps_to_time_base(self._track.fps))
 
         frame = self.video.get_frame_at(t)
 
@@ -85,14 +94,14 @@ class _Part:
             # 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 frame at t={str(t)}.')
+            raise Exception(f'Video is returning None video frame at t={str(t)}.')
         
         return frame
     
     # TODO: I'm not sure if we need this
     def get_audio_frames_at(
         self,
-        t: float
+        t: Union[int, float, Fraction]
     ):
         if not self.is_empty_part:
             frames = self.video.get_audio_frames_at(t)
@@ -101,9 +110,9 @@ class _Part:
             # 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(
-                fps = self._track.fps,
+                video_fps = self._track.fps,
                 sample_rate = self._track.audio_fps,
-                nb_samples = self._track.audio_nb_samples
+                number_of_samples_per_audio_frame = self._track.audio_samples_per_frame
             )
 
             # TODO: I need to set the pts, but here (?)
@@ -114,7 +123,7 @@ class _Part:
                         sample_rate = self._track.audio_fps,
                         # TODO: Check where do we get this value from
                         layout = 'stereo',
-                        nb_samples = self._track.audio_nb_samples,
+                        number_of_samples = self._track.audio_samples_per_frame,
                         # TODO: Check where do we get this value from
                         format = 'fltp'
                     )
@@ -130,7 +139,7 @@ class _Part:
                         sample_rate = self._track.audio_fps,
                         # TODO: Check where do we get this value from
                         layout = 'stereo',
-                        nb_samples = number_of_remaining_samples,
+                        number_of_samples = number_of_remaining_samples,
                         # TODO: Check where do we get this value from
                         format = 'fltp'
                     )
@@ -176,14 +185,14 @@ class Track:
     @property
     def end(
         self
-    ) -> float:
+    ) -> Fraction:
         """
         The end of the last video of this track,
         which is also the end of the track. This
         is the last time moment that has to be
         rendered.
         """
-        return (
+        return Fraction(
             0.0
             if len(self.videos) == 0 else
             max(
@@ -200,8 +209,8 @@ class Track:
         size: tuple[int, int],
         fps: float,
         audio_fps: float,
-        # TODO: Change the name
-        audio_nb_samples: int
+        # TODO: Where does it come from (?)
+        audio_samples_per_frame: int
     ):
         self.videos: list[VideoOnTrack] = []
         """
@@ -212,26 +221,26 @@ class Track:
         """
         The size of the videos of this track.
         """
-        self.fps: float = fps
+        self.fps: float = float(fps)
         """
         The fps of the track, needed to calculate
         the base t time moments to be precise and
         to obtain or generate the frames.
         """
-        self.audio_fps: float = audio_fps
+        self.audio_fps: float = float(audio_fps)
         """
         The fps of the audio track, needed to 
         generate silent audios for the empty parts.
         """
-        self.audio_nb_samples: int = audio_nb_samples
+        self.audio_samples_per_frame: int = audio_samples_per_frame
         """
         The number of samples per audio frame.
         """
 
     def _is_free(
         self,
-        start: float,
-        end: float
+        start: Union[int, float, Fraction],
+        end: Union[int, float, Fraction]
     ) -> bool:
         """
         Check if the time range in between the 
@@ -248,7 +257,7 @@ class Track:
     
     def _get_part_at_t(
         self,
-        t: float
+        t: Union[int, float, Fraction]
     ) -> _Part:
         """
         Get the part at the given 't' time
@@ -269,7 +278,7 @@ class Track:
 
     def get_frame_at(
         self,
-        t: float
+        t: Union[int, float, Fraction]
     ) -> 'VideoFrame':
         """
         Get the frame that must be displayed at
@@ -289,7 +298,7 @@ class Track:
     # TODO: This is not working well...
     def get_audio_frames_at(
         self,
-        t: float
+        t: Union[int, float, Fraction]
     ):
         """
         Get the sequence of audio frames that
@@ -316,7 +325,7 @@ class Track:
     def add_video(
         self,
         video: Video,
-        t: Union[float, None] = None
+        t: Union[int, float, Fraction, None] = None
     ) -> 'Track':
         """
         Add the 'video' provided to the track. If
@@ -338,11 +347,10 @@ class Track:
         if t is not None:
             # TODO: We can have many different strategies
             # that we could define in the '__init__' maybe
-            # TODO: I don't like using float 't', but we
-            # need to make sure it is a multiple of 1 / fps
-            t = T.get_frame_time_base(float(t), self.fps)
-            if not self._is_free(t, (t + video.end)):
+            t: T = T.from_fps(t, self.fps)
+            if not self._is_free(t.truncated, t.next(1).truncated):
                 raise Exception('The video cannot be added at the "t" time moment, something blocks it.')
+            t = t.truncated
         else:
             t = self.end
         

yta_video_opengl/complete/video_on_track.py

@@ -17,6 +17,7 @@ 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 quicktions import Fraction
 from typing import Union
 
 
@@ -28,7 +29,7 @@ class VideoOnTrack:
     @property
     def end(
         self
-    ) -> float:
+    ) -> Fraction:
         """
         The end time moment 't' of the video once
         once its been placed on the track, which
@@ -42,17 +43,20 @@ class VideoOnTrack:
     def __init__(
         self,
         video: Video,
-        start: float = 0.0
+        start: Union[int, float, Fraction] = 0.0
     ):
         ParameterValidator.validate_mandatory_instance_of('video', video, Video)
-        ParameterValidator.validate_mandatory_positive_number('start', start, do_include_zero = True)
+        # TODO: Now we need to accept 'Fraction',
+        # from 'fractions' or 'quicktions', as a
+        # number
+        #ParameterValidator.validate_mandatory_positive_number('start', start, do_include_zero = True)
 
         self.video: Video = video
         """
         The video source, with all its properties,
         that is placed in the timeline.
         """
-        self.start: float = float(start)
+        self.start: Fraction = Fraction(start)
         """
         The time moment in which the video should
         start playing, within the timeline.
@@ -64,7 +68,7 @@ class VideoOnTrack:
 
     def _get_video_t(
         self,
-        t: float
+        t: Union[int, float, Fraction]
     ) -> float:
         """
         The video 't' time moment for the given
@@ -72,52 +76,60 @@ class VideoOnTrack:
         to use inside the video content to display
         its frame.
         """
+        # TODO: Use 'T' here to be precise or the
+        # argument itself must be precise (?)
         return t - self.start
 
     def is_playing(
         self,
-        t: float
+        t: Union[int, float, Fraction]
     ) -> bool:
         """
         Check if this video 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 (?)
         return self.start <= t < self.end
 
     def get_frame_at(
         self,
-        t: float
+        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.reader.get_frame_from_t(self._get_video_t(t))
+            self.video.get_frame_from_t(self._get_video_t(t))
             if self.is_playing(t) else
             None
         )
     
     def get_audio_frame_at(
         self,
-        t: float
+        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
         is not playing in that moment.
         """
+        # TODO: Use 'T' here to be precise or the
+        # argument itself must be precise (?)
         return (
-            self.video.reader.get_audio_frame_from_t(self._get_video_t(t))
+            self.video.get_audio_frame_from_t(self._get_video_t(t))
             if self.is_playing(t) else
             None
         )
     
     def get_audio_frames_at(
         self,
-        t: float
+        t: Union[int, float, Fraction]
     ) -> Union[any, None]:
         """
         Get the audio frames that must be played at
@@ -129,17 +141,16 @@ class VideoOnTrack:
         frames found in that 't' time moment, or an
         iterator if yes.
         """
+        # TODO: Use 'T' here to be precise or the
+        # argument itself must be precise (?)
         frames = (
-            self.video.reader.get_audio_frames_from_t(self._get_video_t(t))
+            self.video.get_audio_frames_from_t(self._get_video_t(t))
             if self.is_playing(t) else
             []
         )
 
         for frame in frames:
-            # TODO: I am generating a tuple in the
-            # src\yta_video_opengl\reader\cache.py
-            # get_frames method... maybe remove it (?)
-            yield frame[0]
+            yield frame
 
         # # TODO: This was a simple return before
         # return (