yta-video-opengl 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

yta_video_opengl/{reader.py → reader/__init__.py}

@@ -2,6 +2,7 @@
 A video reader using the PyAv (av) library
 that, using ffmpeg, detects the video.
 """
+from yta_video_opengl.reader.cache import VideoFrameCache
 from yta_validation import PythonValidator
 from av.video.frame import VideoFrame
 from av.audio.frame import AudioFrame
@@ -31,7 +32,7 @@ class VideoReaderFrame:
         Flag to indicate if the instance is a video
         frame.
         """
-        return PythonValidator.is_instance_of(self.data, VideoFrame)
+        return PythonValidator.is_instance_of(self.value, VideoFrame)
     
     @property
     def is_audio(
@@ -41,18 +42,37 @@ class VideoReaderFrame:
         Flag to indicate if the instance is an audio
         frame.
         """
-        return PythonValidator.is_instance_of(self.data, AudioFrame)
+        return PythonValidator.is_instance_of(self.value, AudioFrame)
+    
+    @property
+    def as_numpy(
+        self
+    ):
+        """
+        The frame as a numpy array.
+        """
+        return self.value.to_ndarray(format = self.pixel_format)
     
     def __init__(
         self,
         # TODO: Add the type, please
-        data: any
+        frame: any,
+        t: float = None,
+        pixel_format: str = 'rgb24'
     ):
-        self.data: Union[AudioFrame, VideoFrame] = data
+        self.value: Union[AudioFrame, VideoFrame] = frame
         """
         The frame content, that can be audio or video
         frame.
         """
+        self.t: float = t
+        """
+        The 't' time moment of the frame.
+        """
+        self.pixel_format: str = pixel_format
+        """
+        The pixel format of the frame.
+        """
 
 @dataclass
 class VideoReaderPacket:
@@ -70,7 +90,7 @@ class VideoReaderPacket:
         Flag to indicate if the packet includes video
         frames or not.
         """
-        return self.data.stream.type == 'video'
+        return self.value.stream.type == 'video'
     
     @property
     def is_audio(
@@ -80,13 +100,13 @@ class VideoReaderPacket:
         Flag to indicate if the packet includes audio
         frames or not.
         """
-        return self.data.stream.type == 'audio'
+        return self.value.stream.type == 'audio'
 
     def __init__(
         self,
-        data: Packet
+        packet: Packet
     ):
-        self.data: Packet = data
+        self.value: Packet = packet
         """
         The packet, that can include video or audio
         frames and can be decoded.
@@ -99,7 +119,7 @@ class VideoReaderPacket:
         Get the frames but decoded, perfect to make
         modifications and encode to save them again.
         """
-        return self.data.decode()
+        return self.value.decode()
         
 
 class VideoReader:
@@ -267,6 +287,24 @@ class VideoReader:
         # TODO: What if no audio (?)
         return self.audio_stream.average_rate
     
+    @property
+    def time_base(
+        self
+    ) -> Fraction:
+        """
+        The time base of the video.
+        """
+        return self.video_stream.time_base
+
+    @property
+    def audio_time_base(
+        self
+    ) -> Fraction:
+        """
+        The time base of the audio.
+        """
+        return self.audio_stream.time_base
+    
     @property
     def size(
         self
@@ -302,29 +340,70 @@ class VideoReader:
 
     def __init__(
         self,
-        filename: str
+        filename: str,
+        # Use 'rgba' if alpha channel
+        pixel_format: str = 'rgb24'
     ):
         self.filename: str = filename
         """
         The filename of the video source.
         """
-        self.container: InputContainer = av_open(filename)
+        self.pixel_format: str = pixel_format
+        """
+        The pixel format.
+        """
+        self.container: InputContainer = None
         """
         The av input general container of the
         video (that also includes the audio) we
         are reading.
         """
-        self.video_stream: VideoStream = self.container.streams.video[0]
+        self.video_stream: VideoStream = None
         """
         The stream that includes the video.
         """
-        self.video_stream.thread_type = 'AUTO'
         # TODO: What if no audio (?)
-        self.audio_stream: AudioStream = self.container.streams.audio[0]
+        self.audio_stream: AudioStream = None
         """
         The stream that includes the audio.
         """
-        self.audio_stream.thread_type = 'AUTO'
+        self.cache: VideoFrameCache = None
+        """
+        The frame cache system to optimize
+        the way we access to the frames.
+        """
+
+        # TODO: Maybe we can read the first 
+        # frame, store it and reset, so we have
+        # it in memory since the first moment.
+        # We should do it here because if we
+        # iterate in some moment and then we
+        # want to obtain it... it will be 
+        # difficult.
+        # Lets load the variables
+        self.reset()
+
+    def reset(
+        self
+    ) -> 'VideoReader':
+        """
+        Reset all the instances, closing the file
+        and opening again.
+
+        This will also return to the first frame.
+        """
+        if self.container is not None:
+            # TODO: Maybe accept forcing it (?)
+            self.container.seek(0)
+            #self.container.close()
+        else:
+            self.container = av_open(self.filename)
+            # TODO: Should this be 'AUTO' (?)
+            self.video_stream = self.container.streams.video[0]
+            self.video_stream.thread_type = 'AUTO'
+            self.audio_stream = self.container.streams.audio[0]
+            self.audio_stream.thread_type = 'AUTO'
+            self.cache = VideoFrameCache(self)
 
     def iterate(
         self
@@ -334,7 +413,11 @@ class VideoReader:
         (already decoded).
         """
         for frame in self.frame_iterator:
-            yield VideoReaderFrame(frame)
+            yield VideoReaderFrame(
+                frame = frame,
+                t = float(frame.pts * self.time_base),
+                pixel_format = self.pixel_format
+            )
 
     def iterate_with_audio(
         self,
@@ -373,6 +456,25 @@ class VideoReader:
                 # Return the packet as it is
                 yield VideoReaderPacket(packet)
 
+    # TODO: Will we use this (?)
+    def get_frame(
+        self,
+        index: int
+    ) -> 'VideoFrame':
+        """
+        Get the frame with the given 'index', using
+        the cache system.
+        """
+        return self.cache.get_frame(index)
+    
+    def close(
+        self
+    ) -> None:
+        """
+        Close the container to free it.
+        """
+        self.container.close()
+
 
 
 

yta_video_opengl/reader/cache.py

@@ -0,0 +1,155 @@
+"""
+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