yta-video-opengl 0.0.11__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
@@ -221,25 +194,37 @@ class VideoReader:
         return self.container.demux((self.video_stream, self.audio_stream))
 
     @property
-    def next_packet_with_audio(
+    def has_video(
         self
-    ) -> Union[Packet, None]:
+    ) -> bool:
         """
-        Get the next video frames packet (or audio
-        frames packet) from the iterator. Depending
-        on the position, the packet can be video or
-        audio.
+        Flag to indicate if there is a video stream
+        or not.
         """
-        return next(self.packet_with_audio_iterator)
+        return self.video_stream is not None
+
+    @property
+    def has_audio(
+        self
+    ) -> bool:
+        """
+        Flag to indicate if there is an audio stream
+        or not.
+        """
+        return self.audio_stream is not None
 
     @property
     def codec_name(
         self
-    ) -> str:
+    ) -> Union[str, None]:
         """
         Get the name of the video codec.
         """
-        return self.video_stream.codec_context.name
+        return (
+            self.video_stream.codec_context.name
+            if self.has_video else
+            None
+        )
     
     @property
     def audio_codec_name(
@@ -248,64 +233,89 @@ class VideoReader:
         """
         Get the name of the audio codec.
         """
-        return self.audio_stream.codec_context.name
+        return (
+            self.audio_stream.codec_context.name
+            if self.has_audio else
+            None
+        )
 
     @property
     def number_of_frames(
         self
-    ) -> int:
+    ) -> Union[int, None]:
         """
         The number of frames in the video.
         """
-        return self.video_stream.frames
+        return (
+            self.video_stream.frames
+            if self.has_video else
+            None
+        )
     
     @property
     def number_of_audio_frames(
         self
-    ) -> int:
+    ) -> Union[int, None]:
         """
         The number of frames in the audio.
         """
-        return self.audio_stream.frames
+        return (
+            self.audio_stream.frames
+            if self.has_audio else
+            None
+        )
     
     @property
     def fps(
         self
-    ) -> Fraction:
+    ) -> Union[Fraction, None]:
         """
         The fps of the video.
         """
-        # They return it as a Fraction but...
-        return self.video_stream.average_rate
+        return (
+            self.video_stream.average_rate
+            if self.has_video else
+            None
+        )
     
     @property
     def audio_fps(
         self
-    ) -> Fraction:
+    ) -> Union[int, None]:
         """
         The fps of the audio.
         """
-        # TODO: What if no audio (?)
-        return self.audio_stream.rate
+        return (
+            self.audio_stream.rate
+            if self.has_audio else
+            None
+        )
     
     @property
     def time_base(
         self
-    ) -> Fraction:
+    ) -> Union[Fraction, None]:
         """
         The time base of the video.
         """
-        return self.video_stream.time_base
+        return (
+            self.video_stream.time_base
+            if self.has_video else
+            None
+        )
 
     @property
     def audio_time_base(
         self
-    ) -> Fraction:
+    ) -> Union[Fraction, None]:
         """
         The time base of the audio.
         """
-        # TODO: What if no audio (?)
-        return self.audio_stream.time_base
+        return (
+            self.audio_stream.time_base
+            if self.has_audio else
+            None
+        )
     
     @property
     def duration(
@@ -314,10 +324,15 @@ class VideoReader:
         """
         The duration of the video.
         """
+        # TODO: What to do in the case we have
+        # video stream but not 'duration' 
+        # attribute (?)
         return (
             float(self.video_stream.duration * self.video_stream.time_base)
-            if self.video_stream.duration else
-            # TODO: What to do in this case (?)
+            if (
+                self.has_video and
+                self.video_stream.duration
+            ) else
             None
         )
 
@@ -328,43 +343,59 @@ class VideoReader:
         """
         The duration of the audio.
         """
-        # TODO: What if no audio (?)
+        # TODO: What to do in the case we have
+        # audio stream but not 'duration' 
+        # attribute (?)
         return (
             float(self.audio_stream.duration * self.audio_stream.time_base)
-            if self.audio_stream.duration else
-            # TODO: What to do in this case (?)
+            if (
+                self.has_audio and
+                self.audio_stream.duration
+            ) else
             None
         )
     
     @property
     def size(
         self
-    ) -> tuple[int, int]:
+    ) -> Union[tuple[int, int], None]:
         """
         The size of the video in a (width, height) format.
         """
         return (
-            self.video_stream.width,
-            self.video_stream.height
+            (
+                self.video_stream.width,
+                self.video_stream.height
+            )
+            if self.has_video else
+            None
         )
     
     @property
     def width(
         self
-    ) -> int:
+    ) -> Union[int, None]:
         """
         The width of the video, in pixels.
         """
-        return self.size[0]
+        return (
+            self.size[0]
+            if self.size is not None else
+            None
+        )
     
     @property
     def height(
         self
-    ) -> int:
+    ) -> Union[int, None]:
         """
         The height of the video, in pixels.
         """
-        return self.size[1]
+        return (
+            self.size[1]
+            if self.size is not None else
+            None
+        )
     
     # Any property related to audio has to
     # start with 'audio_property_name'
@@ -389,14 +420,15 @@ class VideoReader:
         video (that also includes the audio) we
         are reading.
         """
-        self.video_stream: VideoStream = None
+        self.video_stream: Union[VideoStream, None] = None
         """
-        The stream that includes the video.
+        The stream that includes the video. If
+        no video stream this will be None.
         """
-        # TODO: What if no audio (?)
-        self.audio_stream: AudioStream = None
+        self.audio_stream: Union[AudioStream, None] = None
         """
-        The stream that includes the audio.
+        The stream that includes the audio. If
+        no audio stream this will be None.
         """
         self.video_cache: VideoFrameCache = None
         """
@@ -434,22 +466,42 @@ class VideoReader:
             #self.container.close()
         else:
             self.container = av_open(self.filename)
+            
+            self.video_stream = (
+                self.container.streams.video[0]
+                if self.container.streams.video else
+                None
+            )
             # 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 = (
+                self.container.streams.audio[0]
+                if self.container.streams.audio else
+                None
+            )
+            # TODO: Should this be 'AUTO' (?)
             self.audio_stream.thread_type = 'AUTO'
+
+            if (
+                self.video_stream is None and
+                self.audio_stream is None
+            ):
+                raise Exception(f'No video nor audio stream found in the "{self.filename}" file.')
+
             self.video_cache = VideoFrameCache(self.container, self.video_stream)
             self.audio_cache = VideoFrameCache(self.container, self.audio_stream)
 
     def seek(
         self,
-        pts,
+        pts: int,
         stream = None
     ) -> 'VideoReader':
         """
         Call the container '.seek()' method with
-        the given 'pts' packet time stamp.
+        the given 'pts' packet time stamp. By
+        default, the video stream is the one in
+        which we apply the seek.
         """
         stream = (
             self.video_stream
@@ -458,7 +510,10 @@ class VideoReader:
         )
 
         # TODO: Is 'offset' actually a 'pts' (?)
-        self.container.seek(pts, stream = stream)
+        self.container.seek(
+            offset = pts,
+            stream = stream
+        )
 
         return self
 
@@ -472,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
             )
 
@@ -577,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
@@ -585,21 +641,49 @@ class VideoReader:
         """
         return self.video_cache.get_frame_from_t(t)
     
-    # TODO: Will we use this (?)
     def get_audio_frame(
         self,
         index: int
-    ) -> 'VideoFrame':
+    ) -> 'AudioFrame':
         """
         Get the audio frame with the given 'index',
         using the audio cache system.
         """
-        return self.video_cache.get_frame(index)
+        return self.audio_cache.get_frame(index)
+
+    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.
+        """
+        return self.audio_cache.get_frame_from_t(t)
+    
+    def get_audio_frames_from_t(
+        self,
+        t: Union[int, float, Fraction]
+    ):
+        """
+        Get the sequence of audio frames for the 
+        given video 't' time moment, using the
+        audio cache system.
+
+        This is useful when we want to write a
+        video frame with its audio, so we obtain
+        all the audio frames associated to it
+        (remember that a video frame is associated
+        with more than 1 audio frame).
+        """
+        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
@@ -610,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
@@ -629,6 +713,23 @@ 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,
+    audio_fps: float
+):
+    # Remember, from [t_start, t_end), the last one
+    # is not included
+    audio_t_start = int(t * audio_fps)
+    audio_t_end = int((t + 1.0 / video_fps) * audio_fps)
+
+    return [
+        i / audio_fps
+        for i in range(audio_t_start, audio_t_end)
+    ]
+
 
 
 """