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

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

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

{yta_video_opengl-0.0.18.dist-info → yta_video_opengl-0.0.20.dist-info}/RECORD

@@ -1,27 +1,30 @@
 yta_video_opengl/__init__.py,sha256=ycAx_XYMVDfkuObSvtW6irQ0Wo-fgxEz3fjIRMe8PpY,205
+yta_video_opengl/audio.py,sha256=YePF1025CgK335bc6qwzPzqvZ56TJ4aZH86ElyA08s8,6797
 yta_video_opengl/classes.py,sha256=t5-Tfc7ecvHl8JlVBp_FVzZT6ole6Ly5-FeBBH7wcxo,37742
 yta_video_opengl/complete/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 yta_video_opengl/complete/frame_combinator.py,sha256=uYg7907knjBlmZUZCCzkxDcj0Nown0muvL5PNVS707A,9413
 yta_video_opengl/complete/frame_generator.py,sha256=VRcPgpqfxQWMeLzgEJObbM0xu7_85I1y_YyQVhcEswc,7853
 yta_video_opengl/complete/frame_wrapper.py,sha256=g0aTcUVmF5uQtxs95_XsxlwL0QUj-fNOSRHvK4ENqg4,3347
-yta_video_opengl/complete/timeline.py,sha256=haUTJoGv15Xqt0G1E52St_PmYrzoqwPF_k88FWBIfyA,16188
-yta_video_opengl/complete/track.py,sha256=kLd8iUUPKVbCvk0nRnL630lagjh-8QengcZU65xa21c,15706
-yta_video_opengl/complete/video_on_track.py,sha256=laxDvMr1rrmnDfHpk825j42f4pj9I1X8vOFmzwteuM8,4824
+yta_video_opengl/complete/timeline.py,sha256=fri10UpBjsy7QcGdBtSBuqU0eor5faSUyGc6krrBuQw,16877
+yta_video_opengl/complete/track/__init__.py,sha256=E89IQmj6VF-3VGaD34oQbzIMkGEI9ArsgqC76XZ374o,14216
+yta_video_opengl/complete/track/media/__init__.py,sha256=raIbTh5kreFJcnrtxUE1s8Un0N614KzWDWUkS3-OglY,6368
+yta_video_opengl/complete/track/parts.py,sha256=tqUtCdC0WLXAksReX0-77AaH1ywC_nrs4yOdRiWyO4A,7876
+yta_video_opengl/complete/track/utils.py,sha256=nKJT0GqfSnUoATPGCAXinIM9skhtH6v9_MsBZlHYNeg,2486
 yta_video_opengl/nodes/__init__.py,sha256=TZ-ZO05PZ0_ABq675E22_PngLWOe-_w5s1cLlV3NbWM,3469
 yta_video_opengl/nodes/audio/__init__.py,sha256=4nKkC70k1UgLcCSPqFWm3cKdaJM0KUmQTwGWv1xFarQ,2926
 yta_video_opengl/nodes/video/__init__.py,sha256=gSoaoEmjdQmyRwH18mf5z3NAhap3S0RgbeBbfBXi4jc,132
 yta_video_opengl/nodes/video/opengl.py,sha256=K2pyCJEd9z4gnZqJetKyGPbtHuBzFsx74ZYyzhSqYPo,8510
-yta_video_opengl/reader/__init__.py,sha256=kKvOAEeDjIwAaWtpDEQHdAd_Gwk3Ssz2tv6gpNwVkQo,19644
+yta_video_opengl/reader/__init__.py,sha256=fZVb4mwVz9Bb5pawuFXIS-LGPXOLk-9xznAGMoivqTA,19216
 yta_video_opengl/reader/cache/__init__.py,sha256=PAfGM2J-8Vv6p6Cd9aAUvyBcw3rjx2gy_2pJO22VtDM,7020
 yta_video_opengl/reader/cache/audio.py,sha256=cm_1D5f5RnmJgaidA1pnEhTPF8DE0mU2MofmwjU_b5k,6781
-yta_video_opengl/reader/cache/utils.py,sha256=9aJ6qyUFRvoh2jRbIvtF_-1MOm_sgQtPiy0WXLCZYcA,1402
+yta_video_opengl/reader/cache/utils.py,sha256=a3aeiQ8LJpAFvPeoGEk1cn88NZ6c4Eveka7bTP-58VY,1409
 yta_video_opengl/reader/cache/video.py,sha256=3sT9cE0sdTty5AE9yFAPJrJNxCX5vWVATK8OeJInr8I,3496
 yta_video_opengl/t.py,sha256=xOhT1xBEwChlXf-Tuy-WxA_08iRJWVlnL_Hyzr-9-sk,6633
-yta_video_opengl/tests.py,sha256=6s5x-RReIZ38d1c4gB7aMoDLHLrC0LWEttOYyixhUV0,27838
+yta_video_opengl/tests.py,sha256=eyFnz7yBDJyIoti-cV7Dz1bMTeF61Z4_JrFkLXuZQl4,28019
 yta_video_opengl/utils.py,sha256=yUi17EjNR4SVpvdDUwUaKl4mBCb1uyFCSGoIX3Zr2F0,15586
-yta_video_opengl/video.py,sha256=Fgu_BzuDlMbfl1Hwjk8Yzo3ZxO73wPuyTUjTbf9OSLw,8951
+yta_video_opengl/video.py,sha256=Og_SOJwb8Dzbx8c-P75cjT9O8QgITru-4LD5wHC_JDM,8785
 yta_video_opengl/writer.py,sha256=QwvjQcEkzn1WAVqVTFiI6tYIXJO67LKKUTJGO_eflFM,8893
-yta_video_opengl-0.0.18.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-yta_video_opengl-0.0.18.dist-info/METADATA,sha256=3sGbbiucD3tIj8QtHNmXKfEK8JW6ZjBWo09xKXmBplY,714
-yta_video_opengl-0.0.18.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-yta_video_opengl-0.0.18.dist-info/RECORD,,
+yta_video_opengl-0.0.20.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+yta_video_opengl-0.0.20.dist-info/METADATA,sha256=j0mtfYaCzxG68PFO5fPPn96raM2sT5wIhZ8dKlI2Beg,714
+yta_video_opengl-0.0.20.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+yta_video_opengl-0.0.20.dist-info/RECORD,,

yta_video_opengl/complete/track.py

@@ -1,467 +0,0 @@
-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
-from typing import Union
-
-
-NON_LIMITED_EMPTY_PART_END = 999
-"""
-A value to indicate that the empty part
-has no end because it is in the last
-position and there is no video after it.
-"""
-class _Part:
-    """
-    Class to represent an element that is on the
-    track, that can be an empty space or a video
-    (with audio).
-    """
-
-    @property
-    def is_empty_part(
-        self
-    ) -> bool:
-        """
-        Flag to indicate if the part is an empty part,
-        which means that there is no video associated
-        but an empty space.
-        """
-        return self.video is None
-
-    def __init__(
-        self,
-        track: 'Track',
-        start: Union[int, float, Fraction],
-        end: Union[int, float, Fraction],
-        video: Union[VideoOnTrack, None] = None
-    ):
-        ParameterValidator.validate_mandatory_positive_number('start', start, do_include_zero = True)
-        ParameterValidator.validate_mandatory_positive_number('end', end, do_include_zero = False)
-        ParameterValidator.validate_instance_of('video', video, VideoOnTrack)
-
-        self._track: Track = track
-        """
-        The instance of the track this part belongs
-        to.
-        """
-        # TODO: I would like to avoid this 2 instances
-        # here, and I think I've done it with static
-        # properties in other project, but as I don't
-        # remember how and where by now, here it is...
-        self._video_frame_generator: VideoFrameGenerator = VideoFrameGenerator()
-        """
-        Useful internal tool to generate background
-        frames for the empty parts.
-        """
-        self._audio_frame_generator: AudioFrameGenerator = AudioFrameGenerator()
-        """
-        Useful internal tool to generate silent
-        audio frames for the empty parts.
-        """
-        self.start: Fraction = Fraction(start)
-        """
-        The start 't' time moment of the part.
-        """
-        self.end: Fraction = Fraction(end)
-        """
-        The end 't' time moment of the part.
-        """
-        self.video: Union[VideoOnTrack, None] = video
-        """
-        The video associated, if existing, or
-        None if it is an empty space that we need
-        to fulfill with a black background and
-        silent audio.
-        """
-
-    def get_frame_at(
-        self,
-        t: Union[int, float, Fraction]
-    ) -> 'VideoFrameWrapped':
-        """
-        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(
-                    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.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._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
-            # be malfunctioning
-            raise Exception(f'Video is returning None video frame at t={str(t)}.')
-        
-        return frame
-    
-    def get_audio_frames_at(
-        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:
-            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
-            )
-
-            # 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 = (
-                [
-                    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 = 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(
-                    AudioFrameWrapped(
-                        frame = silent_frame,
-                        is_from_empty_part = True
-                    )
-                )
-
-            for frame in frames:
-                yield frame
-
-# TODO: I don't like using t as float,
-# we need to implement fractions.Fraction
-# TODO: This is called Track but it is
-# handling videos only. Should I have
-# VideoTrack and AudioTrack (?)
-class Track:
-    """
-    Class to represent a track in which we place
-    videos, images and audio to build a video
-    project.
-    """
-
-    @property
-    def parts(
-        self
-    ) -> list[_Part]:
-        """
-        The list of parts that build this track,
-        but with the empty parts detected to 
-        be fulfilled with black frames and silent
-        audios.
-
-        A part can be a video or an empty space.
-        """
-        if (
-            not hasattr(self, '_parts') or
-            self._parts is None
-        ):
-            self._recalculate_parts()
-
-        return self._parts
-
-    @property
-    def end(
-        self
-    ) -> Fraction:
-        """
-        The end of the last video of this track,
-        which is also the end of the track. This
-        is the last time moment that has to be
-        rendered.
-        """
-        return Fraction(
-            0.0
-            if len(self.videos) == 0 else
-            max(
-                video.end
-                for video in self.videos
-            )
-        )
-    
-    @property
-    def videos(
-        self
-    ) -> list[VideoOnTrack]:
-        """
-        The list of videos we have in the track
-        but ordered using the 'start' attribute
-        from first to last.
-        """
-        return sorted(self._videos, key = lambda video: video.start)
-
-    def __init__(
-        self,
-        # TODO: I need the general settings of the
-        # project to be able to make audio also, not
-        # only the empty frames
-        size: tuple[int, int],
-        fps: float,
-        audio_fps: float,
-        # TODO: Where does it come from (?)
-        audio_samples_per_frame: int
-    ):
-        self._videos: list[VideoOnTrack] = []
-        """
-        The list of 'VideoOnTrack' instances that
-        must play on this track.
-        """
-        self.size: tuple[int, int] = size
-        """
-        The size of the videos of this track.
-        """
-        self.fps: float = float(fps)
-        """
-        The fps of the track, needed to calculate
-        the base t time moments to be precise and
-        to obtain or generate the frames.
-        """
-        self.audio_fps: float = float(audio_fps)
-        """
-        The fps of the audio track, needed to 
-        generate silent audios for the empty parts.
-        """
-        self.audio_samples_per_frame: int = audio_samples_per_frame
-        """
-        The number of samples per audio frame.
-        """
-
-    def _is_free(
-        self,
-        start: Union[int, float, Fraction],
-        end: Union[int, float, Fraction]
-    ) -> bool:
-        """
-        Check if the time range in between the 
-        'start' and 'end' time given is free or
-        there is some video playing at any moment.
-        """
-        return not any(
-            (
-                video.video.start < end and
-                video.video.end > start
-            )
-            for video in self.videos
-        )
-    
-    def _get_part_at_t(
-        self,
-        t: Union[int, float, Fraction]
-    ) -> _Part:
-        """
-        Get the part at the given 't' time
-        moment, that will always exist because
-        we have an special non ended last 
-        empty part that would be returned if
-        accessing to an empty 't'.
-        """
-        for part in self.parts:
-            if part.start <= t < part.end:
-                return part
-            
-        # TODO: This will only happen if they are
-        # asking for a value greater than the
-        # NON_LIMITED_EMPTY_PART_END...
-        raise Exception('NON_LIMITED_EMPTY_PART_END exceeded.')
-        return None
-
-    def get_frame_at(
-        self,
-        t: Union[int, float, Fraction]
-    ) -> 'VideoFrameWrapped':
-        """
-        Get the frame that must be displayed at
-        the 't' time moment provided, which is
-        a frame from the video audio that is
-        being played at that time moment.
-
-        Remember, this 't' time moment provided
-        is about the track, and we make the
-        conversion to the actual video 't' to
-        get the frame.
-        """
-        # TODO: What if the frame, that comes from
-        # a video, doesn't have the expected size (?)
-        return self._get_part_at_t(t).get_frame_at(t)
-    
-    # TODO: This is not working well...
-    def get_audio_frames_at(
-        self,
-        t: Union[int, float, Fraction]
-    ):
-        """
-        Get the sequence of audio frames that
-        must be displayed at the 't' time 
-        moment provided, which the collection
-        of audio frames corresponding to the
-        video frame that is being played at
-        that time moment.
-
-        Remember, this 't' time moment provided
-        is about the track, and we make the
-        conversion to the actual video 't' to
-        get the frame.
-
-        This is useful when we want to write a
-        video frame with its audio, so we obtain
-        all the audio frames associated to it
-        (remember that a video frame is associated
-        with more than 1 audio frame).
-        """
-        for frame in self._get_part_at_t(t).get_audio_frames_at(t):
-            yield frame
-    
-    def add_video(
-        self,
-        video: Video,
-        t: Union[int, float, Fraction, None] = None
-    ) -> 'Track':
-        """
-        Add the 'video' provided to the track. If
-        a 't' time moment is provided, the video
-        will be added to that time moment if 
-        possible. If there is no other video 
-        placed in the time gap between the given
-        't' and the provided 'video' duration, it
-        will be added succesfully. In the other
-        case, an exception will be raised.
-
-        If 't' is None, the first available 't'
-        time moment will be used, that will be 0.0
-        if no video, or the end of the last video.
-        """
-        ParameterValidator.validate_mandatory_instance_of('video', video, Video)
-        ParameterValidator.validate_positive_number('t', t, do_include_zero = True)
-
-        if t is not None:
-            # 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):
-                raise Exception('The video cannot be added at the "t" time moment, something blocks it.')
-            t = t.truncated
-        else:
-            t = self.end
-        
-        self._videos.append(VideoOnTrack(
-            video,
-            t
-        ))
-
-        self._recalculate_parts()
-
-        # TODO: Maybe return the VideoOnTrack instead (?)
-        return self
-    
-    def _recalculate_parts(
-        self
-    ) -> 'Track':
-        """
-        Check the track and get all the parts. A
-        part can be empty (non video nor audio on
-        that time period, which means black 
-        background and silence audio), or a video
-        with (or without) audio.
-        """
-        parts = []
-        cursor = 0.0
-
-        for video in self.videos:
-            # Empty space between cursor and start of
-            # the next clip
-            if video.start > cursor:
-                parts.append(_Part(
-                    track = self,
-                    start = cursor,
-                    end = video.start,
-                    video = None
-                ))
-
-            # The video itself
-            parts.append(_Part(
-                track = self,
-                start = video.start,
-                end = video.end,
-                video = video
-            ))
-            
-            cursor = video.end
-
-        # Add the non limited last empty part
-        parts.append(_Part(
-            track = self,
-            start = cursor,
-            end = NON_LIMITED_EMPTY_PART_END,
-            video = None
-        ))
-
-        self._parts = parts
-
-        return self