yta-video-opengl 0.0.4__py3-none-any.whl → 0.0.6__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
@@ -308,23 +309,58 @@ class VideoReader:
         """
         The filename of the video source.
         """
-        self.container: InputContainer = av_open(filename)
+        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
@@ -350,17 +386,8 @@ class VideoReader:
         frame individually as a VideoReaderFrame 
         instance. If not, the whole packet as a
         VideoReaderPacket instance.
-
-        If the frame is the last one, with size == 0,
-        it will return None as it must not be passed
-        to the muxer '.mux()' method.
         """
         for packet in self.packet_with_audio_iterator:
-            if packet.size == 0:
-                # End packet, not for muxer
-                yield None
-                continue
-
             is_video = packet.stream.type == 'video'
 
             do_decode = (
@@ -382,38 +409,29 @@ 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)
 
 
 
-"""
-Read this below if you can to combine videos
-that have not been written yet to the disk
-(maybe a composition in moviepy or I don't
-know).
-
-Usar un pipe (sin escribir archivo completo)
-Puedes lanzar un proceso FFmpeg que envíe el vídeo a PyAV por stdin como flujo sin codificar (por ejemplo en rawvideo), así no tienes que escribir el archivo final.
-Ejemplo:
-
-PYTHON_CODE:
-import subprocess
-import av
-
-# FFmpeg produce frames en crudo por stdout
-ffmpeg_proc = subprocess.Popen(
-    [
-        "ffmpeg",
-        "-i", "-",       # Lee de stdin
-        "-f", "rawvideo",
-        "-pix_fmt", "rgba",
-        "-"
-    ],
-    stdin=subprocess.PIPE,
-    stdout=subprocess.PIPE
-)
 
-# Aquí enviarías los datos combinados desde tu programa al ffmpeg_proc.stdin
-# y podrías leer con PyAV o directamente procesar arrays de píxeles
+"""
+When reading packets directly from the stream
+we can receive packets with size=0, but we need
+to process them and decode (or yield them). It
+is only when we are passing packets to the mux
+when we need to ignore teh ones thar are empty
+(size=0).
 
-Esto es lo más usado para pipeline de vídeo en tiempo real.
+TODO: Do we need to ignore all? By now, ignoring
+not is causing exceptions, and ignoring them is
+making it work perfectly.
 """

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