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

yta_video_opengl/reader/__init__.py

@@ -4,6 +4,7 @@ that, using ffmpeg, detects the video.
 """
 from yta_video_opengl.reader.cache import VideoFrameCache
 from yta_video_opengl.utils import iterate_stream_frames_demuxing
+from yta_video_opengl.t import T
 from yta_validation import PythonValidator
 from av.video.frame import VideoFrame
 from av.audio.frame import AudioFrame
@@ -11,7 +12,7 @@ from av.packet import Packet
 from av.video.stream import VideoStream
 from av.audio.stream import AudioStream
 from av.container.input import InputContainer
-from fractions import Fraction
+from quicktions import Fraction
 from av import open as av_open
 from typing import Union
 from dataclasses import dataclass
@@ -58,7 +59,7 @@ class VideoReaderFrame:
         self,
         # TODO: Add the type, please
         frame: any,
-        t: float = None,
+        t: Union[int, float, Fraction] = None,
         pixel_format: str = 'rgb24'
     ):
         self.value: Union[AudioFrame, VideoFrame] = frame
@@ -66,7 +67,7 @@ class VideoReaderFrame:
         The frame content, that can be audio or video
         frame.
         """
-        self.t: float = t
+        self.t: Fraction = Fraction(t)
         """
         The 't' time moment of the frame.
         """
@@ -139,6 +140,8 @@ class VideoReader:
         """
         return self.container.decode(self.video_stream)
     
+    # TODO: Remove this when possible, we are not
+    # using 'next' properties
     @property
     def next_frame(
         self
@@ -159,16 +162,6 @@ class VideoReader:
         """
         return self.container.decode(self.audio_stream)
         
-    @property
-    def next_audio_frame(
-        self
-    ) -> Union[AudioFrame, None]:
-        """
-        Get the next audio frame (decoded) from the
-        iterator.
-        """
-        return next(self.audio_frame_iterator)
-    
     @property
     def packet_iterator(
         self
@@ -179,16 +172,6 @@ class VideoReader:
         """
         return self.container.demux(self.video_stream)
     
-    @property
-    def next_packet(
-        self
-    ) -> Union[Packet, None]:
-        """
-        Get the next video packet (not decoded) from
-        the iterator.
-        """
-        return next(self.packet_iterator)
-    
     @property
     def audio_packet_iterator(
         self
@@ -199,16 +182,6 @@ class VideoReader:
         """
         return self.container.demux(self.audio_stream)
     
-    @property
-    def next_audio_packet(
-        self
-    ) -> Union[Packet, None]:
-        """
-        Get the next audio packet (not decoded) from
-        the iterator.
-        """
-        return next(self.packet_iterator)
-    
     @property
     def packet_with_audio_iterator(
         self
@@ -220,18 +193,6 @@ class VideoReader:
         """
         return self.container.demux((self.video_stream, self.audio_stream))
 
-    @property
-    def next_packet_with_audio(
-        self
-    ) -> Union[Packet, None]:
-        """
-        Get the next video frames packet (or audio
-        frames packet) from the iterator. Depending
-        on the position, the packet can be video or
-        audio.
-        """
-        return next(self.packet_with_audio_iterator)
-    
     @property
     def has_video(
         self
@@ -312,8 +273,6 @@ class VideoReader:
         The fps of the video.
         """
         return (
-            # They return it as a Fraction but we usually
-            # use it as float or even int
             self.video_stream.average_rate
             if self.has_video else
             None
@@ -515,6 +474,7 @@ class VideoReader:
             )
             # TODO: Should this be 'AUTO' (?)
             self.video_stream.thread_type = 'AUTO'
+
             self.audio_stream = (
                 self.container.streams.audio[0]
                 if self.container.streams.audio else
@@ -534,7 +494,7 @@ class VideoReader:
 
     def seek(
         self,
-        pts,
+        pts: int,
         stream = None
     ) -> 'VideoReader':
         """
@@ -567,7 +527,8 @@ class VideoReader:
         for frame in self.frame_iterator:
             yield VideoReaderFrame(
                 frame = frame,
-                t = float(frame.pts * self.time_base),
+                # TODO: Maybe use util to transform it (?)
+                t = frame.pts * self.time_base,
                 pixel_format = self.pixel_format
             )
 
@@ -672,7 +633,7 @@ class VideoReader:
     
     def get_frame_from_t(
         self,
-        t: float
+        t: Union[int, float, Fraction]
     ) -> 'VideoFrame':
         """
         Get the video frame with the given 't' time
@@ -692,7 +653,7 @@ class VideoReader:
 
     def get_audio_frame_from_t(
         self,
-        t: float
+        t: Union[int, float, Fraction]
     ) -> 'AudioFrame':
         """
         Get the audio frame with the given 't' time
@@ -702,7 +663,7 @@ class VideoReader:
     
     def get_audio_frames_from_t(
         self,
-        t: float
+        t: Union[int, float, Fraction]
     ):
         """
         Get the sequence of audio frames for the 
@@ -715,14 +676,14 @@ class VideoReader:
         (remember that a video frame is associated
         with more than 1 audio frame).
         """
-        print(f'Getting audio frames from video, from t:{str(t)} - nt:{str(t + (1 / self.fps))}')
-        for frame in self.audio_cache.get_frames(t, t + (1 / self.fps)):
+        t: T = T.from_fps(t, self.fps)
+        for frame in self.audio_cache.get_frames(t.truncated, t.next(1).truncated):
             yield frame
     
     def get_frames(
         self,
-        start: float = 0.0,
-        end: Union[float, None] = None
+        start: Union[int, float, Fraction] = 0.0,
+        end: Union[int, float, Fraction, None] = None
     ):
         """
         Iterator to get the video frames in between
@@ -733,8 +694,8 @@ class VideoReader:
 
     def get_audio_frames(
         self,
-        start: float = 0.0,
-        end: Union[float, None] = None
+        start: Union[int, float, Fraction] = 0.0,
+        end: Union[int, float, Fraction, None] = None
     ):
         """
         Iterator to get the audio frames in between
@@ -752,6 +713,8 @@ 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,

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
@@ -185,10 +195,19 @@ class VideoFrameCache:
             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):
@@ -199,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
@@ -207,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
@@ -226,24 +255,18 @@ class VideoFrameCache:
     
     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.
         """
-        pts = t_to_pts(t, self.time_base)
-
-        return (
-            self.cache[pts]
-            if pts in self.cache else
-            self.get_frame_from_pts(pts)
-        )
+        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
@@ -273,8 +296,7 @@ class VideoFrameCache:
         """
 
         # The 'duration' is on pts ticks
-        duration = float(self.stream.duration * self.stream.time_base)
-        print(f'duration of the whole stream: {str(duration)}s, asking for [{str(start)}, {str(end)})')
+        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...
@@ -292,16 +314,25 @@ class VideoFrameCache:
 
         # 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():
@@ -311,11 +342,9 @@ class VideoFrameCache:
                 # We store all the frames in cache
                 self._store_frame_in_cache(frame)
 
-                print(frame)
                 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))
-                print(f'    Frame from [{str(frame.pts)}, {str(frame_end_pts)}] and looking for [{str(start)}, {str(end)}]')
 
                 # For the next comments imagine we are looking
                 # for the [1.0, 2.0) audio time range
@@ -354,7 +383,7 @@ class VideoFrameCache:
                         # From 0.5 to 2.5 => take 1.0 to 2.0
                         end
                     )
-                    print('A part at the end is included.')
+                    #print('A part at the end is included.')
                     # TODO: I'm using too much 'pts_to_t'
                     frame = trim_audio_frame_pts(
                         frame = frame,
@@ -374,7 +403,7 @@ class VideoFrameCache:
                         end
                     )
                     # A part at the begining is included
-                    print('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,
@@ -404,14 +433,7 @@ class VideoFrameCache:
         return self
     
 
-
-import av
-import numpy as np
-
-import av
-
-
-
+# TODO: Move this to a utils when refactored
 def trim_audio_frame_pts(
     frame: av.AudioFrame,
     start_pts: int,
@@ -444,12 +466,12 @@ def trim_audio_frame_pts(
     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})"
-    )
+    # 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]
 
@@ -492,7 +514,7 @@ def trim_audio_frame_t(
     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))}')
+    # 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

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