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

yta_video_opengl/reader/cache/video.py

@@ -0,0 +1,110 @@
+
+from yta_video_opengl.reader.cache import FrameCache
+from yta_video_opengl.t import T
+from yta_validation.parameter import ParameterValidator
+from av.container import InputContainer
+from av.video.stream import VideoStream
+from av.video.frame import VideoFrame
+from quicktions import Fraction
+from typing import Union
+
+
+class VideoFrameCache(FrameCache):
+    """
+    Cache for the video frames.
+    """
+
+    @property
+    def fps(
+        self
+    ) -> Union[Fraction, None]:
+        """
+        The frames per second.
+        """
+        return self.stream.average_rate
+
+    @property
+    def frame_duration(
+        self
+    ) -> int:
+        """
+        The frame duration in ticks, which is the
+        minimum amount of time, 1 / time_base.
+        """
+        return self.stream.duration / self.stream.frames
+    
+    def __init__(
+        self,
+        container: InputContainer,
+        stream: VideoStream,
+        size: Union[int, None] = None
+    ):
+        ParameterValidator.validate_mandatory_instance_of('stream', stream, VideoStream)
+
+        super().__init__(container, stream, size)
+
+    def get_frame(
+        self,
+        t: Union[int, float, Fraction]
+    ) -> VideoFrame:
+        """
+        Get the video frame that is in the 't'
+        time moment provided.
+        """
+        t: T = T.from_fps(t, self.fps)
+        for frame in self.get_frames(t.truncated, t.next(1).truncated):
+            return frame
+
+    def get_frames(
+        self,
+        start: Union[int, float, Fraction],
+        end: Union[int, float, Fraction]
+    ):
+        """
+        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.
+        """
+        # TODO: Validate 'start' and 'end' are mandatory
+        # positive numbers
+        # Make sure the 'start' and 'end' time moments
+        # provided are truncated values based on the
+        # stream time base
+        start = T(start, self.time_base).truncated
+        end = T(end, self.time_base).truncated
+
+        if end <= start:
+            raise Exception(f'The time range start:{str(float(start))} - end:{str(float(end))}) is not valid.')
+        
+        key_frame_pts = self._get_nearest_keyframe_pts(start / self.time_base)
+
+        if (
+            self._last_packet_accessed is None or
+            self._last_packet_accessed.pts != key_frame_pts
+        ):
+            self._seek(key_frame_pts)
+
+        for packet in self.container.demux(self.stream):
+            if packet.pts is None:
+                continue
+
+            self._last_packet_accessed = packet
+
+            for frame in packet.decode():
+                if frame.pts is None:
+                    continue
+
+                # We store all the frames in cache
+                self._store_frame_in_cache(frame)
+                
+                current_frame_time = frame.pts * self.time_base
+                
+                # We want the range [start, end)
+                if start <= current_frame_time < end:
+                    yield frame
+
+                if current_frame_time >= end:
+                    break

yta_video_opengl/t.py

@@ -1,3 +1,14 @@
+"""
+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
@@ -36,7 +47,7 @@ class T:
         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).
+        is closer to the previous value).
         """
         return round_t(self._t, self.time_base, do_truncate = False)
     
@@ -96,20 +107,57 @@ class T:
         """
         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
+    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.
+        (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],

yta_video_opengl/video.py

@@ -182,17 +182,22 @@ class Video:
         Get the video frame with the given 't' time
         moment, using the video cache system.
         """
-        return self.reader.video_cache.get_frame_from_t(self._get_real_t(t))
-    
+        return self.reader.video_cache.get_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.
+        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))
+        return self.reader.get_audio_frame_from_t(self._get_real_t(t))
     
     def get_audio_frames_from_t(
         self,

{yta_video_opengl-0.0.13.dist-info → yta_video_opengl-0.0.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: yta-video-opengl
-Version: 0.0.13
+Version: 0.0.15
 Summary: Youtube Autonomous Video OpenGL Module
 Author: danialcala94
 Author-email: danielalcalavalera@gmail.com

yta_video_opengl-0.0.15.dist-info/RECORD

@@ -0,0 +1,24 @@
+yta_video_opengl/__init__.py,sha256=ycAx_XYMVDfkuObSvtW6irQ0Wo-fgxEz3fjIRMe8PpY,205
+yta_video_opengl/classes.py,sha256=t5-Tfc7ecvHl8JlVBp_FVzZT6ole6Ly5-FeBBH7wcxo,37742
+yta_video_opengl/complete/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+yta_video_opengl/complete/timeline.py,sha256=y2IPLRlk3ix14zflCsLKWajbqtf6Y8ceStpLs69OqHY,9323
+yta_video_opengl/complete/track.py,sha256=hI1b4EmbXMPB_COxNUs1VlHVPtbiaIgvt37RY-YUz7g,13623
+yta_video_opengl/complete/video_on_track.py,sha256=KROAI0bndnfcvKlHGsSEyWg9o1xozW0PI_Rhqp0r9kw,4844
+yta_video_opengl/nodes/__init__.py,sha256=TZ-ZO05PZ0_ABq675E22_PngLWOe-_w5s1cLlV3NbWM,3469
+yta_video_opengl/nodes/audio/__init__.py,sha256=4nKkC70k1UgLcCSPqFWm3cKdaJM0KUmQTwGWv1xFarQ,2926
+yta_video_opengl/nodes/video/__init__.py,sha256=gSoaoEmjdQmyRwH18mf5z3NAhap3S0RgbeBbfBXi4jc,132
+yta_video_opengl/nodes/video/opengl.py,sha256=K2pyCJEd9z4gnZqJetKyGPbtHuBzFsx74ZYyzhSqYPo,8510
+yta_video_opengl/reader/__init__.py,sha256=kKvOAEeDjIwAaWtpDEQHdAd_Gwk3Ssz2tv6gpNwVkQo,19644
+yta_video_opengl/reader/cache/__init__.py,sha256=PAfGM2J-8Vv6p6Cd9aAUvyBcw3rjx2gy_2pJO22VtDM,7020
+yta_video_opengl/reader/cache/audio.py,sha256=cm_1D5f5RnmJgaidA1pnEhTPF8DE0mU2MofmwjU_b5k,6781
+yta_video_opengl/reader/cache/utils.py,sha256=9aJ6qyUFRvoh2jRbIvtF_-1MOm_sgQtPiy0WXLCZYcA,1402
+yta_video_opengl/reader/cache/video.py,sha256=CSVgb3Sjqzk22sQkukoakVzms-wwZpXOT61Y6tirhjg,3292
+yta_video_opengl/t.py,sha256=xOhT1xBEwChlXf-Tuy-WxA_08iRJWVlnL_Hyzr-9-sk,6633
+yta_video_opengl/tests.py,sha256=EdTyYtTUd_mj6geWnrvnF-wZSHCKKvhYgiLclkV73O0,26576
+yta_video_opengl/utils.py,sha256=yUi17EjNR4SVpvdDUwUaKl4mBCb1uyFCSGoIX3Zr2F0,15586
+yta_video_opengl/video.py,sha256=JPIWDQcYlLi8eT2LOFQtS1jVu5xVmW4bz1VMtP0gMeA,8626
+yta_video_opengl/writer.py,sha256=QwvjQcEkzn1WAVqVTFiI6tYIXJO67LKKUTJGO_eflFM,8893
+yta_video_opengl-0.0.15.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+yta_video_opengl-0.0.15.dist-info/METADATA,sha256=nDTKhQqRMXHzjg8kQWvRWKfvDsP7rvsAhpcl8qayl-8,714
+yta_video_opengl-0.0.15.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+yta_video_opengl-0.0.15.dist-info/RECORD,,