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

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "yta-video-opengl"
-version = "0.0.17"
+version = "0.0.19"
 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.19}/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.19/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.19}/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,48 +54,103 @@ 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
         # TODO: We need to be careful with the
         # priority, by now its defined by its
         # position in the array
-        self.tracks: list[Track] = [
-            Track(
-                size = size,
-                fps = fps,
-                audio_fps = audio_fps,
-                # TODO: I need more info about the audio
-                # I think
-                audio_samples_per_frame = audio_samples_per_frame
-            ),
-            Track(
-                size = size,
-                fps = fps,
-                audio_fps = audio_fps,
-                # TODO: I need more info about the audio
-                # I think
-                audio_samples_per_frame = audio_samples_per_frame
-            )
-        ]
+        self.tracks: list[Track] = []
         """
         All the video tracks we are handling.
         """
-        # TODO: Handle the other properties
-        self.size = size
-        self.fps = fps
-        self.audio_fps = audio_fps
 
-    # TODO: Create 'add_track' method, but by now
-    # we hare handling only one
+        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.
+        """
+
+        # We will have 2 tracks by now
+        self.add_track().add_track()
+
+    def add_track(
+        self,
+        index: Union[int, None] = None
+    ) -> 'Timeline':
+        """
+        Add a new track to the timeline, that will
+        be placed in the last position (last 
+        priority).
+
+        It will be a video track unless you provide
+        'is_audio_track' parameter as True.
+        """
+        index = (
+            index
+            if (
+                index is not None and
+                index <= len(self.tracks)
+            ) else
+            len(self.tracks)
+        )
+
+        # We need to change the index of the
+        # affected tracks (the ones that are
+        # in that index and after it)
+        if index < len(self.tracks):
+            for track in self.tracks:
+                if track.index >= index:
+                    track.index += 1
+
+        self.tracks.append(Track(
+            size = self.size,
+            index = index,
+            fps = self.fps,
+            audio_fps = self.audio_fps,
+            # TODO: I need more info about the audio
+            # I think
+            audio_samples_per_frame = self.audio_samples_per_frame,
+            # TODO: Where do we obtain this from (?)
+            audio_layout = 'stereo',
+            audio_format = 'fltp'
+        ))
+
+        return self
+    
+    # TODO: Create a 'remove_track'
+
     def add_video(
         self,
         video: Video,
         t: Union[int, float, Fraction],
-        # TODO: This is for testing, it has to
-        # disappear
-        do_use_second_track: bool = False
+        track_index: int = 0
     ) -> 'Timeline':
         """
         Add the provided 'video' to the timeline,
@@ -101,16 +159,14 @@ class Timeline:
         TODO: The 'do_use_second_track' parameter
         is temporary.
         """
-        # TODO: This is temporary logic by now 
-        # just to be able to test mixing frames
-        # from 2 different tracks at the same
-        # time
-        index = 1 * do_use_second_track
+        ParameterValidator.validate_mandatory_number_between('track_index', track_index, 0, len(self.tracks))
 
-        self.tracks[index].add_video(video, t)
+        self.tracks[track_index].add_video(video, t)
 
         return self
     
+    # TODO: Create a 'remove_video'
+    
     # TODO: This method is not for the Track but
     # for the timeline, as one track can only
     # have consecutive elements
@@ -122,7 +178,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 +190,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 +239,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 +259,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.
+        non_empty_collapsed_frames = [
+            frame._frame
+            for frame in collapsed_frames
+            if not frame.is_from_empty_part
+        ]
+
+        if len(non_empty_collapsed_frames) == 0:
+            # If they were all silent, just keep one
+            non_empty_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(non_empty_collapsed_frames, self.audio_fps)
         ]
 
         for audio_frame in frames:
@@ -308,18 +406,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 +444,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.19}/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,54 +128,29 @@ 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
-            # Check many full and partial silent frames we need
-            number_of_frames, number_of_remaining_samples = audio_frames_and_remainder_per_video_frame(
-                video_fps = self._track.fps,
-                sample_rate = self._track.audio_fps,
-                number_of_samples_per_audio_frame = self._track.audio_samples_per_frame
+            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
             )
 
-            # TODO: I need to set the pts, but here (?)
-            # The complete silent frames we need
-            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
-                    )
-                ] * number_of_frames
-                if number_of_frames > 0 else
-                []
-            )
+            for frame in frames:
+                yield frame
 
-            # The remaining partial silent frames we need
-            if number_of_remaining_samples > 0:
-                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
-                    )
-                )
-
-        for frame in frames:
-            yield frame
 
 # TODO: I don't like using t as float,
 # we need to implement fractions.Fraction
@@ -228,27 +213,50 @@ class Track:
         from first to last.
         """
         return sorted(self._videos, key = lambda video: video.start)
+    
+    @property
+    def is_muted(
+        self
+    ) -> bool:
+        """
+        Flag to indicate if the track is muted or
+        not. Being muted means that no audio frames
+        will be retured from this track.
+        """
+        return self._is_muted
 
     def __init__(
         self,
         # TODO: I need the general settings of the
         # project to be able to make audio also, not
         # only the empty frames
+        index: int,
         size: tuple[int, int],
         fps: float,
         audio_fps: float,
         # TODO: Where does it come from (?)
-        audio_samples_per_frame: int
+        audio_samples_per_frame: int,
+        audio_layout: str = 'stereo',
+        audio_format: str = 'fltp'
     ):
         self._videos: list[VideoOnTrack] = []
         """
         The list of 'VideoOnTrack' instances that
         must play on this track.
         """
+        self._is_muted: bool = False
+        """
+        Internal flag to indicate if the track is
+        muted or not.
+        """
         self.size: tuple[int, int] = size
         """
         The size of the videos of this track.
         """
+        self.index: int = index
+        """
+        The index of the track within the timeline.
+        """
         self.fps: float = float(fps)
         """
         The fps of the track, needed to calculate
@@ -264,6 +272,16 @@ class Track:
         """
         The number of samples per audio frame.
         """
+        self.audio_layout: str = audio_layout
+        """
+        The layout of the audio, that can be 'mono'
+        or 'stereo'.
+        """
+        self.audio_format: str = audio_format
+        """
+        The format of the audio, that can be 's16',
+        'flt', 'fltp', etc.
+        """
 
     def _is_free(
         self,
@@ -277,8 +295,8 @@ class Track:
         """
         return not any(
             (
-                video.video.start < end and
-                video.video.end > start
+                video.start < end and
+                video.end > start
             )
             for video in self.videos
         )
@@ -304,10 +322,28 @@ class Track:
         raise Exception('NON_LIMITED_EMPTY_PART_END exceeded.')
         return None
 
+    def mute(
+        self
+    ) -> 'Track':
+        """
+        Set the track as muted so no audio frame will
+        be played from this track.
+        """
+        self._is_muted = True
+
+    def unmute(
+        self
+    ) -> 'Track':
+        """
+        Set the track as unmuted so the audio frames
+        will be played as normal.
+        """
+        self._is_muted = False
+
     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
@@ -347,7 +383,19 @@ class Track:
         (remember that a video frame is associated
         with more than 1 audio frame).
         """
-        for frame in self._get_part_at_t(t).get_audio_frames_at(t):
+        frames = (
+            generate_silent_frames(
+                fps = self.fps,
+                audio_fps = self.audio_fps,
+                audio_samples_per_frame = self.audio_samples_per_frame,
+                layout = self.audio_layout,
+                format = self.audio_format
+            )
+            if self.is_muted else
+            self._get_part_at_t(t).get_audio_frames_at(t)
+        )
+
+        for frame in frames:
             yield frame
     
     def add_video(
@@ -376,7 +424,8 @@ class Track:
             # TODO: We can have many different strategies
             # that we could define in the '__init__' maybe
             t: T = T.from_fps(t, self.fps)
-            if not self._is_free(t.truncated, t.next(1).truncated):
+            #if not self._is_free(t.truncated, t.next(1).truncated):
+            if not self._is_free(t.truncated, t.truncated + video.duration):
                 raise Exception('The video cannot be added at the "t" time moment, something blocks it.')
             t = t.truncated
         else:
@@ -436,4 +485,78 @@ class Track:
 
         self._parts = parts
 
-        return self
+        return self
+    
+# TODO: Is this method here ok (?)
+def generate_silent_frames(
+    fps: int,
+    audio_fps: int,
+    audio_samples_per_frame: int,
+    layout: str = 'stereo',
+    format: str = 'fltp'
+) -> list[AudioFrameWrapped]:
+    """
+    Get the audio silent frames we need for
+    a video with the given 'fps', 'audio_fps'
+    and 'audio_samples_per_frame', using the
+    also provided 'layout' and 'format' for
+    the audio frames.
+
+    This method is used when we have empty
+    parts on our tracks and we need to 
+    provide the frames, that are passed as
+    AudioFrameWrapped instances and tagged as
+    coming from empty parts.
+    """
+    audio_frame_generator: AudioFrameGenerator = AudioFrameGenerator()
+
+    # Check how many full and partial silent
+    # audio frames we need
+    number_of_frames, number_of_remaining_samples = audio_frames_and_remainder_per_video_frame(
+        video_fps = fps,
+        sample_rate = audio_fps,
+        number_of_samples_per_audio_frame = audio_samples_per_frame
+    )
+
+    # The complete silent frames we need
+    silent_frame = audio_frame_generator.silent(
+        sample_rate = audio_fps,
+        layout = layout,
+        number_of_samples = audio_samples_per_frame,
+        format = format,
+        pts = None,
+        time_base = None
+    )
+    
+    frames = (
+        [
+            AudioFrameWrapped(
+                frame = silent_frame,
+                is_from_empty_part = True
+            )
+        ] * number_of_frames
+        if number_of_frames > 0 else
+        []
+    )
+
+    # The remaining partial silent frames we need
+    if number_of_remaining_samples > 0:
+        silent_frame = audio_frame_generator.silent(
+            sample_rate = audio_fps,
+            # TODO: Check where do we get this value from
+            layout = layout,
+            number_of_samples = number_of_remaining_samples,
+            # TODO: Check where do we get this value from
+            format = format,
+            pts = None,
+            time_base = None
+        )
+        
+        frames.append(
+            AudioFrameWrapped(
+                frame = silent_frame,
+                is_from_empty_part = True
+            )
+        )
+
+    return frames

{yta_video_opengl-0.0.17 → yta_video_opengl-0.0.19}/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.19}/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.19}/src/yta_video_opengl/tests.py

@@ -601,10 +601,25 @@ def video_modified_stored():
     # must be played at the same time
     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(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)
+
+    transitions_30fps = 'C:/Users/dania/Downloads/Y2meta.app-10 Smooth Transitions Green Screen Template For Kinemaster, Alight Motion, Filmora, premiere pro-(1080p).mp4'
+    simpsons_60fps = 'C:/Users/dania/Downloads/Y_una_porra_los_simpsons_castellano_60fps.mp4'
+
+    # Track 1
+    timeline.add_video(Video(VIDEO_PATH, 0.25, 1.0), 0.75, track_index = 0)
+    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()
+
+    # Track 2
+    timeline.add_video(Video(VIDEO_PATH, 0.5, 1.0), 2.7, track_index = 1)
+    timeline.add_video(Video(simpsons_60fps, 5.8, 7.8), 0.6, track_index = 1)
+    # 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.render(OUTPUT_PATH)
 
     return

{yta_video_opengl-0.0.17 → yta_video_opengl-0.0.19}/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