yta-video-opengl 0.0.10__py3-none-any.whl → 0.0.12__py3-none-any.whl

yta_video_opengl/complete/video_on_track.py

@@ -0,0 +1,149 @@
+"""
+If we have a video placed in a timeline,
+starting at the t=2s and the video lasts
+2 seconds, the `t` time range in which the
+video is playing is `[2s, 4s]`, so here 
+you have some examples with global `t` 
+values:
+- `t=1`, the video is not playing because
+it starts at `t=2`
+- `t=3`, the video is playing, it started
+at `t=2` and it has been playing during 1s
+- `t=5`, the video is not playing because
+it started at `t=2`, lasting 2s, so it
+finished at `t=4`
+"""
+from yta_video_opengl.video import Video
+from yta_validation.parameter import ParameterValidator
+from av.video.frame import VideoFrame
+from av.audio.frame import AudioFrame
+from typing import Union
+
+
+class VideoOnTrack:
+    """
+    A video in the timeline.
+    """
+
+    @property
+    def end(
+        self
+    ) -> float:
+        """
+        The end time moment 't' of the video once
+        once its been placed on the track, which
+        is affected by the video duration and its
+        start time moment on the track.
+
+        This end is different from the video end.
+        """
+        return self.start + self.video.duration
+
+    def __init__(
+        self,
+        video: Video,
+        start: float = 0.0
+    ):
+        ParameterValidator.validate_mandatory_instance_of('video', video, Video)
+        ParameterValidator.validate_mandatory_positive_number('start', start, do_include_zero = True)
+
+        self.video: Video = video
+        """
+        The video source, with all its properties,
+        that is placed in the timeline.
+        """
+        self.start: float = float(start)
+        """
+        The time moment in which the video should
+        start playing, within the timeline.
+
+        This is the time respect to the timeline
+        and its different from the video `start`
+        time, which is related to the file.
+        """
+
+    def _get_video_t(
+        self,
+        t: float
+    ) -> float:
+        """
+        The video 't' time moment for the given
+        global 't' time moment. This 't' is the one
+        to use inside the video content to display
+        its frame.
+        """
+        return t - self.start
+
+    def is_playing(
+        self,
+        t: float
+    ) -> bool:
+        """
+        Check if this video is playing at the general
+        't' time moment, which is a global time moment
+        for the whole project.
+        """
+        return self.start <= t < self.end
+
+    def get_frame_at(
+        self,
+        t: float
+    ) -> Union[VideoFrame, None]:
+        """
+        Get the frame for the 't' time moment provided,
+        that could be None if the video is not playing
+        in that moment.
+        """
+        return (
+            self.video.reader.get_frame_from_t(self._get_video_t(t))
+            if self.is_playing(t) else
+            None
+        )
+    
+    def get_audio_frame_at(
+        self,
+        t: float
+    ) -> Union[AudioFrame, None]:
+        """
+        Get the audio frame for the 't' time moment
+        provided, that could be None if the video
+        is not playing in that moment.
+        """
+        return (
+            self.video.reader.get_audio_frame_from_t(self._get_video_t(t))
+            if self.is_playing(t) else
+            None
+        )
+    
+    def get_audio_frames_at(
+        self,
+        t: float
+    ) -> Union[any, None]:
+        """
+        Get the audio frames that must be played at
+        the 't' time moment provided, that could be
+        None if the video is not playing at that
+        moment.
+
+        This method will return None if no audio
+        frames found in that 't' time moment, or an
+        iterator if yes.
+        """
+        frames = (
+            self.video.reader.get_audio_frames_from_t(self._get_video_t(t))
+            if self.is_playing(t) else
+            []
+        )
+
+        for frame in frames:
+            # TODO: I am generating a tuple in the
+            # src\yta_video_opengl\reader\cache.py
+            # get_frames method... maybe remove it (?)
+            yield frame[0]
+
+        # # TODO: This was a simple return before
+        # return (
+        #     self.video.reader.get_audio_frames_from_t(self._get_video_t(t))
+        #     if self.is_playing(t) else
+        #     None
+        # )

yta_video_opengl/reader/__init__.py

@@ -231,15 +231,39 @@ class VideoReader:
         audio.
         """
         return next(self.packet_with_audio_iterator)
+    
+    @property
+    def has_video(
+        self
+    ) -> bool:
+        """
+        Flag to indicate if there is a video stream
+        or not.
+        """
+        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 +272,91 @@ 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 (
+            # They return it as a Fraction but we usually
+            # use it as float or even int
+            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 +365,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 +384,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 +461,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,11 +507,28 @@ 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)
 
@@ -449,7 +539,9 @@ class VideoReader:
     ) -> '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 +550,10 @@ class VideoReader:
         )
 
         # TODO: Is 'offset' actually a 'pts' (?)
-        self.container.seek(pts, stream = stream)
+        self.container.seek(
+            offset = pts,
+            stream = stream
+        )
 
         return self
 
@@ -575,16 +670,54 @@ class VideoReader:
         """
         return self.video_cache.get_frame(index)
     
-    # TODO: Will we use this (?)
+    def get_frame_from_t(
+        self,
+        t: float
+    ) -> 'VideoFrame':
+        """
+        Get the video frame with the given 't' time
+        moment, using the video cache system.
+        """
+        return self.video_cache.get_frame_from_t(t)
+    
     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: float
+    ) -> '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: float
+    ):
+        """
+        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).
+        """
+        print(f'Getting audio frames from video, from t:{str(t)} - nt:{str(t + (1 / self.fps))}')
+        for frame in self.audio_cache.get_frames(t, t + (1 / self.fps)):
+            yield frame
     
     def get_frames(
         self,
@@ -619,6 +752,21 @@ class VideoReader:
         self.container.close()
 
 
+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)
+    ]
+
 
 
 """