yta-video-opengl 0.0.17__tar.gz → 0.0.18__tar.gz

{yta_video_opengl-0.0.17 → yta_video_opengl-0.0.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: yta-video-opengl
-Version: 0.0.17
+Version: 0.0.18
 Summary: Youtube Autonomous Video OpenGL Module
 Author: danialcala94
 Author-email: danielalcalavalera@gmail.com

{yta_video_opengl-0.0.17 → yta_video_opengl-0.0.18}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yta-video-opengl"
-version = "0.0.17"
+version = "0.0.18"
 description = "Youtube Autonomous Video OpenGL Module"
 authors = [
     {name = "danialcala94",email = "danielalcalavalera@gmail.com"}
@@ -14,7 +14,7 @@ dependencies = [
     "av (>=0.0.1,<19.0.0)",
     "moderngl (>=0.0.1,<9.0.0)",
     "numpy (>=0.0.1,<9.0.0)",
-    "quicktions (>=0.0.1,<9.0.0)"
+    "quicktions (>=0.0.1,<9.0.0)",
 ]
 
 [tool.poetry]

{yta_video_opengl-0.0.17 → yta_video_opengl-0.0.18}/src/yta_video_opengl/complete/frame_generator.py

@@ -5,6 +5,13 @@ array that will be used for it. We will
 receive the values as (width, height) but
 we will invert them when needed.
 
+The frames that come from an empty part
+are flagged with the .metadata attribute
+'is_from_empty_part' so we can recognize
+them and ignore when combining on the
+timeline. We have that metadata in the
+wrapper class we created.
+
 TODO: Check because we have a similar
 module in other project or projects.
 """
@@ -170,7 +177,7 @@ class AudioFrameGenerator:
         number_of_samples: int = 1024,
         format = 's16',
         pts: Union[int, None] = None,
-        time_base: Union['Fraction', None] = None 
+        time_base: Union['Fraction', None] = None
     ) -> AudioFrame:
         """
         Get an audio frame that is completely silent.
@@ -241,7 +248,7 @@ def numpy_to_audio_frame(
 
     if time_base is not None:
         frame.time_base = time_base
-    
+
     return frame
 
 # TODO: Maybe transform into a Enum (?)

yta_video_opengl-0.0.18/src/yta_video_opengl/complete/frame_wrapper.py

@@ -0,0 +1,122 @@
+from yta_validation.parameter import ParameterValidator
+from av.video.frame import VideoFrame
+from av.audio.frame import AudioFrame
+from typing import Union
+
+
+IS_FROM_EMPTY_PART_METADATA = 'is_from_empty_part'
+
+class _FrameWrappedBase:
+    """
+    Class to wrap video and audio frames from
+    the pyav library but to support a metadata
+    field to inject some information we need
+    when processing and combining them.
+    """
+
+    @property
+    def is_from_empty_part(
+        self
+    ) -> bool:
+        """
+        Flag to indicate if the frame comes from
+        an empty part or not, that will be done
+        by checking the 'is_from_empty_part' 
+        attribute in the metadata.
+        """
+        return IS_FROM_EMPTY_PART_METADATA in self.metadata
+
+    def __init__(
+        self,
+        frame,
+        metadata: dict = {}
+    ):
+        ParameterValidator.validate_mandatory_instance_of('frame', frame, [VideoFrame, AudioFrame])
+        ParameterValidator.validate_mandatory_dict('metadata', metadata)
+
+        self._frame: Union[VideoFrame, AudioFrame] = frame
+        self.metadata: dict = metadata or {}
+
+    def __getattr__(
+        self,
+        name
+    ):
+        return getattr(self._frame, name)
+
+    def __setattr__(
+        self,
+        name,
+        value
+    ):
+        super().__setattr__(name, value)
+        #setattr(self._frame, name, value)
+        # if name in ('_frame', 'metadata'):
+        #     super().__setattr__(name, value)
+        # else:
+        #     setattr(self._frame, name, value)
+
+    def __repr__(
+        self
+    ):
+        cname = self.__class__.__name__
+        return f'<{cname} metadata={self.metadata} frame={self._frame!r}>'
+    
+    def set_as_from_empty_part(
+        self
+    ) -> None:
+        """
+        Add the metadata information to indicate
+        that this is a frame that comes from an 
+        empty part.
+        """
+        self.metadata[IS_FROM_EMPTY_PART_METADATA] = 'True'
+    
+    def unwrap(
+        self
+    ):
+        """
+        Get the original frame instance.
+        """
+        return self._frame
+
+class VideoFrameWrapped(_FrameWrappedBase):
+    """
+    Class to wrap video frames from the pyav
+    library but to support a metadata field
+    to inject some information we need when
+    processing and combining them.
+    """
+
+    def __init__(
+        self,
+        frame: VideoFrame,
+        metadata: dict = {},
+        is_from_empty_part: bool = False
+    ):
+        ParameterValidator.validate_mandatory_instance_of('frame', frame, VideoFrame)
+
+        super().__init__(frame, metadata)
+
+        if is_from_empty_part:
+            self.set_as_from_empty_part()
+
+class AudioFrameWrapped(_FrameWrappedBase):
+    """
+    Class to wrap audio frames from the pyav
+    library but to support a metadata field
+    to inject some information we need when
+    processing and combining them.
+    """
+
+    def __init__(
+        self,
+        frame: AudioFrame,
+        metadata: dict = {},
+        is_from_empty_part: bool = False
+    ):
+        ParameterValidator.validate_mandatory_instance_of('frame', frame, AudioFrame)
+
+        super().__init__(frame, metadata)
+
+        if is_from_empty_part:
+            self.set_as_from_empty_part()

{yta_video_opengl-0.0.17 → yta_video_opengl-0.0.18}/src/yta_video_opengl/complete/timeline.py

@@ -13,11 +13,14 @@ video written).
 from yta_video_opengl.complete.track import Track
 from yta_video_opengl.video import Video
 from yta_video_opengl.t import get_ts, fps_to_time_base, T
+from yta_video_opengl.complete.frame_wrapper import VideoFrameWrapped, AudioFrameWrapped
 from yta_video_opengl.complete.frame_combinator import AudioFrameCombinator
 from yta_validation.parameter import ParameterValidator
+from yta_validation import PythonValidator
 from av.video.frame import VideoFrame
 from av.audio.frame import AudioFrame
 from quicktions import Fraction
+from functools import reduce
 from typing import Union
 
 import numpy as np
@@ -51,7 +54,10 @@ class Timeline:
         audio_fps: Union[int, Fraction] = 44_100.0, # 48_000.0 for aac
         # TODO: I don't like this name
         # TODO: Where does this come from (?)
-        audio_samples_per_frame: int = 1024
+        audio_samples_per_frame: int = 1024,
+        video_codec: str = 'h264',
+        video_pixel_format: str = 'yuv420p',
+        audio_codec: str = 'aac'
     ):
         # TODO: By now we are using just two video
         # tracks to test the composition
@@ -79,10 +85,36 @@ class Timeline:
         """
         All the video tracks we are handling.
         """
-        # TODO: Handle the other properties
-        self.size = size
-        self.fps = fps
-        self.audio_fps = audio_fps
+        
+        self.size: tuple[int, int] = size
+        """
+        The size that the final video must have.
+        """
+        self.fps: Union[int, float, Fraction] = fps
+        """
+        The fps of the output video.
+        """
+        self.audio_fps: Union[int, Fraction] = audio_fps
+        """
+        The fps of the output audio.
+        """
+        self.audio_samples_per_frame: int = audio_samples_per_frame
+        """
+        The audio samples each audio frame must
+        have.
+        """
+        self.video_codec: str = video_codec
+        """
+        The video codec for the video exported.
+        """
+        self.video_pixel_format: str = video_pixel_format
+        """
+        The pixel format for the video exported.
+        """
+        self.audio_codec: str = audio_codec
+        """
+        The audio codec for the audio exported.
+        """
 
     # TODO: Create 'add_track' method, but by now
     # we hare handling only one
@@ -122,7 +154,7 @@ class Timeline:
         Get all the frames that are played at the
         't' time provided, but combined in one.
         """
-        frames = (
+        frames = list(
             track.get_frame_at(t)
             for track in self.tracks
         )
@@ -134,21 +166,45 @@ class Timeline:
         # other frame in other track, or to know if
         # I want them as transparent or something
 
-        # TODO: This is just a test function
-        from yta_video_opengl.complete.frame_combinator import VideoFrameCombinator
-
         # TODO: Combinate frames, we force them to
         # rgb24 to obtain them with the same shape,
         # but maybe we have to change this because
         # we also need to handle alphas
-        output_frame = next(frames).to_ndarray(format = 'rgb24')
+
+        # TODO: We need to ignore the ones that are
+        # tagged with 
+        # .metadata['is_from_empty_part'] = 'True'
+
+        """
+        1. Only empty frames
+            -> Black background, keep one
+        2. Empty frames but other frames:
+            -> Skip all empty frames and apply
+               track orders
+        """
+
+        output_frame = frames[0]._frame.to_ndarray(format = 'rgb24')
+
         for frame in frames:
-            # Combine them
-            # TODO: We need to ignore the frames that
-            # are just empty black frames and use them
-            # not in the combination process
-            # TODO: What about the 'format' (?)
-            output_frame = VideoFrameCombinator.blend_add(output_frame, frame.to_ndarray(format = 'rgb24'))
+            # We just need the first non-empty frame,
+            # that must be from the track with the
+            # bigger priority
+            # TODO: I assume, by now, that the frames
+            # come in order (bigger priority first)
+            if not frame.is_from_empty_part:
+                # TODO: By now I'm just returning the first
+                # one but we will need to check the alpha
+                # layer to combine if possible
+                output_frame = frame._frame.to_ndarray(format = 'rgb24')
+                break
+
+            # # TODO: This code below is to combine the
+            # # frames but merging all of them, that is
+            # # unexpected in a video editor but we have
+            # # the way to do it
+            # from yta_video_opengl.complete.frame_combinator import VideoFrameCombinator
+            # # TODO: What about the 'format' (?)
+            # output_frame = VideoFrameCombinator.blend_add(output_frame, frame.to_ndarray(format = 'rgb24'))
 
         # TODO: How to build this VideoFrame correctly
         # and what about the 'format' (?)
@@ -159,7 +215,7 @@ class Timeline:
         self,
         t: float
     ):
-        audio_frames = []
+        audio_frames: list[AudioFrameWrapped] = []
         """
         Matrix in which the rows are the different
         tracks we have, and the column includes all
@@ -179,18 +235,36 @@ class Timeline:
             # not in the combination process
 
         # We need only 1 single audio frame per column
-        collapsed = [
+        collapsed_frames = [
             concatenate_audio_frames(frames)
             for frames in audio_frames
         ]
 
+        # TODO: What about the lenghts and those
+        # things? They should be ok because they are
+        # based on our output but I'm not completely
+        # sure here..
+
+        # We keep only the non-silent frames because
+        # we will sum them after and keeping them
+        # will change the results.
+        collapsed_frames = [
+            frame._frame
+            for frame in collapsed_frames
+            if not frame.is_from_empty_part
+        ]
+
+        if len(collapsed_frames) == 0:
+            # If they were all silent, just keep one
+            collapsed_frames = [collapsed_frames[0]._frame]
+
         # Now, mix column by column (track by track)
         # TODO: I do this to have an iterator, but 
         # maybe we need more than one single audio
         # frame because of the size at the original
         # video or something...
         frames = [
-            AudioFrameCombinator.sum_tracks_frames(collapsed, self.audio_fps)
+            AudioFrameCombinator.sum_tracks_frames(collapsed_frames, self.audio_fps)
         ]
 
         for audio_frame in frames:
@@ -308,18 +382,36 @@ class Timeline:
         writer.mux_audio_frame(None)
         writer.output.close()
 
+def _is_empty_part_frame(
+    frame: Union['VideoFrameWrapped', 'AudioFrameWrapped']
+) -> bool:
+    """
+    Flag to indicate if the frame comes from
+    an empty part or not.
+
+    TODO: The 'metadata' is included in our
+    wrapper class, not in VideoFrame or
+    AudioFrame classes. I should be sending
+    the wrapper in all the code, but by now
+    I'm doing it just in specific cases.
+    """
+    return (
+        hasattr(frame, 'metadata') and
+        frame.is_from_empty_part
+    )
 
-# TODO: I don't know where to put this
-# method because if a bit special
 # TODO: Refactor and move please
+# TODO: This has to work for AudioFrame
+# also, but I need it working for Wrapped
 def concatenate_audio_frames(
-    frames: list[AudioFrame]
-) -> AudioFrame:
+    frames: list[AudioFrameWrapped]
+) -> AudioFrameWrapped:
     """
-    Combina varios AudioFrames consecutivos en uno solo.
-    - Convierte a float32
-    - Concatena muestras a lo largo del tiempo
-    - Devuelve un AudioFrame nuevo
+    Concatenate all the given 'frames' in one
+    single audio frame and return it.
+
+    The audio frames must have the same layout
+    and sample rate.
     """
     if not frames:
         # TODO: This should not happen
@@ -328,29 +420,44 @@ def concatenate_audio_frames(
     if len(frames) == 1:
         return frames[0]
 
-    # Verificamos consistencia básica
-    sample_rate = frames[0].sample_rate
-    layout = frames[0].layout.name
-    channels = frames[0].layout.channels
+    # We need to preserve the metadata
+    is_from_empty_part = all(
+        frame.is_from_empty_part
+        for frame in frames
+    )
+    metadata = reduce(lambda key_values, frame: {**key_values, **frame.metadata}, frames, {})
+    
+    sample_rate = frames[0]._frame.sample_rate
+    layout = frames[0]._frame.layout.name
 
     arrays = []
-    for f in frames:
-        if f.sample_rate != sample_rate or f.layout.name != layout:
+    # TODO: What about 'metadata' (?)
+    for frame in frames:
+        if (
+            frame._frame.sample_rate != sample_rate or
+            frame._frame.layout.name != layout
+        ):
             raise ValueError("Los frames deben tener mismo sample_rate y layout")
 
-        # arr = f.to_ndarray()  # (channels, samples)
+        # arr = frame.to_ndarray()  # (channels, samples)
         # if arr.dtype == np.int16:
         #     arr = arr.astype(np.float32) / 32768.0
         # elif arr.dtype != np.float32:
         #     arr = arr.astype(np.float32)
 
-        arrays.append(f.to_ndarray())
+        arrays.append(frame._frame.to_ndarray())
 
-    # Concatenamos por eje de samples
     combined = np.concatenate(arrays, axis = 1)
 
-    # Creamos un frame nuevo
-    out = AudioFrame.from_ndarray(combined, format = frames[0].format, layout = layout)
+    out = AudioFrame.from_ndarray(
+        array = combined,
+        format = frames[0].format,
+        layout = layout
+    )
     out.sample_rate = sample_rate
 
-    return out
+    return AudioFrameWrapped(
+        frame = out,
+        metadata = metadata,
+        is_from_empty_part = is_from_empty_part
+    )

{yta_video_opengl-0.0.17 → yta_video_opengl-0.0.18}/src/yta_video_opengl/complete/track.py

@@ -1,8 +1,10 @@
 from yta_video_opengl.complete.video_on_track import VideoOnTrack
 from yta_video_opengl.video import Video
 from yta_video_opengl.t import T
+from yta_video_opengl.complete.frame_wrapper import VideoFrameWrapped
 from yta_video_opengl.utils import audio_frames_and_remainder_per_video_frame
 from yta_video_opengl.t import fps_to_time_base
+from yta_video_opengl.complete.frame_wrapper import AudioFrameWrapped
 from yta_video_opengl.complete.frame_generator import VideoFrameGenerator, AudioFrameGenerator
 from yta_validation.parameter import ParameterValidator
 from quicktions import Fraction
@@ -82,30 +84,38 @@ class _Part:
     def get_frame_at(
         self,
         t: Union[int, float, Fraction]
-    ) -> 'VideoFrame':
+    ) -> 'VideoFrameWrapped':
         """
         Get the frame that must be displayed at 
         the given 't' time moment.
         """
-        if self.is_empty_part:
+        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
-            return self._video_frame_generator.background.full_black(
-                size = self._track.size,
-                time_base = fps_to_time_base(self._track.fps)
+            VideoFrameWrapped(
+                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
             )
-
-        frame = self.video.get_frame_at(t)
+            if self.is_empty_part else
+            VideoFrameWrapped(
+                frame = self.video.get_frame_at(t),
+                is_from_empty_part = False
+            )
+            
+        )
 
         # TODO: This should not happen because of
         # the way we handle the videos here but the
         # video could send us a None frame here, so
         # do we raise exception (?)
-        if frame is None:
+        if frame._frame is None:
             #frame = get_black_background_video_frame(self._track.size)
             # TODO: By now I'm raising exception to check if
             # this happens or not because I think it would
@@ -118,8 +128,16 @@ class _Part:
         self,
         t: Union[int, float, Fraction]
     ):
+        """
+        Iterate over all the audio frames that
+        exist at the time moment 't' provided.
+        """
         if not self.is_empty_part:
-            frames = self.video.get_audio_frames_at(t)
+            for frame in self.video.get_audio_frames_at(t):
+                yield AudioFrameWrapped(
+                    frame = frame,
+                    is_from_empty_part = False
+                )
         else:
             # TODO: Transform this below to a utils in
             # which I obtain the array directly
@@ -132,17 +150,22 @@ class _Part:
 
             # TODO: I need to set the pts, but here (?)
             # The complete silent frames we need
+            silent_frame = self._audio_frame_generator.silent(
+                sample_rate = self._track.audio_fps,
+                # TODO: Check where do we get this value from
+                layout = 'stereo',
+                number_of_samples = self._track.audio_samples_per_frame,
+                # TODO: Check where do we get this value from
+                format = 'fltp',
+                pts = None,
+                time_base = None
+            )
+            
             frames = (
                 [
-                    self._audio_frame_generator.silent(
-                        sample_rate = self._track.audio_fps,
-                        # TODO: Check where do we get this value from
-                        layout = 'stereo',
-                        number_of_samples = self._track.audio_samples_per_frame,
-                        # TODO: Check where do we get this value from
-                        format = 'fltp',
-                        pts = None,
-                        time_base = None
+                    AudioFrameWrapped(
+                        frame = silent_frame,
+                        is_from_empty_part = True
                     )
                 ] * number_of_frames
                 if number_of_frames > 0 else
@@ -151,21 +174,26 @@ class _Part:
 
             # The remaining partial silent frames we need
             if number_of_remaining_samples > 0:
+                silent_frame = self._audio_frame_generator.silent(
+                    sample_rate = self._track.audio_fps,
+                    # TODO: Check where do we get this value from
+                    layout = 'stereo',
+                    number_of_samples = number_of_remaining_samples,
+                    # TODO: Check where do we get this value from
+                    format = 'fltp',
+                    pts = None,
+                    time_base = None
+                )
+                
                 frames.append(
-                    self._audio_frame_generator.silent(
-                        sample_rate = self._track.audio_fps,
-                        # TODO: Check where do we get this value from
-                        layout = 'stereo',
-                        number_of_samples = number_of_remaining_samples,
-                        # TODO: Check where do we get this value from
-                        format = 'fltp',
-                        pts = None,
-                        time_base = None
+                    AudioFrameWrapped(
+                        frame = silent_frame,
+                        is_from_empty_part = True
                     )
                 )
 
-        for frame in frames:
-            yield frame
+            for frame in frames:
+                yield frame
 
 # TODO: I don't like using t as float,
 # we need to implement fractions.Fraction
@@ -307,7 +335,7 @@ class Track:
     def get_frame_at(
         self,
         t: Union[int, float, Fraction]
-    ) -> 'VideoFrame':
+    ) -> 'VideoFrameWrapped':
         """
         Get the frame that must be displayed at
         the 't' time moment provided, which is

{yta_video_opengl-0.0.17 → yta_video_opengl-0.0.18}/src/yta_video_opengl/complete/video_on_track.py

@@ -127,7 +127,7 @@ class VideoOnTrack:
     def get_audio_frames_at(
         self,
         t: Union[int, float, Fraction]
-    ) -> Union[any, None]:
+    ):
         """
         Get the audio frames that must be played at
         the 't' time moment provided, that could be

{yta_video_opengl-0.0.17 → yta_video_opengl-0.0.18}/src/yta_video_opengl/reader/cache/video.py

@@ -51,7 +51,10 @@ class VideoFrameCache(FrameCache):
         Get the video frame that is in the 't'
         time moment provided.
         """
+        print(f'Getting frame from {str(float(t))}')
+        print(f'FPS: {str(self.fps)}')
         t: T = T.from_fps(t, self.fps)
+        print(f'So the actual frame is from {str(float(t.truncated))} to {str(float(t.next(1).truncated))}')
         for frame in self.get_frames(t.truncated, t.next(1).truncated):
             return frame
 

{yta_video_opengl-0.0.17 → yta_video_opengl-0.0.18}/src/yta_video_opengl/tests.py

@@ -602,9 +602,14 @@ def video_modified_stored():
     video = Video(VIDEO_PATH, 0.25, 0.75)
     timeline = Timeline()
     timeline.add_video(Video(VIDEO_PATH, 0.25, 1.0), 0.75)
+    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', 1.5, 2.0), 3.0)
     timeline.add_video(Video(VIDEO_PATH, 0.5, 1.0), 2.0)
     timeline.add_video(Video(VIDEO_PATH, 0.5, 1.0), 2.1, do_use_second_track = True)
-    timeline.add_video(Video('C:/Users/dania/Downloads/Y2meta.app-TOP 12 SIMPLE LIQUID TRANSITION _ GREEN SCREEN TRANSITION PACK-(1080p60).mp4', 0.25, 1.5), 0.25, do_use_second_track = True)
+    # 30fps
+    # timeline.add_video(Video('C:/Users/dania/Downloads/Y2meta.app-TOP 12 SIMPLE LIQUID TRANSITION _ GREEN SCREEN TRANSITION PACK-(1080p60).mp4', 0.25, 1.5), 0.25, do_use_second_track = True)
+    # 29.97fps
+    # timeline.add_video(Video('C:/Users/dania/Downloads/Y_una_porra_los_simpsons_castellano.mp4', 5.8, 6.8), 3.6, do_use_second_track = True)
+    timeline.add_video(Video('C:/Users/dania/Downloads/Y_una_porra_los_simpsons_castellano_60fps.mp4', 5.8, 7.8), 3.6, do_use_second_track = True)
     timeline.render(OUTPUT_PATH)
 
     return

{yta_video_opengl-0.0.17 → yta_video_opengl-0.0.18}/src/yta_video_opengl/video.py

@@ -167,8 +167,9 @@ class Video:
         actually the 1.5s of the video because of
         the subclipped time range.
         """
-        t = self.start + t
+        t += self.start
         
+        print(f'Video real t is {str(float(t))}')
         if t >= self.end:
             raise Exception(f'The "t" ({str(t)}) provided is out of range. This video lasts from [{str(self.start)}, {str(self.end)}).')
         
@@ -182,7 +183,9 @@ class Video:
         Get the video frame with the given 't' time
         moment, using the video cache system.
         """
-        return self.reader.video_cache.get_frame(self._get_real_t(t))
+        print(f'Getting frame from {str(float(t))} that is actually {str(float(self._get_real_t(t)))}')
+        return self.reader.get_frame(self._get_real_t(t))
+        #return self.reader.video_cache.get_frame(self._get_real_t(t))
 
     def get_audio_frame_from_t(
         self,
@@ -214,6 +217,7 @@ class Video:
         (remember that a video frame is associated
         with more than 1 audio frame).
         """
+        print(f'Getting audio frames from {str(float(t))} that is actually {str(float(self._get_real_t(t)))}')
         for frame in self.reader.get_audio_frames_from_t(self._get_real_t(t)):
             yield frame