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

yta_video_opengl/t.py

@@ -0,0 +1,233 @@
+"""
+This is an example of what a video has:
+- fps = 60
+- time_base = 1 / 15360
+- tick = fps * time_base = 256
+
+So, the first pts is 0 and the second 
+one is 256. The frame 16 will be 3840,
+that is 256 * 15 (because first index
+is 0).
+"""
+from yta_validation.parameter import ParameterValidator
+from yta_validation import PythonValidator
+from yta_validation.number import NumberValidator
+from quicktions import Fraction
+from typing import Union
+
+
+class T:
+    """
+    Class to simplify the way we work with a
+    't' time moment but using the fractions
+    library to be precise and avoid any issue
+    related with commas.
+
+    This class must be used when trying to
+    apply a specific 't' time moment for a 
+    video or audio frame, using the fps or
+    sample rate as time_base to be precise.
+    """
+
+    @property
+    def truncated(
+        self
+    ) -> Fraction:
+        """
+        The 't' but as a Fraction that is multiple
+        of the given 'time_base' and truncated.
+        """
+        return round_t(self._t, self.time_base)
+    
+    @property
+    def rounded(
+        self
+    ) -> Fraction:
+        """
+        The 't' but as a Fraction that is multiple
+        of the given 'time_base' and rounded (the
+        value could be the same as truncated if it
+        is closer to the previous value).
+        """
+        return round_t(self._t, self.time_base, do_truncate = False)
+    
+    @property
+    def truncated_pts(
+        self
+    ) -> int:
+        """
+        The 'truncated' value but as a pts, which
+        is the int value to be set in audio and 
+        video frames in the pyav library to be
+        displayed in that moment.
+        """
+        return int(self.truncated / self.time_base)
+    
+    @property
+    def rounded_pts(
+        self
+    ) -> int:
+        """
+        The 'rounded' value but as a pts, which
+        is the int value to be set in audio and 
+        video frames in the pyav library to be
+        displayed in that moment.
+        """
+        return int(self.rounded / self.time_base)
+
+    def __init__(
+        self,
+        t: Union[int, float, Fraction],
+        time_base: Fraction
+    ):
+        ParameterValidator.validate_mandatory_instance_of('t', t, [int, float, 'Fraction'])
+        ParameterValidator.validate_mandatory_instance_of('time_base', time_base, 'Fraction')
+
+        self._t: Union[int, float, Fraction] = t
+        """
+        The 't' time moment as it was passed as
+        parameter.
+        """
+        self.time_base: Fraction = time_base
+        """
+        The time_base that will used to round the
+        values to be multiples of it.
+        """
+
+    def next(
+        self,
+        n: int = 1
+    ) -> 'T':
+        """
+        Get the value that is 'n' times ahead of
+        the 'truncated' property of this instance.
+
+        Useful when you need the next value for a
+        range in an iteration or similar.
+        """
+        return T(self.truncated + n * self.time_base, self.time_base)
+    
+    def previous(
+        self,
+        n: int = 1
+    ) -> 'T':
+        """
+        Get the value that is 'n' times before the
+        'truncated' property of this instance.
+
+        Useful when you need the previous value to
+        check if the current is the next one or
+        similar.
+
+        Be careful, if the 'truncated' value is 0
+        this will give you an unexpected negative
+        value.
+        """
+        return T(self.truncated - n * self.time_base, self.time_base)
+    
+    @staticmethod
+    def from_fps(
+        t: Union[int, float, Fraction],
+        fps: Union[int, float, Fraction]
+    ) -> 'T':
+        """
+        Get the instance but providing the 'fps'
+        (or sample rate) value directly, that will
+        be turned into a time base.
+        """
+        return T(t, fps_to_time_base(fps))
+
+    @staticmethod
+    def from_pts(
+        pts: int,
+        time_base: Fraction
+    ) -> 'T':
+        """
+        Get the instance but providing the 'pts'
+        and the 'time_base'.
+        """
+        return T(pts * time_base, time_base)
+    
+
+# TODO: Careful with this below
+"""
+To obtain the pts step, or frame duration in
+ticks, you need to apply 2 formulas that are
+different according to if the frame is video
+or audio:
+- Audio: .samples
+- Video: int(round((1 / .fps) / .time_base))
+"""
+    
+def get_ts(
+    start: Union[int, float, Fraction],
+    end: Union[int, float, Fraction],
+    fps: Fraction
+) -> list[Fraction]:
+    """
+    Get all the 't' time moments between the given
+    'start' and the given 'end', using the provided
+    'time_base' for precision.
+
+    The 'end' is not included, we return a range
+    [start, end) because the last frame is the
+    start of another time range.
+    """
+    start = T.from_fps(start, fps).truncated
+    end = T.from_fps(end, fps).truncated
+
+    time_base = fps_to_time_base(fps)
+    return [
+        start + i * time_base
+        for i in range((end - start) // time_base)
+    ]
+
+def round_t(
+    t: Union[int, float, Fraction],
+    time_base = Fraction(1, 60),
+    do_truncate: bool = True
+):
+    """
+    Round the given 't' time moment to the most
+    near multiple of the given 'time_base' (or
+    the previous one if 'do_truncate' is True)
+    using fractions module to be precise.
+
+    This method is very useful to truncate 't'
+    time moments in order to get the frames or
+    samples for the specific and exact time 
+    moments according to their fps or sample
+    rate (that should be passed as the
+    'time_base' parameter).
+
+    Examples below, with `time_base = 1/5`:
+    - `t = 0.25` => `0.2` (truncated or rounded)
+    - `t = 0.35` => `0.2` (truncated)
+    - `t = 0.45` => `0.4` (truncated or rounded)
+    - `t = 0.55` => `0.6` (rounded)
+    """
+    t = Fraction(t).limit_denominator()
+    steps = t / time_base
+
+    snapped_steps = (
+        steps.numerator // steps.denominator
+        if do_truncate else
+        round(steps) # round(float(steps))
+    )
+
+    return snapped_steps * time_base
+
+def fps_to_time_base(
+    fps: Union[int, float, Fraction]
+) -> Fraction:
+    """
+    Get the pyav time base from the given
+    'fps'.
+    """
+    return (
+        Fraction(1, fps)
+        if NumberValidator.is_int(fps) else
+        Fraction(1, 1) / fps
+        if PythonValidator.is_instance_of(fps, 'Fraction') else
+        Fraction(1, 1) / Fraction.from_float(fps).limit_denominator(1000000) # if float
+    )

yta_video_opengl/tests.py

@@ -586,10 +586,12 @@ def video_modified_stored():
 
     video = Video(VIDEO_PATH, 0.25, 0.75)
     timeline = Timeline()
-    timeline.add_video(Video(VIDEO_PATH, 0.25, 0.75), 0.5)
+    timeline.add_video(Video(VIDEO_PATH, 0.25, 1.0), 0.5)
     # This is successfully raising an exception
     #timeline.add_video(Video(VIDEO_PATH, 0.25, 0.75), 0.6)
-    timeline.add_video(Video(VIDEO_PATH, 0.25, 0.75), 1.5)
+    timeline.add_video(Video(VIDEO_PATH, 0.25, 0.75), 1.75)
+    timeline.add_video(Video('C:/Users/dania/Downloads/Y2meta.app-TOP 12 SIMPLE LIQUID TRANSITION _ GREEN SCREEN TRANSITION PACK-(1080p60).mp4', 4.0, 5.0), 3)
+    # 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', 2.25, 3.0), 3)
     timeline.render(OUTPUT_PATH)
 
     return

yta_video_opengl/utils.py

@@ -1,10 +1,11 @@
+from yta_video_opengl.t import fps_to_time_base
 from yta_validation import PythonValidator
 from av.container import InputContainer
 from av.video.stream import VideoStream
 from av.audio.stream import AudioStream
 from av.video.frame import VideoFrame
+from quicktions import Fraction
 from typing import Union
-from fractions import Fraction
 
 import av
 import numpy as np
@@ -311,9 +312,13 @@ def iterate_stream_frames_demuxing(
                 pts_to_index(frame.pts, time_base, average_rate)
             )
 
+# TODO: These methods below have to be
+# removed because we created the new T
+# class that is working with Fractions
+# to be precise
 def t_to_pts(
-    t: float,
-    stream_time_base: 'Fraction'
+    t: Union[int, float, Fraction],
+    stream_time_base: Fraction
  ) -> int:
     """
     Transform a 't' time moment (in seconds) to
@@ -324,8 +329,8 @@ def t_to_pts(
 
 def pts_to_index(
     pts: int,
-    stream_time_base: 'Fraction',
-    fps: float
+    stream_time_base: Fraction,
+    fps: Union[float, Fraction]
 ) -> int:
     """
     Transform a 'pts' packet timestamp to a 
@@ -335,8 +340,8 @@ def pts_to_index(
 
 def index_to_pts(
     index: int,
-    stream_time_base: 'Fraction',
-    fps: float
+    stream_time_base: Fraction,
+    fps: Union[float, Fraction]
 ) -> int:
     """
     Transform a frame index into a 'pts' packet
@@ -346,7 +351,7 @@ def index_to_pts(
 
 def pts_to_t(
     pts: int,
-    stream_time_base: 'Fraction'
+    stream_time_base: Fraction
 ) -> float:
     """
     Transform a 'pts' packet timestamp to a 't'
@@ -357,59 +362,82 @@ def pts_to_t(
 
 # TODO: Move this to another utils
 def get_silent_audio_frame(
-    sample_rate,
-    layout="stereo",
-    nb_samples=1024,
-    format="s16"
+    sample_rate: int,
+    layout = 'stereo',
+    number_of_samples: int = 1024,
+    format = 's16'
 ):
-    # Número de canales
-    channels = len(av.AudioLayout(layout).channels)
-    
-    # Creamos un array de ceros (silencio)
-    # dtype depende del formato
-    # if format in ('s16', 's16p'):
-    #     dtype = np.int16
-    # elif format in ('flt', 'fltp'):
-    #     dtype = np.float32
-    # else:
-    #     raise ValueError(f"Formato no soportado: {format}")
-    
-    if format == "s16":
-        dtype = np.int16
-    elif format in ('flt', 'fltp'):
-        dtype = np.float32
-    else:
-        raise ValueError(f"Formato no soportado: {format}")
-
-     # Para formatos packed → (1, samples * channels)
-    
-    if layout == 'stereo':
-        silent_array = np.zeros((2, nb_samples), dtype = dtype)
-    else:
-        silent_array = np.zeros((1, nb_samples), dtype = dtype)
-
-    # # Si es planar: (channels, samples) | Si es packed: (samples, channels)
-    # if format.endswith("p"):  # planar
-    #     silent_array = np.zeros((channels, nb_samples), dtype=dtype)
-    # else:  # packed
-    #     silent_array = np.zeros((nb_samples, channels), dtype=dtype)
-    
-    # Crear frame de audio
-    frame = av.AudioFrame.from_ndarray(silent_array, format=format, layout=layout)
+    # TODO: This could be a utils or something to
+    # directly transform format into dtype
+    dtype = {
+        's16': np.int16,
+        'flt': np.float32,
+        'fltp': np.float32
+    }.get(format, None)
+
+    if dtype is None:
+        raise Exception(f'The format "{format}" is not accepted.')
+
+    number_of_channels = len(av.AudioLayout(layout).channels)
+    # TODO: I think the option above is better
+    # number_of_channels = (
+    #     2
+    #     if layout == 'stereo' else
+    #     1
+    # )
+
+    # For packed (or planar) formats we apply:
+    # (1, samples * channels). This is the same
+    # amount of data but planar, in 1D only
+    # TODO: This wasn't in the previous version
+    # and it was working, we were sending the
+    # same 'number_of_samples' even when 'fltp'
+    # that includes the 'p'
+    # TODO: This is making the audio last 2x
+    # if 'p' in format:
+    #     number_of_samples *= number_of_channels
+
+    silent_array = np.zeros((number_of_channels, number_of_samples), dtype = dtype)
+    frame = av.AudioFrame.from_ndarray(silent_array, format = format, layout = layout)
     frame.sample_rate = sample_rate
     
     return frame
 
 def get_black_background_video_frame(
     size: tuple[int, int] = (1920, 1080),
-    format: str = 'rgb24'
+    format: str = 'rgb24',
+    pts: Union[int, None] = None,
+    time_base: Union[Fraction, None] = None
 ):
-    return av.VideoFrame.from_ndarray(
+    """
+    Get a pyav VideoFrame that is a completely black
+    frame. If the 'pts' and/or 'time_base' parameters
+    are provided, they will be set to the frame that
+    is returned with them. If not, remember to set
+    later because they are needed to be sent to the
+    pyav muxer.
+    """
+    frame = av.VideoFrame.from_ndarray(
         # TODO: What if we want alpha (?)
-        array = np.zeros((size[0], size[1], 3), dtype = np.uint8),
+        # Size must be inverted
+        array = np.zeros((size[1], size[0], 3), dtype = np.uint8),
         format = format
     )
 
+    frame.pts = (
+        pts
+        if pts is not None else
+        frame.pts
+    )
+
+    frame.time_base = (
+        time_base
+        if time_base is not None else
+        frame.time_base
+    )
+
+    return frame
+
 def get_audio_frame_pts_range(
     frame: av.AudioFrame,
     do_in_seconds: bool = False
@@ -451,43 +479,37 @@ def get_audio_frame_pts_range(
     )
 
 def audio_frames_and_remainder_per_video_frame(
-    fps: float,
-    sample_rate: int,
-    nb_samples: int
-):
+    # TODO: Maybe force 'fps' as int (?)
+    video_fps: Union[float, Fraction],
+    sample_rate: int, # audio_fps
+    number_of_samples_per_audio_frame: int
+) -> tuple[int, int]:
     """
-    Calcula cuántos audio frames completos y cuántas muestras sobrantes
-    corresponden a la duración de 1 frame de vídeo.
-    
-    Args:
-        fps (float): Frames por segundo del vídeo
-        sample_rate (int): Frecuencia de muestreo del audio (Hz)
-        nb_samples (int): Número de samples por AudioFrame (PyAV)
-    
-    Returns:
-        (int, int): (frames_completos, muestras_restantes)
+    Get how many full silent audio frames we
+    need and the remainder for the last one
+    (that could be not complete), according
+    to the parameters provided.
+
+    This method returns a tuple containing
+    the number of full silent audio frames
+    we need and the number of samples we need
+    in the last non-full audio frame.
     """
-    # Duración de un frame de vídeo en segundos
-    video_frame_duration = 1.0 / fps
-    
-    # Total de samples de audio necesarios
-    samples_needed = round(sample_rate * video_frame_duration)
-    
-    # Cuántos audio frames completos de nb_samples
-    full_frames = samples_needed // nb_samples
+    # Video frame duration (in seconds)
+    time_base = fps_to_time_base(video_fps)
+    sample_rate = Fraction(int(sample_rate), 1)
+
+    # Example:
+    # 44_100 / 60 = 735  ->  This means that we
+    # will have 735 samples of sound per each
+    # video frame
+    # The amount of samples per frame is actually
+    # the amount of samples we need, because we
+    # are generating it...
+    samples_per_frame = sample_rate * time_base
+    # The 'nb_samples' is the amount of samples
+    # we are including on each audio frame
+    full_audio_frames_needed = samples_per_frame // number_of_samples_per_audio_frame
+    remainder = samples_per_frame % number_of_samples_per_audio_frame
     
-    # Restante que no completa un audio frame
-    remainder = samples_needed % nb_samples
-    
-    return full_frames, remainder
-
-    # # Usage below:
-    # fps = 30
-    # sample_rate = 44100
-    # nb_samples = 1024
-
-    # full, rem = audio_frames_and_remainder_per_video_frame(fps, sample_rate, nb_samples)
-    # # This will return (1, 446)
-
-
-
+    return int(full_audio_frames_needed), int(remainder)

yta_video_opengl/video.py

@@ -1,7 +1,8 @@
 from yta_video_opengl.reader import VideoReader
 from yta_video_opengl.writer import VideoWriter
-from yta_video_opengl.utils import iterate_stream_frames_demuxing
+from yta_video_opengl.t import T
 from yta_validation import PythonValidator
+from quicktions import Fraction
 from typing import Union
 
 
@@ -26,7 +27,8 @@ class Video:
         This timestamp is used to read the video
         file source.
         """
-        return int(self.start / self.reader.time_base)
+        # TODO: What if 'time_base' is None (?)
+        return T(self.start, self.reader.time_base).truncated_pts
     
     @property
     def end_pts(
@@ -40,7 +42,8 @@ class Video:
         file source.
         """
         return (
-            int(self.end / self.reader.time_base)
+            # TODO: What if 'time_base' is None (?)
+            T(self.end, self.reader.time_base).truncated_pts
             # TODO: What do we do if no duration (?)
             if self.duration is not None else
             None
@@ -54,7 +57,8 @@ class Video:
         The start packet time stamp (pts), needed 
         to optimize the packet iteration process.
         """
-        return int(self.start / self.reader.audio_time_base)
+        # TODO: What if 'audio_time_base' is None (?)
+        return T(self.start, self.reader.audio_time_base).truncated_pts
     
     @property
     def audio_end_pts(
@@ -65,7 +69,8 @@ class Video:
         optimize the packet iteration process.
         """
         return (
-            int(self.end / self.reader.audio_time_base)
+            # 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
@@ -74,7 +79,7 @@ class Video:
     @property
     def duration(
         self
-    ):
+    ) -> Fraction:
         """
         The duration of the video.
         """
@@ -83,7 +88,7 @@ class Video:
     @property
     def number_of_frames(
         self
-    ):
+    ) -> Union[int, None]:
         """
         The number of frames of the video.
         """
@@ -117,8 +122,8 @@ class Video:
     def __init__(
         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
     ):
         self.filename: str = filename
         """
@@ -130,12 +135,12 @@ class Video:
         """
         The pyav video reader.
         """
-        self.start: float = start
+        self.start: Fraction = Fraction(start)
         """
         The time moment 't' in which the video
         should start.
         """
-        self.end: Union[float, None] = (
+        self.end: Union[Fraction, None] = Fraction(
             # TODO: Is this 'end' ok (?)
             self.reader.duration
             if end is None else
@@ -145,12 +150,85 @@ class Video:
         The time moment 't' in which the video
         should end.
         """
+
+    # TODO: We need to implement the 'get_frame'
+    # methods because this Video can be subclipped
+    # and have a 'start' and' end' that are 
+    # different from [0, end)
+    def _get_real_t(
+        self,
+        t: Union[int, float, Fraction]
+    ) -> Fraction:
+        """
+        Get the real 't' time moment based on the
+        video 'start' and 'end'. If they were 
+        asking for the t=0.5s but our video was
+        subclipped to [1.0, 2.0), the 0.5s must be
+        actually the 1.5s of the video because of
+        the subclipped time range.
+        """
+        t = self.start + t
         
+        if t >= self.end:
+            raise Exception(f'The "t" ({str(t)}) provided is out of range. This video lasts from [{str(self.start)}, {str(self.end)}).')
+        
+        return t
+
+    def get_frame_from_t(
+        self,
+        t: Union[int, float, Fraction]
+    ) -> 'VideoFrame':
+        """
+        Get the video frame with the given 't' time
+        moment, using the video cache system.
+        """
+        return self.reader.video_cache.get_video_frame(self._get_real_t(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.audio_cache.get_frame_from_t(self._get_real_t(t))
+    
+    def get_audio_frames_from_t(
+        self,
+        t: Union[int, float, Fraction]
+    ):
+        """
+        Get the sequence of audio frames for the 
+        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).
+        """
+        for frame in self.reader.get_audio_frames_from_t(self._get_real_t(t)):
+            yield frame
+
     def save_as(
         self,
         filename: str
     ) -> 'Video':
-        writer =  VideoWriter(filename)
+        """
+        Save the video 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_video_stream_from_template(self.reader.video_stream)
         writer.set_audio_stream_from_template(self.reader.audio_stream)