yta-video-opengl 0.0.20__tar.gz → 0.0.21__tar.gz

{yta_video_opengl-0.0.20 → yta_video_opengl-0.0.21}/PKG-INFO

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

{yta_video_opengl-0.0.20 → yta_video_opengl-0.0.21}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yta-video-opengl"
-version = "0.0.20"
+version = "0.0.21"
 description = "Youtube Autonomous Video OpenGL Module"
 authors = [
     {name = "danialcala94",email = "danielalcalavalera@gmail.com"}

{yta_video_opengl-0.0.20 → yta_video_opengl-0.0.21}/src/yta_video_opengl/audio.py

@@ -1,3 +1,8 @@
+"""
+TODO: This class has not been refactored nor
+tested. I need to put some love on it to make
+it work and test that it is working properly.
+"""
 from yta_video_opengl.reader import VideoReader
 from yta_video_opengl.writer import VideoWriter
 from yta_video_opengl.t import T

{yta_video_opengl-0.0.20 → yta_video_opengl-0.0.21}/src/yta_video_opengl/complete/frame_combinator.py

@@ -201,93 +201,4 @@ class AudioFrameCombinator:
         )
         out.sample_rate = sample_rate
 
-        return out
-
-# TODO: This method below has been refactored
-# to the 'sum_tracks_frames', so delete it 
-# when the one above is working well
-def mix_audio_frames_by_index(
-    tracks_frames,
-    sample_rate: int,
-    layout = 'stereo',
-):
-    """
-    Combine all the columns of the given
-    matrix of audio frames 'tracks_frames'.
-    The rows are the different tracks and
-    the columns are the frame at that 't'
-    moment of each of those tracks.
-
-    The 'tracks_frames' matrix needs to be
-    pre-processed to have only 1 single
-    frame to combine, so we concatenate
-    all the frames if more than 1 per 
-    column.
-    """
-    # TODO: Please, improve and clean all this
-    # code is so sh*tty, and make utils to
-    # combine and those things, not here...
-    # Also the formats, make them dynamic and
-    # based on the output that is defined here
-    # in the Timeline class.
-    mixed_frames = []
-
-    # Iterate by columns (each row is a track)
-    for frames_at_index in zip(*tracks_frames):
-        arrays = []
-        for f in frames_at_index:
-            # Resample to output expected values
-            # TODO: This must be dynamic depending
-            # on the track values
-            resampler = AudioResampler(format = 'fltp', layout = 'stereo', rate = sample_rate)
-            arr = resampler.resample(f)
-
-            arr = f.to_ndarray()
-
-            # TODO: This below must change depending
-            # on the expected output, for us and now
-            # it is float32, fltp, stereo, 44_100
-            # Same format
-            if arr.dtype == np.int16:
-                arr = arr.astype(np.float32) / 32768.0
-
-            # Same layout (number of channels)
-            if arr.shape[0] == 1:
-                return np.repeat(arr, 2, axis = 0)
-            # elif arr.dtype == np.float32:
-            #     # Ya está en [-1,1], no lo toques
-            #     pass
-
-            arrays.append(arr)
-
-        # Alinear longitudes
-        max_len = max(a.shape[1] for a in arrays)
-        stacked = []
-        for a in arrays:
-            buf = np.zeros((a.shape[0], max_len), dtype = np.float32)
-            buf[:, :a.shape[1]] = a
-            stacked.append(buf)
-
-        # Mezcla
-        mix = np.sum(stacked, axis = 0) / len(stacked)
-        #mix = np.sum(stacked, axis = 0) 
-
-        # Limitar al rango [-1,1]
-        mix = np.clip(mix, -1.0, 1.0)
-
-        # Crear frame de salida
-        # TODO: What about the 'format' if they
-        # are all different (?)
-        out = AudioFrame.from_ndarray(mix, format = 'fltp', layout = layout)
-        out.sample_rate = sample_rate
-        # TODO: This will be written later when
-        # encoding
-        # out.pts = frames_at_index[0].pts
-        # out.time_base = frames_at_index[0].time_base
-
-        print(mix.min(), mix.max())
-
-        mixed_frames.append(out)
-
-    return mixed_frames
-
+        return out

{yta_video_opengl-0.0.20 → yta_video_opengl-0.0.21}/src/yta_video_opengl/complete/frame_generator.py

@@ -28,6 +28,9 @@ class _FrameGenerator:
     Class to generate frames as numpy arrays.
     """
 
+    # TODO: I have some library doing this with
+    # colors and numpy frames, so please refactor
+
     def full_black(
         self,
         size: tuple[int, int] = (1920, 1080),
@@ -62,6 +65,24 @@ class _FrameGenerator:
             dtype = dtype
         )
 
+    def full_red(
+        self,
+        size: tuple[int, int] = (1920, 1080),
+        dtype: np.dtype = np.uint8
+    ):
+        """
+        Get a numpy array that represents a full
+        red frame of the given 'size' and with
+        the given 'dtype'.
+        """
+        # TODO: I think 'ones' only work if dtype
+        # is int
+        return np.full(
+            shape = (size[1], size[0], 3),
+            fill_value = (255, 0, 0),
+            dtype = dtype
+        )
+
 class _BackgroundFrameGenerator:
     """
     Internal class to simplify the way we
@@ -115,6 +136,25 @@ class _BackgroundFrameGenerator:
             time_base = time_base
         )
 
+    def full_red(
+        self,
+        size: tuple[int, int] = (1920, 1080),
+        dtype: np.dtype = np.uint8,
+        format: str = 'rgb24',
+        pts: Union[int, None] = None,
+        time_base: Union['Fraction', None] = None   
+    ) -> VideoFrame:
+        """
+        Get a video frame that is completely red
+        and of the given 'size'.
+        """
+        return numpy_to_video_frame(
+            frame = self._frame_generator.full_red(size, dtype),
+            format = format,
+            pts = pts,
+            time_base = time_base
+        )
+
 class VideoFrameGenerator:
     """
     Class to wrap the functionality related to

{yta_video_opengl-0.0.20 → yta_video_opengl-0.0.21}/src/yta_video_opengl/complete/frame_wrapper.py

@@ -5,6 +5,12 @@ from typing import Union
 
 
 IS_FROM_EMPTY_PART_METADATA = 'is_from_empty_part'
+"""
+Metadata key to indicate if the frame
+has been generated by an empty part
+and should be ignored when trying to
+combine with others.
+"""
 
 class _FrameWrappedBase:
     """
@@ -35,7 +41,14 @@ class _FrameWrappedBase:
         ParameterValidator.validate_mandatory_dict('metadata', metadata)
 
         self._frame: Union[VideoFrame, AudioFrame] = frame
+        """
+        The VideoFrame or AudioFrame pyav instance.
+        """
         self.metadata: dict = metadata or {}
+        """
+        The metadata we want to include with the
+        frame.
+        """
 
     def __getattr__(
         self,

{yta_video_opengl-0.0.20 → yta_video_opengl-0.0.21}/src/yta_video_opengl/complete/timeline.py

@@ -10,12 +10,14 @@ an important property or will make ffmpeg
 become crazy and deny packets (that means no
 video written).
 """
-from yta_video_opengl.complete.track import VideoTrack
+from yta_video_opengl.complete.track import VideoTrack, AudioTrack
 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_wrapper import AudioFrameWrapped
 from yta_video_opengl.complete.frame_combinator import AudioFrameCombinator
+from yta_video_opengl.writer import VideoWriter
 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
@@ -45,6 +47,80 @@ class Timeline:
             track.end
             for track in self.tracks
         )
+    
+    @property
+    def tracks(
+        self
+    ) -> list[Union['AudioTrack', 'VideoTrack']]:
+        """
+        All the tracks we have but ordered by 
+        their indexes, from lower index (highest
+        priority) to highest index (lowest
+        priority).
+        """
+        return sorted(self._tracks, key = lambda track: track.index)
+    
+    @property
+    def video_tracks(
+        self
+    ) -> list['VideoTrack']:
+        """
+        All the video tracks we have but ordered
+        by their indexes, from lower index
+        (highest priority) to highest index
+        (lowest priority).
+        """
+        return [
+            track
+            for track in self.tracks
+            if PythonValidator.is_instance_of(track, 'VideoTrack')
+        ]
+    
+    @property
+    def audio_tracks(
+        self
+    ) -> list['AudioTrack']:
+        """
+        All the audio tracks we have but ordered
+        by their indexes, from lower index
+        (highest priority) to highest index
+        (lowest priority).
+        """
+        return [
+            track
+            for track in self.tracks
+            if PythonValidator.is_instance_of(track, 'AudioTrack')
+        ]
+    
+    @property
+    def number_of_tracks(
+        self
+    ) -> int:
+        """
+        The number of tracks we have in the
+        timeline.
+        """
+        return len(self.tracks)
+
+    @property
+    def number_of_video_tracks(
+        self
+    ) -> int:
+        """
+        The number of video tracks we have in the
+        timeline.
+        """
+        return len(self.video_tracks)
+    
+    @property
+    def number_of_audio_tracks(
+        self
+    ) -> int:
+        """
+        The number of audio tracks we have in the
+        timeline.
+        """
+        return len(self.audio_tracks)
 
     def __init__(
         self,
@@ -56,14 +132,14 @@ class Timeline:
         audio_samples_per_frame: int = 1024,
         video_codec: str = 'h264',
         video_pixel_format: str = 'yuv420p',
-        audio_codec: str = 'aac'
+        audio_codec: str = 'aac',
+        # TODO: What about this below (?)
+        # audio_layout = 'stereo',
+        # audio_format = 'fltp'
     ):
-        # TODO: We need to be careful with the
-        # priority, by now its defined by its
-        # position in the array
         # TODO: By now I'm having only video
         # tracks
-        self.tracks: list[VideoTrack] = []
+        self._tracks: list[VideoTrack] = []
         """
         All the video tracks we are handling.
         """
@@ -98,61 +174,112 @@ class Timeline:
         The audio codec for the audio exported.
         """
 
-        # We will have 2 tracks by now
-        self.add_track().add_track()
+        # We will have 2 video tracks by now
+        self.add_video_track().add_video_track()
 
-    # TODO: This has to be modified to accept
-    # adding an AudioTrack
-    def add_track(
+    def _add_track(
         self,
-        index: Union[int, None] = None
+        index: Union[int, None] = None,
+        is_audio: bool = False
     ) -> 'Timeline':
         """
-        Add a new track to the timeline, that will
-        be placed in the last position (last 
-        priority).
+        Add a new track to the timeline that will
+        be placed in the last position (highest 
+        index, lowest priority).
 
-        It will be a video track unless you provide
-        'is_audio_track' parameter as True.
+        It will be a video track unless you send
+        the 'is_audio' parameter as True.
         """
+        number_of_tracks = (
+            self.number_of_audio_tracks
+            if is_audio else
+            self.number_of_video_tracks
+        )
+
+        tracks = (
+            self.audio_tracks
+            if is_audio else
+            self.video_tracks
+        )
+
         index = (
             index
             if (
                 index is not None and
-                index <= len(self.tracks)
+                index <= number_of_tracks
             ) else
-            len(self.tracks)
+            number_of_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 index < number_of_tracks:
+            for track in tracks:
                 if track.index >= index:
                     track.index += 1
 
-        self.tracks.append(VideoTrack(
-            index = index,
-            size = self.size,
-            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'
-        ))
+        track = (
+            AudioTrack(
+                index = index,
+                fps = self.fps,
+                audio_fps = self.audio_fps,
+                audio_samples_per_frame = self.audio_samples_per_frame,
+                # TODO: Where do we obtain this from (?)
+                audio_layout = 'stereo',
+                audio_format = 'fltp'
+            )
+            if is_audio else
+            VideoTrack(
+                index = index,
+                size = self.size,
+                fps = self.fps,
+                audio_fps = self.audio_fps,
+                audio_samples_per_frame = self.audio_samples_per_frame,
+                # TODO: Where do we obtain this from (?)
+                audio_layout = 'stereo',
+                audio_format = 'fltp'
+            )
+        )
+            
+        self._tracks.append(track)
 
         return self
+
+    def add_video_track(
+        self,
+        index: Union[int, None] = None
+    ) -> 'Timeline':
+        """
+        Add a new video track to the timeline, that
+        will be placed in the last position (highest
+        index, lowest priority).
+        """
+        return self._add_track(
+            index = index,
+            is_audio = False
+        )
+    
+    def add_audio_track(
+        self,
+        index: Union[int, None] = None
+    ) -> 'Timeline':  
+        """
+        Add a new audio track to the timeline, that
+        will be placed in the last position (highest
+        index, lowest priority).
+        """  
+        return self._add_track(
+            index = index,
+            is_audio = True
+        )
     
     # TODO: Create a 'remove_track'
 
     def add_video(
         self,
         video: Video,
-        t: Union[int, float, Fraction],
+        t: Union[int, float, Fraction, None] = None,
         track_index: int = 0
     ) -> 'Timeline':
         """
@@ -162,17 +289,23 @@ class Timeline:
         TODO: The 'do_use_second_track' parameter
         is temporary.
         """
-        ParameterValidator.validate_mandatory_number_between('track_index', track_index, 0, len(self.tracks))
+        ParameterValidator.validate_mandatory_number_between('track_index', track_index, 0, self.number_of_tracks)
+
+        if track_index >= self.number_of_video_tracks:
+            raise Exception(f'The "track_index" {str(track_index)} provided does not exist in this timeline.')
 
-        self.tracks[track_index].add_media(video, t)
+        # TODO: This should be, maybe, looking for
+        # tracks by using the index property, not
+        # as array index, but by now it is like
+        # this as it is not very robust yet
+        self.video_tracks[track_index].add_media(video, t)
 
         return self
     
-    # TODO: Create a 'remove_video'
+    # TODO: Create a 'remove_video' 
+    # TODO: Create a 'add_audio'
+    # TODO: Create a 'remove_audio'
     
-    # TODO: This method is not for the Track but
-    # for the timeline, as one track can only
-    # have consecutive elements
     def get_frame_at(
         self,
         t: Union[int, float, Fraction]
@@ -183,26 +316,17 @@ class Timeline:
         """
         frames = list(
             track.get_frame_at(t)
-            for track in self.tracks
+            for track in self.video_tracks
         )
-        # TODO: Here I receive black frames because
-        # it was empty, but I don't have a way to
-        # detect those black empty frames because
-        # they are just VideoFrame instances... I
-        # need a way to know so I can skip them if
-        # other frame in other track, or to know if
-        # I want them as transparent or something
-
         # 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
 
-        # TODO: We need to ignore the ones that are
-        # tagged with 
-        # .metadata['is_from_empty_part'] = 'True'
-
         """
+        We need to ignore the frames that are tagged
+        as coming from an empty part, so we can have:
+
         1. Only empty frames
             -> Black background, keep one
         2. Empty frames but other frames:
@@ -254,12 +378,16 @@ class Timeline:
         """
         # TODO: What if the different audio streams
         # have also different fps (?)
+        # We use both tracks because videos and
+        # audio tracks have both audios
         for track in self.tracks:
             # TODO: Make this work properly
             audio_frames.append(list(track.get_audio_frames_at(t)))
-            # TODO: We need to ignore the frames that
-            # are just empty black frames and use them
-            # not in the combination process
+
+        # TODO: I am receiving empty array here []
+        # that doesn't include any frame in a specific
+        # track that contains a video, why (?)
+        print(audio_frames)
 
         # We need only 1 single audio frame per column
         collapsed_frames = [
@@ -271,6 +399,7 @@ class Timeline:
         # things? They should be ok because they are
         # based on our output but I'm not completely
         # sure here..
+        print(collapsed_frames)
 
         # We keep only the non-silent frames because
         # we will sum them after and keeping them
@@ -299,9 +428,9 @@ class Timeline:
             
     def render(
         self,
-        filename: str,
+        output_filename: str = 'test_files/output_render.mp4',
         start: Union[int, float, Fraction] = 0.0,
-        end: Union[int, float, Fraction, None] = None
+        end: Union[int, float, Fraction, None] = None,
     ) -> 'Timeline':
         """
         Render the time range in between the given
@@ -311,122 +440,74 @@ class Timeline:
         If no 'start' and 'end' provided, the whole
         project will be rendered.
         """
-        ParameterValidator.validate_mandatory_string('filename', filename, do_accept_empty = False)
+        ParameterValidator.validate_mandatory_string('output_filename', output_filename, do_accept_empty = False)
         ParameterValidator.validate_mandatory_positive_number('start', start, do_include_zero = True)
         ParameterValidator.validate_positive_number('end', end, do_include_zero = False)
 
-        # TODO: Limitate 'end' a bit...
         end = (
             self.end
             if end is None else
             end
         )
 
+        # Limit 'end' a bit...
+        if end >= 300:
+            raise Exception('More than 5 minutes not supported yet.')
+
         if start >= end:
             raise Exception('The provided "start" cannot be greater or equal to the "end" provided.')
 
-        from yta_video_opengl.writer import VideoWriter
+        writer = VideoWriter(output_filename)
 
-        writer = VideoWriter('test_files/output_render.mp4')
         # TODO: This has to be dynamic according to the
-        # video we are writing
+        # video we are writing (?)
         writer.set_video_stream(
-            codec_name = 'h264',
+            codec_name = self.video_codec,
             fps = self.fps,
             size = self.size,
-            pixel_format = 'yuv420p'
+            pixel_format = self.video_pixel_format
         )
         
         writer.set_audio_stream(
-            codec_name = 'aac',
+            codec_name = self.audio_codec,
             fps = self.audio_fps
         )
 
         time_base = fps_to_time_base(self.fps)
         audio_time_base = fps_to_time_base(self.audio_fps)
 
-        """
-        We are trying to render this:
-        -----------------------------
-        [0 a 0.5) => Frames negros
-        [0.5 a 1.25) => [0.25 a 1.0) de Video1
-        [1.25 a 1.75) => Frames negros
-        [1.75 a 2.25) => [0.25 a 0.75) de Video1
-        [2.25 a 3.0) => Frames negros
-        [3.0 a 3.75) => [2.25 a 3.0) de Video2
-        """
-        
         audio_pts = 0
         for t in get_ts(start, end, self.fps):
             frame = self.get_frame_at(t)
 
             print(f'Getting t:{str(float(t))}')
-            #print(frame)
 
             # We need to adjust our output elements to be
             # consecutive and with the right values
             # TODO: We are using int() for fps but its float...
             frame.time_base = time_base
-            #frame.pts = int(video_frame_index / frame.time_base)
             frame.pts = T(t, time_base).truncated_pts
 
-            # TODO: We need to handle the audio
             writer.mux_video_frame(
                 frame = frame
             )
 
-            #print(f'    [VIDEO] Here in t:{str(t)} -> pts:{str(frame.pts)} - dts:{str(frame.dts)}')
-
-            # TODO: Uncomment all this below for the audio
-            num_of_audio_frames = 0
             for audio_frame in self.get_audio_frames_at(t):
-                # TODO: The track gives us empty (black)
-                # frames by default but maybe we need a
-                # @dataclass in the middle to handle if
-                # we want transparent frames or not and/or
-                # to detect them here because, if not,
-                # they are just simple VideoFrames and we
-                # don't know they are 'empty' frames
-
                 # We need to adjust our output elements to be
                 # consecutive and with the right values
                 # TODO: We are using int() for fps but its float...
                 audio_frame.time_base = audio_time_base
-                #audio_frame.pts = int(audio_frame_index / audio_frame.time_base)
                 audio_frame.pts = audio_pts
+
                 # We increment for the next iteration
                 audio_pts += audio_frame.samples
-                #audio_frame.pts = int(t + (audio_frame_index * audio_frame.time_base) / audio_frame.time_base)
-
-                #print(f'[AUDIO] Here in t:{str(t)} -> pts:{str(audio_frame.pts)} - dts:{str(audio_frame.dts)}')
 
-                #num_of_audio_frames += 1
-                #print(audio_frame)
                 writer.mux_audio_frame(audio_frame)
-            #print(f'Num of audio frames: {str(num_of_audio_frames)}')
 
         writer.mux_video_frame(None)
         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: Refactor and move please
 # TODO: This has to work for AudioFrame
 # also, but I need it working for Wrapped

{yta_video_opengl-0.0.20 → yta_video_opengl-0.0.21}/src/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-0.0.20 → yta_video_opengl-0.0.21}/src/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-0.0.20 → yta_video_opengl-0.0.21}/src/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-0.0.20 → yta_video_opengl-0.0.21}/src/yta_video_opengl/tests.py

@@ -597,6 +597,34 @@ 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')
+
+
+    # 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 +638,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)