yta-video-opengl 0.0.8__tar.gz → 0.0.9__tar.gz

{yta_video_opengl-0.0.8 → yta_video_opengl-0.0.9}/PKG-INFO

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

{yta_video_opengl-0.0.8 → yta_video_opengl-0.0.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yta-video-opengl"
-version = "0.0.8"
+version = "0.0.9"
 description = "Youtube Autonomous Video OpenGL Module"
 authors = [
     {name = "danialcala94",email = "danielalcalavalera@gmail.com"}

{yta_video_opengl-0.0.8 → yta_video_opengl-0.0.9}/src/yta_video_opengl/reader/__init__.py

@@ -398,9 +398,14 @@ class VideoReader:
         """
         The stream that includes the audio.
         """
-        self.cache: VideoFrameCache = None
+        self.video_cache: VideoFrameCache = None
         """
-        The frame cache system to optimize
+        The video frame cache system to optimize
+        the way we access to the frames.
+        """
+        self.audio_cache: VideoFrameCache = None
+        """
+        The audio frame cache system to optimize
         the way we access to the frames.
         """
 
@@ -434,7 +439,8 @@ class VideoReader:
             self.video_stream.thread_type = 'AUTO'
             self.audio_stream = self.container.streams.audio[0]
             self.audio_stream.thread_type = 'AUTO'
-            self.cache = VideoFrameCache(self)
+            self.video_cache = VideoFrameCache(self.container, self.video_stream)
+            self.audio_cache = VideoFrameCache(self.container, self.audio_stream)
 
     def seek(
         self,
@@ -564,10 +570,45 @@ class VideoReader:
         index: int
     ) -> 'VideoFrame':
         """
-        Get the frame with the given 'index', using
-        the cache system.
+        Get the video frame with the given 'index',
+        using the video cache system.
+        """
+        return self.video_cache.get_frame(index)
+    
+    # TODO: Will we use this (?)
+    def get_audio_frame(
+        self,
+        index: int
+    ) -> 'VideoFrame':
+        """
+        Get the audio frame with the given 'index',
+        using the audio cache system.
+        """
+        return self.video_cache.get_frame(index)
+    
+    def get_frames(
+        self,
+        start: float = 0.0,
+        end: Union[float, None] = None
+    ):
         """
-        return self.cache.get_frame(index)
+        Iterator to get the video frames in between
+        the provided 'start' and 'end' time moments.
+        """
+        for frame in self.video_cache.get_frames(start, end):
+            yield frame
+
+    def get_audio_frames(
+        self,
+        start: float = 0.0,
+        end: Union[float, None] = None
+    ):
+        """
+        Iterator to get the audio frames in between
+        the provided 'start' and 'end' time moments.
+        """
+        for frame in self.audio_cache.get_frames(start, end):
+            yield frame
     
     def close(
         self

yta_video_opengl-0.0.9/src/yta_video_opengl/reader/cache.py

@@ -0,0 +1,233 @@
+"""
+The pyav container stores the information based
+on the packets timestamps (called 'pts'). Some
+of the packets are considered key_frames because
+they include those key frames.
+
+Also, this library uses those key frames to start
+decodifying from there to the next one, obtaining
+all the frames in between able to be read and
+modified.
+
+This cache system will look for the range of 
+frames that belong to the key frame related to the
+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.
+"""
+from yta_video_opengl.utils import t_to_pts, pts_to_t, pts_to_index
+from av.container import InputContainer
+from av.video.stream import VideoStream
+from av.audio.stream import AudioStream
+from av.video.frame import VideoFrame
+from av.audio.frame import AudioFrame
+from yta_validation.parameter import ParameterValidator
+from fractions import Fraction
+from collections import OrderedDict
+from typing import Union
+
+
+class VideoFrameCache:
+    """
+    Class to manage the frames cache of a video
+    within a video reader instance.
+    """
+
+    @property
+    def fps(
+        self
+    ) -> float:
+        """
+        The frames per second as a float.
+        """
+        return (
+            float(self.stream.average_rate)
+            if self.stream.type == 'video' else
+            float(self.stream.rate)
+        )
+    
+    @property
+    def time_base(
+        self
+    ) -> Union[Fraction, None]:
+        """
+        The time base of the stream.
+        """
+        return self.stream.time_base
+
+    def __init__(
+        self,
+        container: InputContainer,
+        stream: Union[VideoStream, AudioStream],
+        size: int = 50
+    ):
+        ParameterValidator.validate_mandatory_instance_of('container', container, InputContainer)
+        ParameterValidator.validate_mandatory_instance_of('stream', stream, [VideoStream, AudioStream])
+        ParameterValidator.validate_mandatory_positive_int('size', size)
+
+        self.container: InputContainer = container
+        """
+        The pyav container.
+        """
+        self.stream: Union[VideoStream, AudioStream] = stream
+        """
+        The pyav stream.
+        """
+        self.cache: OrderedDict = OrderedDict()
+        """
+        The cache ordered dictionary.
+        """
+        self.size = size
+        """
+        The size (in number of frames) of the cache.
+        """
+        self.key_frames_pts: list[int] = []
+        """
+        The list that contains the timestamps of the
+        key frame packets, ordered from begining to
+        end.
+        """
+
+        self._prepare()
+
+    def _prepare(
+        self
+    ):
+        # Index key frames
+        for packet in self.container.demux(self.stream):
+            if packet.is_keyframe:
+                self.key_frames_pts.append(packet.pts)
+
+        self.container.seek(0)
+
+    def _get_nearest_keyframe_fps(
+        self,
+        pts: int
+    ):
+        """
+        Get the fps of the keyframe that is the
+        nearest to the provided 'pts'. Useful to
+        seek and start decoding frames from that
+        keyframe.
+        """
+        return max([
+            key_frame_pts
+            for key_frame_pts in self.key_frames_pts
+            if key_frame_pts <= pts
+        ])
+
+    def _get_frame_by_pts(
+        self,
+        pts: int
+    ):
+        """
+        Get the frame that has the provided 'pts'.
+
+        This method will start decoding frames from the
+        most near key frame (the one with the nearer
+        pts) until the one requested is found. All those
+        frames will be stored in cache.
+
+        This method must be called when the frame 
+        requested is not stored in the caché.
+        """
+        # Look for the most near key frame
+        key_frame_pts = self._get_nearest_keyframe_fps(pts)
+
+        # Go to the key frame that includes it
+        self.container.seek(key_frame_pts, stream = self.stream)
+
+        decoded = None
+        for frame in self.container.decode(self.stream):
+            # TODO: Could 'frame' be None (?)
+            if frame.pts is None:
+                continue
+
+            # Store in cache if needed
+            if frame.pts not in self.cache:
+                # TODO: The 'format' must be dynamic
+                self.cache[frame.pts] = frame.to_ndarray(format = "rgb24")
+
+                # Clean cache if full
+                if len(self.cache) > self.size:
+                    self.cache.popitem(last = False)
+
+            if frame.pts >= pts:
+                decoded = self.cache[frame.pts]
+                break
+
+        return decoded
+
+    def get_frame(
+        self,
+        index: int
+    ) -> Union[VideoFrame, AudioFrame]:
+        """
+        Get the frame with the given 'index' from
+        the cache.
+        """
+        # TODO: Maybe we can accept 't' and 'pts' also
+        target_pts = int(index / self.fps / self.time_base)
+
+        return (
+            self.cache[target_pts]
+            if target_pts in self.cache else
+            self._get_frame_by_pts(target_pts)
+        )
+
+    def get_frames(
+        self,
+        start: float = 0,
+        end: Union[float, None] = None
+    ):
+        """
+        Get all the frames in the range between
+        the provided 'start' and 'end' time in
+        seconds.
+        """
+        # TODO: I create this method by default using
+        # the cache. Think about how to implement it
+        # and apply it here, please.
+        # Go to the nearest key frame
+        start = t_to_pts(start, self.time_base)
+        end = (
+            t_to_pts(end, self.time_base)
+            if end is not None else
+            None
+        )
+        key_frame_pts = self._get_nearest_keyframe_fps(start)
+
+        # Go to the nearest key frame to start decoding
+        self.container.seek(key_frame_pts, stream = self.stream)
+
+        for packet in self.container.demux(self.stream):
+            for frame in packet.decode():
+                if frame.pts is None:
+                    continue
+
+                if frame.pts < start:
+                    continue
+
+                if (
+                    end is not None and
+                    frame.pts > end
+                ):
+                    return
+                
+                # TODO: Maybe send a @dataclass instead (?)
+                yield (
+                    frame,
+                    pts_to_t(frame.pts, self.time_base),
+                    pts_to_index(frame.pts, self.time_base, self.fps)
+                )
+    
+    def clear(
+        self
+    ) -> 'VideoFrameCache':
+        """
+        Clear the cache by removing all the items.
+        """
+        self.cache.clear()
+
+        return self

{yta_video_opengl-0.0.8 → yta_video_opengl-0.0.9}/src/yta_video_opengl/tests.py

@@ -583,7 +583,7 @@ def video_modified_stored():
     from yta_video_opengl.utils import texture_to_frame, frame_to_texture
     from yta_video_opengl.video import Video
 
-    Video(VIDEO_PATH, 0, 0.5).save_as(OUTPUT_PATH)
+    Video(VIDEO_PATH, 0.25, 0.75).save_as(OUTPUT_PATH)
 
     return
 

{yta_video_opengl-0.0.8 → yta_video_opengl-0.0.9}/src/yta_video_opengl/video.py

@@ -89,17 +89,23 @@ class Video:
         - `t` as the frame time moment
         - `index` as the frame index
         """
-        for frame in iterate_stream_frames_demuxing(
-            container = self.reader.container,
-            video_stream = self.reader.video_stream,
-            audio_stream = self.reader.audio_stream,
-            video_start_pts = self.start_pts,
-            video_end_pts = self.end_pts,
-            audio_start_pts = self.audio_start_pts,
-            audio_end_pts = self.audio_end_pts
-        ):
+        for frame in self.reader.get_frames(self.start, self.end):
             yield frame
 
+        for frame in self.reader.get_audio_frames(self.start, self.end):
+            yield frame
+
+        # for frame in iterate_stream_frames_demuxing(
+        #     container = self.reader.container,
+        #     video_stream = self.reader.video_stream,
+        #     audio_stream = self.reader.audio_stream,
+        #     video_start_pts = self.start_pts,
+        #     video_end_pts = self.end_pts,
+        #     audio_start_pts = self.audio_start_pts,
+        #     audio_end_pts = self.audio_end_pts
+        # ):
+        #     yield frame
+
     def __init__(
         self,
         filename: str,

yta_video_opengl-0.0.8/src/yta_video_opengl/reader/cache.py

@@ -1,155 +0,0 @@
-"""
-The pyav container stores the information based
-on the packets timestamps (called 'pts'). Some
-of the packets are considered key_frames because
-they include those key frames.
-
-Also, this library uses those key frames to start
-decodifying from there to the next one, obtaining
-all the frames in between able to be read and
-modified.
-
-This cache system will look for the range of 
-frames that belong to the key frame related to the
-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.
-"""
-from collections import OrderedDict
-
-
-class VideoFrameCache:
-    """
-    Class to manage the frames cache of a video
-    within a video reader instance.
-    """
-
-    @property
-    def container(
-        self
-    ) -> 'InputContainer':
-        """
-        Shortcut to the video reader instance container.
-        """
-        return self.reader_instance.container
-    
-    @property
-    def stream(
-        self
-    ) -> 'VideoStream':
-        """
-        Shortcut to the video reader instance video
-        stream.
-        """
-        return self.reader_instance.video_stream
-
-    def __init__(
-        self,
-        reader: 'VideoReader',
-        size: int = 50
-    ):
-        self.reader_instance: 'VideoReader' = reader
-        """
-        The video reader instance this cache belongs
-        to.
-        """
-        self.cache: OrderedDict = OrderedDict()
-        """
-        The cache ordered dictionary.
-        """
-        self.size = size
-        """
-        The size (in number of frames) of the cache.
-        """
-        self.key_frames_pts: list[int] = []
-        """
-        The list that contains the timestamps of the
-        key frame packets, ordered from begining to
-        end.
-        """
-
-        # Index key frames
-        for packet in self.container.demux(self.stream):
-            if packet.is_keyframe:
-                self.key_frames_pts.append(packet.pts)
-
-        self.container.seek(0)
-        # TODO: Maybe this is better (?)
-        #self.reader_instance.reset()
-
-    def _get_frame_by_pts(
-        self,
-        target_pts
-    ):
-        """
-        Get the frame that has the provided 'target_pts'.
-
-        This method will start decoding frames from the
-        most near key frame (the one with the nearer
-        pts) until the one requested is found. All those
-        frames will be stored in cache.
-
-        This method must be called when the frame 
-        requested is not stored in the caché.
-        """
-        # Look for the most near key frame
-        key_frame_pts = max([
-            key_frame_pts
-            for key_frame_pts in self.key_frames_pts
-            if key_frame_pts <= target_pts
-        ])
-
-        # Go to the key frame that includes it
-        self.container.seek(key_frame_pts, stream = self.stream)
-
-        decoded = None
-        for frame in self.container.decode(self.stream):
-            # TODO: Could 'frame' be None (?)
-            pts = frame.pts
-            if pts is None:
-                continue
-
-            # Store in cache if needed
-            if pts not in self.cache:
-                # TODO: The 'format' must be dynamic
-                self.cache[pts] = frame.to_ndarray(format = "rgb24")
-
-                # Clean cache if full
-                if len(self.cache) > self.size:
-                    self.cache.popitem(last = False)
-
-            if pts >= target_pts:
-                decoded = self.cache[pts]
-                break
-
-        return decoded
-
-    def get_frame(
-        self,
-        index: int
-    ) -> 'VideoFrame':
-        """
-        Get the frame with the given 'index' from
-        the cache.
-        """
-        # convertir frame_number a PTS (timestamps internos)
-        time_base = self.stream.time_base
-        fps = float(self.stream.average_rate)
-        target_pts = int(index / fps / time_base)
-
-        return (
-            self.cache[target_pts]
-            if target_pts in self.cache else
-            self._get_frame_by_pts(target_pts)
-        )
-    
-    def clear(
-        self
-    ) -> 'VideoFrameCache':
-        """
-        Clear the cache by removing all the items.
-        """
-        self.cache.clear()
-
-        return self