yta-video-opengl 0.0.20__py3-none-any.whl → 0.0.22__py3-none-any.whl

yta_video_opengl/complete/track/__init__.py

@@ -43,15 +43,17 @@ class _Track(ABC):
         """
         The end of the last audio of this track,
         which is also the end of the track. This
-        is the last time moment that has to be
-        rendered.
+        is the last time moment that has not to
+        be rendered because its the end and it
+        is not included -> [start, end).
         """
         return Fraction(
-            0.0
-            if len(self.medias) == 0 else
             max(
-                media.end
-                for media in self.medias
+                (
+                    media.end
+                    for media in self.medias
+                ),
+                default = 0.0
             )
         )
     
@@ -185,7 +187,7 @@ class _Track(ABC):
             t = t.truncated
         else:
             t = self.end
-        
+
         self._medias.append(self._make_media_on_track(
             media = media,
             start = t
@@ -344,10 +346,15 @@ class _TrackWithAudio(_Track):
                 format = self.audio_format
             )
             if self.is_muted else
+            # TODO: What if we find None here (?)
             self._get_part_at_t(t).get_audio_frames_at(t)
         )
 
         for frame in frames:
+            print('      HELLO       ')
+            print(frame)
+            if frame == []:
+                print(f'   [ERROR] Audio frame t:{str(float(t))} not obtained.')
             yield frame
 
 class _TrackWithVideo(_Track):

yta_video_opengl/complete/track/parts.py

@@ -68,20 +68,19 @@ class _Part(ABC):
         to fulfill.
         """
 
-class _AudioPart(_Part):
+class _PartWithAudio(_Part):
     """
-    Class to represent an element that is on the
-    track, that can be an empty space or an audio.
+    TODO: Explain
     """
 
     def __init__(
         self,
-        track: 'AudioTrack',
+        track: Union['AudioTrack', 'VideoTrack'],
         start: Union[int, float, Fraction],
         end: Union[int, float, Fraction],
-        media: Union[AudioOnTrack, None] = None
+        media: Union[AudioOnTrack, VideoOnTrack, None] = None
     ):
-        ParameterValidator.validate_instance_of('media', media, AudioOnTrack)
+        ParameterValidator.validate_instance_of('media', media, [AudioOnTrack, VideoOnTrack])
 
         super().__init__(
             track = track,
@@ -105,13 +104,25 @@ class _AudioPart(_Part):
         Iterate over all the audio frames that
         exist at the time moment 't' provided.
         """
+        frames = []
         if not self.is_empty_part:
-            for frame in self.media.get_audio_frames_at(t):
-                yield AudioFrameWrapped(
-                    frame = frame,
-                    is_from_empty_part = False
-                )
-        else:
+            # TODO: What do we do in this case (?)
+            frames = list(self.media.get_audio_frames_at(t))
+
+            if len(frames) == 0:
+                print(f'   [ERROR] Audio frame {str(float(t))} was not obtained')
+            else:
+                frames = [
+                    AudioFrameWrapped(
+                        frame = frame,
+                        is_from_empty_part = False
+                    )
+                    for frame in frames
+                ]
+
+        # This could be because is empty part or
+        # because we couldn't obtain the frames
+        if len(frames) == 0:
             frames = generate_silent_frames(
                 fps = self._track.fps,
                 audio_fps = self._track.audio_fps,
@@ -121,13 +132,12 @@ class _AudioPart(_Part):
                 format = self._track.audio_format
             )
 
-            for frame in frames:
-                yield frame
+        for frame in frames:
+            yield frame
 
-class _VideoPart(_Part):
+class _PartWithVideo(_Part):
     """
-    Class to represent an element that is on the
-    track, that can be an empty space or a video.
+    TODO: Explain
     """
 
     def __init__(
@@ -152,12 +162,6 @@ class _VideoPart(_Part):
         Useful internal tool to generate background
         frames for the empty parts.
         """
-        # TODO: Can I refactor this below (?)
-        self._audio_frame_generator: AudioFrameGenerator = AudioFrameGenerator()
-        """
-        Useful internal tool to generate silent
-        audio frames for the empty parts.
-        """
 
     def get_frame_at(
         self,
@@ -167,25 +171,42 @@ class _VideoPart(_Part):
         Get the frame that must be displayed at 
         the given 't' time moment.
         """
-        frame = (
-            # TODO: What about the 'format' (?)
-            # TODO: Maybe I shouldn't set the 'time_base'
-            # here and do it just in the Timeline 'render'
-            #return get_black_background_video_frame(self._track.size)
-            # TODO: This 'time_base' maybe has to be related
-            # to a Timeline general 'time_base' and not the fps
-            VideoFrameWrapped(
-                frame = self._video_frame_generator.background.full_black(
+        is_from_empty_part = False
+        if self.is_empty_part:
+            frame = self._video_frame_generator.background.full_black(
+                size = self._track.size,
+                time_base = fps_to_time_base(self._track.fps)
+            )
+
+            is_from_empty_part = True
+        else:
+            # TODO: This can be None, why? I don't know...
+            frame = self.media.get_frame_at(t)
+
+            if frame is None:
+                print(f'   [ERROR] Frame {str(float(t))} was not obtained')
+
+            frame = (
+                # I'm using a red full frame to be able to detect
+                # fast the frames that were not available, but
+                # I need to find the error and find a real solution
+                self._video_frame_generator.background.full_red(
                     size = self._track.size,
                     time_base = fps_to_time_base(self._track.fps)
-                ),
-                is_from_empty_part = True
-            )
-            if self.is_empty_part else
-            VideoFrameWrapped(
-                frame = self.media.get_frame_at(t),
-                is_from_empty_part = False
+                )
+                if frame is None else
+                frame
             )
+
+        # TODO: What about the 'format' (?)
+        # TODO: Maybe I shouldn't set the 'time_base'
+        # here and do it just in the Timeline 'render'
+        #return get_black_background_video_frame(self._track.size)
+        # TODO: This 'time_base' maybe has to be related
+        # to a Timeline general 'time_base' and not the fps
+        frame = VideoFrameWrapped(
+            frame = frame,
+            is_from_empty_part = is_from_empty_part
         )
 
         # TODO: This should not happen because of
@@ -201,30 +222,46 @@ class _VideoPart(_Part):
         
         return frame
 
-    def get_audio_frames_at(
+class _AudioPart(_PartWithAudio):
+    """
+    Class to represent an element that is on the
+    track, that can be an empty space or an audio.
+    """
+
+    def __init__(
         self,
-        t: Union[int, float, Fraction]
+        track: 'AudioTrack',
+        start: Union[int, float, Fraction],
+        end: Union[int, float, Fraction],
+        media: Union[AudioOnTrack, None] = None
     ):
-        """
-        Iterate over all the audio frames that
-        exist at the time moment 't' provided.
-        """
-        if not self.is_empty_part:
-            for frame in self.media.get_audio_frames_at(t):
-                yield AudioFrameWrapped(
-                    frame = frame,
-                    is_from_empty_part = False
-                )
-        else:
-            frames = generate_silent_frames(
-                fps = self._track.fps,
-                audio_fps = self._track.audio_fps,
-                audio_samples_per_frame = self._track.audio_samples_per_frame,
-                # TODO: Where do this 2 formats come from (?)
-                layout = self._track.audio_layout,
-                format = self._track.audio_format
-            )
+        ParameterValidator.validate_instance_of('media', media, AudioOnTrack)
+
+        super().__init__(
+            track = track,
+            start = start,
+            end = end,
+            media = media
+        )
+
+class _VideoPart(_PartWithAudio, _PartWithVideo):
+    """
+    Class to represent an element that is on the
+    track, that can be an empty space or a video.
+    """
 
-            for frame in frames:
-                yield frame
+    def __init__(
+        self,
+        track: 'VideoTrack',
+        start: Union[int, float, Fraction],
+        end: Union[int, float, Fraction],
+        media: Union[VideoOnTrack, None] = None
+    ):
+        ParameterValidator.validate_instance_of('media', media, VideoOnTrack)
 
+        super().__init__(
+            track = track,
+            start = start,
+            end = end,
+            media = media
+        )

yta_video_opengl/media.py

@@ -0,0 +1,347 @@
+
+"""
+The pyav uses Pillow to load an image as
+a numpy array but using not the alpha.
+"""
+from yta_video_opengl.complete.frame_generator import VideoFrameGenerator
+from yta_video_opengl.writer import VideoWriter
+from yta_video_opengl.t import get_ts
+from av.video.frame import VideoFrame
+from yta_validation.parameter import ParameterValidator
+from yta_validation import PythonValidator
+from quicktions import Fraction
+from PIL import Image
+from abc import ABC, abstractmethod
+from typing import Union
+
+import numpy as np
+
+
+class _Media(ABC):
+    """
+    Class to represent an element that can be
+    used in our video editor, that can be a
+    video, an audio, an image, a color frame,
+    etc.
+    """
+
+    @property
+    def duration(
+        self
+    ) -> Fraction:
+        """
+        The duration of the media.
+        """
+        return self.end - self.start
+
+    def __init__(
+        self,
+        start: Union[int, float, Fraction],
+        end: Union[int, float, Fraction]
+    ):
+        self.start: Fraction = Fraction(start)
+        """
+        The time moment 't' in which the media
+        should start.
+        """
+        self.end: Fraction = Fraction(end)
+        """
+        The time moment 't' in which the media
+        should end.
+        """
+
+    def _get_t(
+        self,
+        t: Union[int, float, Fraction]
+    ) -> Fraction:
+        """
+        Get the real 't' time moment based on the
+        media 'start' and 'end'. If they were 
+        asking for the t=0.5s but our media was
+        subclipped to [1.0, 2.0), the 0.5s must be
+        actually the 1.5s of the media because of
+        the subclipped time range.
+
+        This method will raise an exception if the
+        't' time moment provided, when adjusted to
+        the internal media start and end time, is
+        not valid (is after the end).
+        """
+        t += self.start
+        
+        if t >= self.end:
+            raise Exception(f'The "t" ({str(t)}) provided is out of range. This media lasts from [{str(self.start)}, {str(self.end)}).')
+        
+        return t
+    
+class _CanBeSavedAsVideo:
+    """
+    Class to implement the functionality of
+    being written into a video file, frame
+    by frame.
+    """
+
+    def save_as(
+        self,
+        output_filename: str,
+        fps: Union[int, float, Fraction] = 60.0,
+        video_codec: str = 'h264',
+        video_pixel_format: str = 'yuv420p'
+    ) -> '_CanBeSavedAsVideo':
+        """
+        Save the media as a video to the
+        given 'output_filename' file.
+        """
+        writer = VideoWriter(output_filename)
+
+        fps = int(fps)
+
+        # TODO: This has to be dynamic according to the
+        # video we are writing (?)
+        writer.set_video_stream(
+            codec_name = video_codec,
+            fps = fps,
+            size = self.size,
+            pixel_format = video_pixel_format
+        )
+
+        for index, t in enumerate(get_ts(self.start, self.end, fps)):
+            frame = self.get_frame_from_t(t)
+            frame.pts = index
+            frame.time_base = Fraction(1, fps)
+
+            writer.mux_video_frame(
+                frame = frame
+            )
+
+        writer.mux_video_frame(None)
+        writer.output.close()
+
+        return self
+    
+class _HasVideoFrame(ABC):
+    """
+    Class to be inherited by all those classes
+    that have video frames.
+    """
+
+    # TODO: Maybe force
+    # size: tuple[int, int] = (1920, 1080),
+    # dtype: dtype = np.uint8,
+    # format: str = 'rgb24'
+    # on __init__ (?)
+
+    @abstractmethod
+    def get_frame_from_t(
+        self,
+        t: Union[int, float, Fraction]
+    ) -> 'VideoFrame':
+        """
+        Get the video frame with the given 't' time
+        moment.
+        """
+        # TODO: Maybe 
+        pass
+
+class _HasAudioFrame(ABC):
+    """
+    Class to be inherited by all those classes
+    that have audio frames.
+    """
+
+    @abstractmethod
+    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).
+        """
+        pass
+    
+class _StaticMedia(_Media, _HasVideoFrame, _CanBeSavedAsVideo):
+    """
+    Class to represent a media that doesn't
+    change during its whole duration and
+    the frame is the same, it remains static.
+
+    This class must be implemented by our
+    ImageMedia and ColorMedia as the frame
+    will be always the same, an image or
+    a color frame.
+    """
+
+    @property
+    @abstractmethod
+    def frame(
+        self
+    ) -> VideoFrame:
+        """
+        The frame that must be displayed.
+        """
+        pass
+
+    def __init__(
+        self,
+        start: Union[int, float, Fraction],
+        end: Union[int, float, Fraction]
+    ):
+        _Media.__init__(
+            self,
+            start = start,
+            end = end
+        )
+
+    def get_frame_from_t(
+        self,
+        t: Union[int, float, Fraction]
+    ) -> VideoFrame:
+        """
+        Get the video frame with the given 't' time
+        moment.
+        """
+        # This will raise an exception if invalid 't'
+        # when adapted to its internal 'start' and 'end'
+        t = self._get_t(t)
+
+        # TODO: What if we need to resize the source
+        # before putting it into a video frame (?)
+
+        return self.frame
+
+class ColorMedia(_StaticMedia):
+    """
+    A media that will be a single color video
+    frame during its whole duration.
+    """
+
+    @property
+    def frame(
+        self
+    ) -> VideoFrame:
+        """
+        The frame that must be displayed.
+        """
+        # TODO: Make this use the 'color'
+        # TODO: I need to implement the alpha layer
+        return VideoFrameGenerator().background.full_white(
+            size = self.size
+        )
+
+    def __init__(
+        self,
+        # TODO: Apply format
+        color: any,
+        start: Union[int, float, Fraction],
+        end: Union[int, float, Fraction],
+        size: tuple[int, int] = (1920, 1080),
+        # TODO: Do I need this (?)
+        # dtype: dtype = np.uint8,
+        # format: str = 'rgb24',
+    ):
+        # TODO: Apply format
+        self._color: any = color
+        """
+        The color that will be used to make the
+        frame that will be played its whole
+        duration.
+        """
+        self.size: tuple[int, int] = size
+        """
+        The size of the media frame.
+        """
+
+        super().__init__(
+            start = start,
+            end = end
+        )
+
+class ImageMedia(_StaticMedia):
+    """
+    A media that will be a single image 
+    during its whole duration.
+    """
+
+    @property
+    def frame(
+        self
+    ) -> VideoFrame:
+        """
+        The frame that must be displayed.
+        """
+        # By default we use it accepting transparency
+        # TODO: The image must be like this:
+        # arr = np.array(img)  # shape (h, w, 4), dtype=uint8
+        # TODO: What value if no alpha (?)
+        return VideoFrame.from_ndarray(self._image, format = 'rgba')
+
+    def __init__(
+        self,
+        # TODO: It must be RGB
+        image: Union[np.ndarray, str],
+        start: Union[int, float, Fraction],
+        end: Union[int, float, Fraction],
+        size: tuple[int, int] = (1920, 1080),
+        do_include_alpha: bool = True,
+        # TODO: Do I need this (?)
+        # dtype: dtype = np.uint8,
+        # TODO: Maybe this 'format' need to be
+        # dynamic according to if we are reading
+        # the alpha channel or not...
+        # format: str = 'rgb24',
+    ):
+        ParameterValidator.validate_mandatory_instance_of('image', image, [str, np.ndarray])
+        ParameterValidator.validate_mandatory_positive_number('start', start, do_include_zero = True)
+        ParameterValidator.validate_mandatory_positive_number('end', end, do_include_zero = False)
+        ParameterValidator.validate_mandatory_bool('do_include_alpha', do_include_alpha)
+
+        image = (
+            image_to_numpy_pillow(image, do_include_alpha = do_include_alpha)
+            if PythonValidator.is_string(image) else
+            image
+        )
+
+        self._image: np.ndarray = image
+        """
+        The image that will be used to make the
+        frame that will be played its whole
+        duration.
+        """
+        self.size: tuple[int, int] = size
+        """
+        The size of the media frame.
+        """
+
+        super().__init__(
+            start = start,
+            end = end
+        )
+
+# TODO: Need to implement Video as the others
+# are implemented here
+
+# TODO: I think I have this util in another
+# library, so please check it...
+def image_to_numpy_pillow(
+    filename: str,
+    do_include_alpha: bool = True
+) -> 'np.ndarray':
+    """
+    Read the imagen file 'filename' and transform
+    it into a numpy, reading also the alpha channel.
+    """
+    mode = (
+        'RGBA'
+        if do_include_alpha else
+        'RGB'
+    )
+
+    return np.array(Image.open(filename).convert(mode))

yta_video_opengl/reader/cache/__init__.py

@@ -155,11 +155,15 @@ class FrameCache(ABC):
         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
-        ])
+        return max(
+            (
+                key_frame_pts
+                for key_frame_pts in self.key_frames_pts
+                if key_frame_pts <= pts
+            ),
+            # If no key frames, just 0
+            default = 0
+        )
 
     def _store_frame_in_cache(
         self,

yta_video_opengl/tests.py

@@ -597,6 +597,39 @@ def video_modified_stored():
     # # timeline.add_video(Video('C:/Users/dania/Downloads/Y2meta.app-10 Smooth Transitions Green Screen Template For Kinemaster, Alight Motion, Filmora, premiere pro-(1080p).mp4', 2.25, 3.0), 3)
     # timeline.render(OUTPUT_PATH)
 
+    # # Testing concatenating
+    # timeline = Timeline()
+    # # When you concat like this, some of the
+    # # videos have frames that cannot be accessed
+    # # and I don't know why...
+    # timeline.add_video(Video('test_files/glitch_rgb_frame.mp4'))
+    # timeline.add_video(Video('test_files/output.mp4'))
+    # timeline.add_video(Video('test_files/output_render.mp4'))
+    # timeline.add_video(Video('test_files/strange_tv_frame.mp4'))
+    # timeline.add_video(Video('test_files/test_1.mp4'))
+    # timeline.add_video(Video('test_files/test_1_short_2.mp4'))
+    # timeline.add_video(Video('test_files/test_audio_1st_track_solo_v0_0_15.mp4'))
+    # timeline.add_video(Video('test_files/test_audio_2nd_track_solo_v0_0_15.mp4'))
+    # timeline.add_video(Video('test_files/test_audio_combined_tracks_v0_0_015.mp4'))
+    # timeline.add_video(Video('test_files/test_audio_combined_v0_0_15.mp4'))
+    # timeline.add_video(Video('test_files/test_blend_add_v0_0_16.mp4'))
+    # timeline.add_video(Video('test_files/test_blend_difference_v0_0_16.mp4'))
+    # timeline.add_video(Video('test_files/test_blend_multiply_v0_0_16.mp4'))
+    # timeline.add_video(Video('test_files/test_blend_overlay_v0_0_16.mp4'))
+    # timeline.add_video(Video('test_files/test_blend_screen_v0_0_16.mp4'))
+    # timeline.add_video(Video('test_files/test_combine_skipping_empty_using_priority_v0_0_18.mp4'))
+    # timeline.add_video(Video('test_files/test_ok_v0_0_13.mp4'))
+
+    # timeline.render('test_files/concatenated.mp4')
+
+    from yta_video_opengl.media import ImageMedia, ColorMedia
+
+    image_media = ImageMedia('C:/Users/dania/Desktop/PROYECTOS/RECURSOS/mobile_alpha.png', 0, 1).save_as('test_files/test_image.mp4')
+
+    color_media = ColorMedia('random', 0, 1).save_as('test_files/test_color.mp4')
+
+    return
+
     # TODO: This test will add videos that
     # must be played at the same time
     video = Video(VIDEO_PATH, 0.25, 0.75)
@@ -610,7 +643,7 @@ def video_modified_stored():
     timeline.add_video(Video(simpsons_60fps, 1.5, 2.0), 3.0, track_index = 0)
     timeline.add_video(Video(VIDEO_PATH, 0.5, 1.0), 2.0, track_index = 0)
 
-    timeline.tracks[0].mute()
+    #timeline.tracks[0].mute()
 
     # Track 2
     timeline.add_video(Video(VIDEO_PATH, 0.5, 1.0), 2.7, track_index = 1)

{yta_video_opengl-0.0.20.dist-info → yta_video_opengl-0.0.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: yta-video-opengl
-Version: 0.0.20
+Version: 0.0.22
 Summary: Youtube Autonomous Video OpenGL Module
 Author: danialcala94
 Author-email: danielalcalavalera@gmail.com
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.9
 Requires-Dist: av (>=0.0.1,<19.0.0)
 Requires-Dist: moderngl (>=0.0.1,<9.0.0)
 Requires-Dist: numpy (>=0.0.1,<9.0.0)
+Requires-Dist: pillow (>=0.0.1,<99.0.0)
 Requires-Dist: quicktions (>=0.0.1,<9.0.0)
 Requires-Dist: yta_timer (>0.0.1,<1.0.0)
 Requires-Dist: yta_validation (>=0.0.1,<1.0.0)