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

yta_video_opengl/complete/track/parts.py

@@ -1,267 +0,0 @@
-from yta_video_opengl.complete.track.media import AudioOnTrack, VideoOnTrack
-from yta_video_opengl.complete.track.utils import generate_silent_frames
-from yta_video_opengl.complete.frame_wrapper import AudioFrameWrapped
-from yta_video_opengl.complete.frame_wrapper import VideoFrameWrapped
-from yta_video_opengl.complete.frame_generator import VideoFrameGenerator, AudioFrameGenerator
-from yta_video_opengl.t import fps_to_time_base
-from yta_validation.parameter import ParameterValidator
-from quicktions import Fraction
-from typing import Union
-from abc import ABC
-
-
-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(ABC):
-    """
-    Abstract class to represent an element
-    that is on the track, that can be an
-    empty space or a vide or audio. This
-    class must be inherited by our own
-    custom part classes.
-    """
-
-    @property
-    def is_empty_part(
-        self
-    ) -> bool:
-        """
-        Flag to indicate if the part is an empty part,
-        which means that there is no media associated
-        but an empty space.
-        """
-        return self.media is None
-
-    def __init__(
-        self,
-        track: Union['AudioTrack', 'VideoTrack'],
-        start: Union[int, float, Fraction],
-        end: Union[int, float, Fraction],
-        media: Union[AudioOnTrack, 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('audimediao', media, [AudioOnTrack, VideoOnTrack])
-
-        self._track: Union['AudioTrack', 'VideoTrack'] = track
-        """
-        The instance of the track this part belongs
-        to.
-        """
-        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.media: Union[AudioOnTrack, VideoOnTrack, None] = media
-        """
-        The media associated, if existing, or
-        None if it is an empty space that we need
-        to fulfill.
-        """
-
-class _PartWithAudio(_Part):
-    """
-    TODO: Explain
-    """
-
-    def __init__(
-        self,
-        track: Union['AudioTrack', 'VideoTrack'],
-        start: Union[int, float, Fraction],
-        end: Union[int, float, Fraction],
-        media: Union[AudioOnTrack, VideoOnTrack, None] = None
-    ):
-        ParameterValidator.validate_instance_of('media', media, [AudioOnTrack, VideoOnTrack])
-
-        super().__init__(
-            track = track,
-            start = start,
-            end = end,
-            media = media
-        )
-
-        # 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_audio_frames_at(
-        self,
-        t: Union[int, float, Fraction]
-    ):
-        """
-        Iterate over all the audio frames that
-        exist at the time moment 't' provided.
-        """
-        frames = []
-        if not self.is_empty_part:
-            # 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,
-                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
-            )
-
-        for frame in frames:
-            yield frame
-
-class _PartWithVideo(_Part):
-    """
-    TODO: Explain
-    """
-
-    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
-        )
-
-        # TODO: Can I refactor this below (?)
-        self._video_frame_generator: VideoFrameGenerator = VideoFrameGenerator()
-        """
-        Useful internal tool to generate background
-        frames for the empty parts.
-        """
-
-    def get_frame_at(
-        self,
-        t: Union[int, float, Fraction]
-    ) -> 'VideoFrameWrapped':
-        """
-        Get the frame that must be displayed at 
-        the given 't' time moment.
-        """
-        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)
-                )
-                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
-        # 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
-
-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,
-        track: 'AudioTrack',
-        start: Union[int, float, Fraction],
-        end: Union[int, float, Fraction],
-        media: Union[AudioOnTrack, None] = None
-    ):
-        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.
-    """
-
-    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/complete/track/utils.py

@@ -1,78 +0,0 @@
-from yta_video_opengl.complete.frame_wrapper import AudioFrameWrapped
-from yta_video_opengl.complete.frame_generator import AudioFrameGenerator
-from yta_video_opengl.utils import audio_frames_and_remainder_per_video_frame
-
-
-# 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/media.py

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