yta-video-opengl 0.0.11__py3-none-any.whl → 0.0.13__py3-none-any.whl

yta_video_opengl/reader/cache.py

@@ -15,9 +15,14 @@ frame we are requesting in the moment, keeping in
 memory all those frames to be handled fast. It
 will remove the old frames if needed to use only
 the 'size' we set when creating it.
+
+A stream can have 'fps = 60' but use another
+different time base that make the pts values go 0,
+ 256, 512... for example. The 'time_base' is the
+only accurate way to obtain the pts.
 """
 from yta_video_opengl.utils import t_to_pts, pts_to_t, pts_to_index, index_to_pts
-from yta_video_frame_time import T
+from yta_video_opengl.t import T
 from av.container import InputContainer
 from av.video.stream import VideoStream
 from av.audio.stream import AudioStream
@@ -25,14 +30,19 @@ from av.video.frame import VideoFrame
 from av.audio.frame import AudioFrame
 from yta_validation.parameter import ParameterValidator
 from yta_validation import PythonValidator
-from fractions import Fraction
+from quicktions import Fraction
 from collections import OrderedDict
 from typing import Union
 
 import numpy as np
+import av
 import math
 
 
+# TODO: This is not actually a Video
+# cache, is a FrameCache because we
+# create one for video but another
+# one for audio. Rename it please.
 class VideoFrameCache:
     """
     Class to manage the frames cache of a video
@@ -108,6 +118,7 @@ class VideoFrameCache:
         # use the amount of frames of the biggest
         # interval of frames that belongs to a key
         # frame, or a value by default
+        # TODO: Careful if this is too big
         fps = (
             float(self.stream.average_rate)
             if PythonValidator.is_instance_of(self.stream, VideoStream) else
@@ -116,7 +127,7 @@ class VideoFrameCache:
         # Intervals, but in number of frames
         intervals = np.diff(
             # Intervals of time between keyframes
-            np.array(self.key_frames_pts) * self.stream.time_base
+            np.array(self.key_frames_pts) * self.time_base
         ) * fps
 
         self.size = (
@@ -131,7 +142,7 @@ class VideoFrameCache:
         
         self.container.seek(0)
 
-    def _get_nearest_keyframe_fps(
+    def _get_nearest_keyframe_pts(
         self,
         pts: int
     ):
@@ -157,7 +168,6 @@ class VideoFrameCache:
         the cache if full.
         """
         if frame.pts not in self.cache:
-            # TODO: The 'format' must be dynamic
             self.cache[frame.pts] = frame
 
             # Clean cache if full
@@ -166,7 +176,7 @@ class VideoFrameCache:
 
         return frame
 
-    def _get_frame_by_pts(
+    def get_frame_from_pts(
         self,
         pts: int
     ) -> Union[VideoFrame, AudioFrame, None]:
@@ -181,11 +191,23 @@ class VideoFrameCache:
         This method must be called when the frame 
         requested is not stored in the caché.
         """
+        if pts in self.cache:
+            return self.cache[pts]
+        
         # Look for the most near key frame
-        key_frame_pts = self._get_nearest_keyframe_fps(pts)
+        key_frame_pts = self._get_nearest_keyframe_pts(pts)
 
         # Go to the key frame that includes it
-        self.container.seek(key_frame_pts, stream = self.stream)
+        # but I read that it is recommended to
+        # read ~100ms before the pts we want to
+        # actually read so we obtain the frames
+        # clean (this is important in audio)
+        # TODO: This code is repeated, refactor
+        pts_pad = int(0.1 / self.time_base)
+        self.container.seek(
+            offset = max(0, key_frame_pts - pts_pad),
+            stream = self.stream
+        )
 
         decoded = None
         for frame in self.container.decode(self.stream):
@@ -196,6 +218,15 @@ class VideoFrameCache:
             # Store in cache if needed
             self._store_frame_in_cache(frame)
 
+            """
+            The 'frame.pts * frame.time_base' will give
+            us the index of the frame, and actually the
+            'pts' que are looking for seems to be the
+            index and not a pts.
+
+            TODO: Review all this in all the logic 
+            please.
+            """
             if frame.pts >= pts:
                 decoded = self.cache[frame.pts]
                 break
@@ -204,6 +235,7 @@ class VideoFrameCache:
         # frames to be able to decode...
         return decoded
 
+    # TODO: I'm not using this method...
     def get_frame(
         self,
         index: int
@@ -218,55 +250,89 @@ class VideoFrameCache:
         return (
             self.cache[pts]
             if pts in self.cache else
-            self._get_frame_by_pts(pts)
+            self.get_frame_from_pts(pts)
         )
     
     def get_frame_from_t(
         self,
-        t: float
+        t: Union[int, float, Fraction]
     ) -> Union[VideoFrame, AudioFrame]:
         """
         Get the frame with the given 't' time moment
         from the cache.
         """
-        return self.get_frame(T.video_frame_time_to_video_frame_index(t, self.fps))
+        return self.get_frame_from_pts(T(t, self.time_base).truncated_pts)
 
     def get_frames(
         self,
-        start: float = 0,
-        end: Union[float, None] = None
+        start: Union[int, float, Fraction] = 0,
+        end: Union[int, float, Fraction, None] = None
     ):
         """
         Get all the frames in the range between
         the provided 'start' and 'end' time in
         seconds.
+
+        This method is an iterator that yields
+        the frame, its t and its index.
         """
         # We use the cache as iterator if all the frames
         # requested are stored there
-        pts_list = [
-            t_to_pts(t, self.time_base)
-            for t in T.get_frame_indexes(self.stream.duration, self.fps, start, end)
-        ]
-
-        if all(
-            pts in self.cache
-            for pts in pts_list
-        ):
-            for pts in pts_list:
-                yield self.cache[pts]
+        # TODO: I think this is not ok... I will never
+        # have all the pts form here stored, as they come
+        # from 't' that is different...
+
+        """
+        Feel free to move this explanation to other
+        place, its about the duration.
+
+        The stream 'duration' parameter is measured
+        on ticks, the amount of ticks that the
+        stream lasts. Here below is an example:
+
+        - Duration raw: 529200
+        - Time base: 1/44100
+        - Duration (seconds): 12.0
+        """
+
+        # The 'duration' is on pts ticks
+        duration = float(self.stream.duration * self.time_base)
+        # TODO: I think it would be better to
+        # receive and work with pts instead of
+        # 't' time moments...
+        # pts_list = [
+        #     t_to_pts(t, self.time_base)
+        #     for t in T.get_frame_indexes(duration, self.fps, start, end)
+        # ]
+
+        # if all(
+        #     pts in self.cache
+        #     for pts in pts_list
+        # ):
+        #     for pts in pts_list:
+        #         yield self.cache[pts]
 
         # If not all, we ignore the cache because we
         # need to decode and they are all consecutive
-        start = t_to_pts(start, self.time_base)
+        start = T(start, self.time_base).truncated_pts
         end = (
-            t_to_pts(end, self.time_base)
+            T(end, self.time_base).truncated_pts
             if end is not None else
             None
         )
-        key_frame_pts = self._get_nearest_keyframe_fps(start)
+        key_frame_pts = self._get_nearest_keyframe_pts(start)
 
-        # Go to the nearest key frame to start decoding
-        self.container.seek(key_frame_pts, stream = self.stream)
+        # Go to the key frame that includes it
+        # but I read that it is recommended to
+        # read ~100ms before the pts we want to
+        # actually read so we obtain the frames
+        # clean (this is important in audio)
+        # TODO: This code is repeated, refactor
+        pts_pad = int(0.1 / self.time_base)
+        self.container.seek(
+            offset = max(0, key_frame_pts - pts_pad),
+            stream = self.stream
+        )
 
         for packet in self.container.demux(self.stream):
             for frame in packet.decode():
@@ -276,16 +342,80 @@ class VideoFrameCache:
                 # We store all the frames in cache
                 self._store_frame_in_cache(frame)
 
-                if frame.pts < start:
+                frame_end_pts = frame.pts + int(frame.samples * (1 / self.stream.sample_rate) / self.time_base)
+                #frame_end_pts = frame.pts + int(frame.samples)
+                #frame_end_pts = frame.pts + int(frame.samples / (self.stream.sample_rate * self.time_base))
+
+                # For the next comments imagine we are looking
+                # for the [1.0, 2.0) audio time range
+                # Previous frame and nothing is inside
+                if frame_end_pts <= start:
+                    # From 0.25 to 1.0
                     continue
 
+                # We finished, nothing is inside and its after
                 if (
                     end is not None and
-                    frame.pts > end
+                    frame.pts >= end
                 ):
+                    # From 2.0 to 2.75
                     return
+
+                # We need: from 1 to 2
+                # Audio is:
+                #   - from 0 to 0.75    (Not included, omit)
+                #   - from 0.5 to 1.5   (Included, take 1.0 to 1.5)
+                #   - from 0.5 to 2.5   (Included, take 1.0 to 2.0)
+                #   - from 1.25 to 1.5  (Included, take 1.25 to 1.5)
+                #   - from 1.25 to 2.5  (Included, take 1.25 to 2.0)
+                #   - from 2.5 to 3.5   (Not included, omit)
+                
+                # Here below, at least a part is inside
+                if (
+                    frame.pts < start and
+                    frame_end_pts > start
+                ):
+                    # A part at the end is included
+                    end_time = (
+                        # From 0.5 to 1.5 0> take 1.0 to 1.5
+                        frame_end_pts
+                        if frame_end_pts <= end else
+                        # From 0.5 to 2.5 => take 1.0 to 2.0
+                        end
+                    )
+                    #print('A part at the end is included.')
+                    # TODO: I'm using too much 'pts_to_t'
+                    frame = trim_audio_frame_pts(
+                        frame = frame,
+                        start_pts = start,
+                        end_pts = end_time,
+                        time_base = self.time_base
+                    )
+                elif (
+                    frame.pts >= start and
+                    frame.pts < end
+                ):
+                    end_time = (
+                        # From 1.25 to 1.5 => take 1.25 to 1.5
+                        frame_end_pts
+                        if frame_end_pts <= end else
+                        # From 1.25 to 2.5 => take 1.25 to 2.0
+                        end
+                    )
+                    # A part at the begining is included
+                    #print('A part at the begining is included.')
+                    # TODO: I'm using too much 'pts_to_t'
+                    frame = trim_audio_frame_pts(
+                        frame = frame,
+                        start_pts = frame.pts,
+                        end_pts = end_time,
+                        time_base = self.time_base
+                    )
+
+                # If the whole frame is in, past as it is
                 
                 # TODO: Maybe send a @dataclass instead (?)
+                # TODO: Do I really need these 't' and 'index' (?)
                 yield (
                     frame,
                     pts_to_t(frame.pts, self.time_base),
@@ -300,4 +430,100 @@ class VideoFrameCache:
         """
         self.cache.clear()
 
-        return self
+        return self
+    
+
+# TODO: Move this to a utils when refactored
+def trim_audio_frame_pts(
+    frame: av.AudioFrame,
+    start_pts: int,
+    end_pts: int,
+    time_base
+) -> av.AudioFrame:
+    """
+    Recorta un AudioFrame para quedarse solo con la parte entre [start_pts, end_pts] en ticks (PTS).
+    """
+    samples = frame.to_ndarray()  # (channels, n_samples)
+    n_channels, n_samples = samples.shape
+    sr = frame.sample_rate
+
+    #frame_end_pts = frame.pts + int((n_samples / sr) / time_base)
+    # TODO: This could be wrong
+    frame_end_pts = frame.pts + int(frame.samples)
+
+    # solapamiento en PTS
+    cut_start_pts = max(frame.pts, start_pts)
+    cut_end_pts = min(frame_end_pts, end_pts)
+
+    if cut_start_pts >= cut_end_pts:
+        raise Exception('Oops...')
+        return None  # no hay solapamiento
+
+    # convertir a índices de samples (en ticks → segundos → samples)
+    cut_start_time = (cut_start_pts - frame.pts) * time_base
+    cut_end_time = (cut_end_pts - frame.pts) * time_base
+
+    start_idx = int(cut_start_time * sr)
+    end_idx = int(cut_end_time * sr)
+
+    # print(
+    #     f"cutting [{frame.pts}, {frame_end_pts}] "
+    #     f"to [{cut_start_pts}, {cut_end_pts}] "
+    #     f"({start_idx}:{end_idx} / {frame.samples})"
+    #     #f"({start_idx}:{end_idx} / {n_samples})"
+    # )
+
+    cut_samples = samples[:, start_idx:end_idx]
+
+    # crear nuevo AudioFrame
+    new_frame = av.AudioFrame.from_ndarray(cut_samples, format=frame.format, layout=frame.layout)
+    new_frame.sample_rate = sr
+
+    # ajustar PTS → corresponde al inicio real del recorte
+    new_frame.pts = cut_start_pts
+    new_frame.time_base = time_base
+
+    return new_frame
+
+
+
+def trim_audio_frame_t(
+    frame: av.AudioFrame,
+    start_time: float,
+    end_time: float,
+    time_base
+) -> av.AudioFrame:
+    """
+    Recorta un AudioFrame para quedarse solo con la parte entre [start_time, end_time] en segundos.
+    """
+    samples = frame.to_ndarray()  # (channels, n_samples)
+    n_channels, n_samples = samples.shape
+    sr = frame.sample_rate
+
+    frame_start = float(frame.pts * time_base)
+    frame_end = frame_start + (n_samples / sr)
+
+    # calcular solapamiento en segundos
+    cut_start = max(frame_start, start_time)
+    cut_end = min(frame_end, end_time)
+
+    if cut_start >= cut_end:
+        return None  # no hay solapamiento
+
+    # convertir a índices de samples
+    start_idx = int((cut_start - frame_start) * sr)
+    end_idx = int((cut_end - frame_start) * sr)
+
+    # print(f'cutting [{str(frame_start)}, {str(frame_end)}] to [{str(float(start_time))}, {str(float(end_time))}] from {str(start_idx)} to {str(end_idx)} of {str(int((frame_end - frame_start) * sr))}')
+    cut_samples = samples[:, start_idx:end_idx]
+
+    # crear nuevo AudioFrame
+    new_frame = av.AudioFrame.from_ndarray(cut_samples, format = frame.format, layout = frame.layout)
+    new_frame.sample_rate = sr
+
+    # ajustar PTS → corresponde al inicio real del recorte
+    new_pts = int(cut_start / time_base)
+    new_frame.pts = new_pts
+    new_frame.time_base = time_base
+
+    return new_frame

yta_video_opengl/t.py

@@ -0,0 +1,185 @@
+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 previou 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)
+    
+    # TODO: Maybe its better to make the '__init__'
+    # receive the fps and create the 'from_time_base'
+    # because I think we will provide the fps or the
+    # sample rate more often
+    @staticmethod
+    def from_fps(
+        t: Union[int, float, Fraction],
+        fps: Union[int, float, Fraction]
+    ):
+        """
+        Get the instance but providing the 'fps'
+        (or sample rate) value directly.
+        """
+        return T(t, fps_to_time_base(fps))
+    
+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