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

yta_video_opengl/t.py

@@ -1,233 +0,0 @@
-"""
-This is an example of what a video has:
-- fps = 60
-- time_base = 1 / 15360
-- tick = fps * time_base = 256
-
-So, the first pts is 0 and the second 
-one is 256. The frame 16 will be 3840,
-that is 256 * 15 (because first index
-is 0).
-"""
-from yta_validation.parameter import ParameterValidator
-from yta_validation import PythonValidator
-from yta_validation.number import NumberValidator
-from quicktions import Fraction
-from typing import Union
-
-
-class T:
-    """
-    Class to simplify the way we work with a
-    't' time moment but using the fractions
-    library to be precise and avoid any issue
-    related with commas.
-
-    This class must be used when trying to
-    apply a specific 't' time moment for a 
-    video or audio frame, using the fps or
-    sample rate as time_base to be precise.
-    """
-
-    @property
-    def truncated(
-        self
-    ) -> Fraction:
-        """
-        The 't' but as a Fraction that is multiple
-        of the given 'time_base' and truncated.
-        """
-        return round_t(self._t, self.time_base)
-    
-    @property
-    def rounded(
-        self
-    ) -> Fraction:
-        """
-        The 't' but as a Fraction that is multiple
-        of the given 'time_base' and rounded (the
-        value could be the same as truncated if it
-        is closer to the previous value).
-        """
-        return round_t(self._t, self.time_base, do_truncate = False)
-    
-    @property
-    def truncated_pts(
-        self
-    ) -> int:
-        """
-        The 'truncated' value but as a pts, which
-        is the int value to be set in audio and 
-        video frames in the pyav library to be
-        displayed in that moment.
-        """
-        return int(self.truncated / self.time_base)
-    
-    @property
-    def rounded_pts(
-        self
-    ) -> int:
-        """
-        The 'rounded' value but as a pts, which
-        is the int value to be set in audio and 
-        video frames in the pyav library to be
-        displayed in that moment.
-        """
-        return int(self.rounded / self.time_base)
-
-    def __init__(
-        self,
-        t: Union[int, float, Fraction],
-        time_base: Fraction
-    ):
-        ParameterValidator.validate_mandatory_instance_of('t', t, [int, float, 'Fraction'])
-        ParameterValidator.validate_mandatory_instance_of('time_base', time_base, 'Fraction')
-
-        self._t: Union[int, float, Fraction] = t
-        """
-        The 't' time moment as it was passed as
-        parameter.
-        """
-        self.time_base: Fraction = time_base
-        """
-        The time_base that will used to round the
-        values to be multiples of it.
-        """
-
-    def next(
-        self,
-        n: int = 1
-    ) -> 'T':
-        """
-        Get the value that is 'n' times ahead of
-        the 'truncated' property of this instance.
-
-        Useful when you need the next value for a
-        range in an iteration or similar.
-        """
-        return T(self.truncated + n * self.time_base, self.time_base)
-    
-    def previous(
-        self,
-        n: int = 1
-    ) -> 'T':
-        """
-        Get the value that is 'n' times before the
-        'truncated' property of this instance.
-
-        Useful when you need the previous value to
-        check if the current is the next one or
-        similar.
-
-        Be careful, if the 'truncated' value is 0
-        this will give you an unexpected negative
-        value.
-        """
-        return T(self.truncated - n * self.time_base, self.time_base)
-    
-    @staticmethod
-    def from_fps(
-        t: Union[int, float, Fraction],
-        fps: Union[int, float, Fraction]
-    ) -> 'T':
-        """
-        Get the instance but providing the 'fps'
-        (or sample rate) value directly, that will
-        be turned into a time base.
-        """
-        return T(t, fps_to_time_base(fps))
-
-    @staticmethod
-    def from_pts(
-        pts: int,
-        time_base: Fraction
-    ) -> 'T':
-        """
-        Get the instance but providing the 'pts'
-        and the 'time_base'.
-        """
-        return T(pts * time_base, time_base)
-    
-
-# TODO: Careful with this below
-"""
-To obtain the pts step, or frame duration in
-ticks, you need to apply 2 formulas that are
-different according to if the frame is video
-or audio:
-- Audio: .samples
-- Video: int(round((1 / .fps) / .time_base))
-"""
-    
-def get_ts(
-    start: Union[int, float, Fraction],
-    end: Union[int, float, Fraction],
-    fps: Fraction
-) -> list[Fraction]:
-    """
-    Get all the 't' time moments between the given
-    'start' and the given 'end', using the provided
-    'time_base' for precision.
-
-    The 'end' is not included, we return a range
-    [start, end) because the last frame is the
-    start of another time range.
-    """
-    start = T.from_fps(start, fps).truncated
-    end = T.from_fps(end, fps).truncated
-
-    time_base = fps_to_time_base(fps)
-    return [
-        start + i * time_base
-        for i in range((end - start) // time_base)
-    ]
-
-def round_t(
-    t: Union[int, float, Fraction],
-    time_base = Fraction(1, 60),
-    do_truncate: bool = True
-):
-    """
-    Round the given 't' time moment to the most
-    near multiple of the given 'time_base' (or
-    the previous one if 'do_truncate' is True)
-    using fractions module to be precise.
-
-    This method is very useful to truncate 't'
-    time moments in order to get the frames or
-    samples for the specific and exact time 
-    moments according to their fps or sample
-    rate (that should be passed as the
-    'time_base' parameter).
-
-    Examples below, with `time_base = 1/5`:
-    - `t = 0.25` => `0.2` (truncated or rounded)
-    - `t = 0.35` => `0.2` (truncated)
-    - `t = 0.45` => `0.4` (truncated or rounded)
-    - `t = 0.55` => `0.6` (rounded)
-    """
-    t = Fraction(t).limit_denominator()
-    steps = t / time_base
-
-    snapped_steps = (
-        steps.numerator // steps.denominator
-        if do_truncate else
-        round(steps) # round(float(steps))
-    )
-
-    return snapped_steps * time_base
-
-def fps_to_time_base(
-    fps: Union[int, float, Fraction]
-) -> Fraction:
-    """
-    Get the pyav time base from the given
-    'fps'.
-    """
-    return (
-        Fraction(1, fps)
-        if NumberValidator.is_int(fps) else
-        Fraction(1, 1) / fps
-        if PythonValidator.is_instance_of(fps, 'Fraction') else
-        Fraction(1, 1) / Fraction.from_float(fps).limit_denominator(1000000) # if float
-    )

yta_video_opengl/video.py

@@ -1,277 +0,0 @@
-from yta_video_opengl.reader import VideoReader
-from yta_video_opengl.writer import VideoWriter
-from yta_video_opengl.t import T
-from yta_validation import PythonValidator
-from quicktions import Fraction
-from typing import Union
-
-
-# TODO: Where can I obtain this dynamically (?)
-PIXEL_FORMAT = 'yuv420p'
-
-# TODO: Maybe create a _Media(ABC) to put
-# some code shared with the Audio class
-class Video:
-    """
-    Class to wrap the functionality related to
-    handling and modifying a video.
-    """
-
-    @property
-    def start_pts(
-        self
-    ) -> int:
-        """
-        The start packet time stamp (pts), needed 
-        to optimize the packet iteration process.
-
-        This timestamp is used to read the video
-        file source.
-        """
-        # TODO: What if 'time_base' is None (?)
-        return T(self.start, self.reader.time_base).truncated_pts
-    
-    @property
-    def end_pts(
-        self
-    ) -> Union[int, None]:
-        """
-        The end packet time stamp (pts), needed to
-        optimize the packet iteration process.
-
-        This timestamp is used to read the video
-        file source.
-        """
-        return (
-            # TODO: What if 'time_base' is None (?)
-            T(self.end, self.reader.time_base).truncated_pts
-            # TODO: What do we do if no duration (?)
-            if self.duration is not None else
-            None
-        )
-    
-    @property
-    def audio_start_pts(
-        self
-    ) -> int:
-        """
-        The start packet time stamp (pts), needed 
-        to optimize the packet iteration process.
-        """
-        # TODO: What if 'audio_time_base' is None (?)
-        return T(self.start, self.reader.audio_time_base).truncated_pts
-    
-    @property
-    def audio_end_pts(
-        self
-    ) -> Union[int, None]:
-        """
-        The end packet time stamp (pts), needed to
-        optimize the packet iteration process.
-        """
-        return (
-            # TODO: What if 'audio_time_base' is None (?)
-            T(self.end, self.reader.audio_time_base).truncated_pts
-            # TODO: What do we do if no duration (?)
-            if self.duration is not None else
-            None
-        )
-    
-    @property
-    def duration(
-        self
-    ) -> Fraction:
-        """
-        The duration of the video.
-        """
-        return self.end - self.start
-    
-    @property
-    def number_of_frames(
-        self
-    ) -> Union[int, None]:
-        """
-        The number of frames of the video.
-        """
-        return self.reader.number_of_frames
-
-    @property
-    def frames(
-        self
-    ):
-        """
-        Iterator to yield all the frames, one by
-        one, within the range defined by the
-        'start' and 'end' parameters provided when
-        instantiating it.
-
-        The iterator will iterate first over the
-        video frames, and once finished over the
-        audio frames.
-        """
-        for frame in self.reader.get_frames(self.start, self.end):
-            yield frame
-
-        for frame in self.reader.get_audio_frames(self.start, self.end):
-            yield frame
-
-    def __init__(
-        self,
-        filename: str,
-        start: Union[int, float, Fraction] = 0.0,
-        end: Union[int, float, Fraction, None] = None
-    ):
-        self.filename: str = filename
-        """
-        The filename of the original video.
-        """
-        # TODO: Detect the 'pixel_format' from the
-        # extension (?)
-        self.reader: VideoReader = VideoReader(self.filename)
-        """
-        The pyav video reader.
-        """
-        self.start: Fraction = Fraction(start)
-        """
-        The time moment 't' in which the video
-        should start.
-        """
-        self.end: Union[Fraction, None] = Fraction(
-            # TODO: Is this 'end' ok (?)
-            self.reader.duration
-            if end is None else
-            end
-        )
-        """
-        The time moment 't' in which the video
-        should end.
-        """
-
-    # TODO: We need to implement the 'get_frame'
-    # methods because this Video can be subclipped
-    # and have a 'start' and' end' that are 
-    # different from [0, end)
-    def _get_t(
-        self,
-        t: Union[int, float, Fraction]
-    ) -> Fraction:
-        """
-        Get the real 't' time moment based on the
-        video 'start' and 'end'. If they were 
-        asking for the t=0.5s but our video was
-        subclipped to [1.0, 2.0), the 0.5s must be
-        actually the 1.5s of the video because of
-        the subclipped time range.
-        """
-        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)}).')
-        
-        return t
-
-    def get_frame_from_t(
-        self,
-        t: Union[int, float, Fraction]
-    ) -> 'VideoFrame':
-        """
-        Get the video frame with the given 't' time
-        moment, using the video cache system.
-        """
-        print(f'Getting frame from {str(float(t))} that is actually {str(float(self._get_t(t)))}')
-        return self.reader.get_frame(self._get_t(t))
-        #return self.reader.video_cache.get_frame(self._get_t(t))
-
-    def get_audio_frame_from_t(
-        self,
-        t: Union[int, float, Fraction]
-    ) -> 'AudioFrame':
-        """
-        Get the audio frame with the given 't' time
-        moment, using the audio cache system. This
-        method is useful when we need to combine 
-        many different frames so we can obtain them
-        one by one.
-
-        TODO: Is this actually necessary (?)
-        """
-        return self.reader.get_audio_frame_from_t(self._get_t(t))
-    
-    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).
-        """
-        print(f'Getting audio frames from {str(float(t))} that is actually {str(float(self._get_t(t)))}')
-        for frame in self.reader.get_audio_frames_from_t(self._get_t(t)):
-            yield frame
-
-    def save_as(
-        self,
-        filename: str
-    ) -> 'Video':
-        """
-        Save the video locally as the given 'filename'.
-
-        TODO: By now we are doing tests inside so the
-        functionality is a manual test. Use it 
-        carefully.
-        """
-        writer = VideoWriter(filename)
-        writer.set_video_stream_from_template(self.reader.video_stream)
-        writer.set_audio_stream_from_template(self.reader.audio_stream)
-
-        from yta_video_opengl.nodes.audio import VolumeAudioNode
-        # Audio from 0 to 1
-        # TODO: This effect 'fn' is shitty
-        def fade_in_fn(t, index, start=0.5, end=1.0):
-            if t < start or t > end:
-                # fuera de la franja: no tocar nada → volumen original (1.0)
-                progress = 1.0
-            else:
-                # dentro de la franja: interpolar linealmente entre 0 → 1
-                progress = (t - start) / (end - start)
-
-            return progress
-
-        #fade_in = SetVolumeAudioNode(lambda t, i: min(1, t / self.duration))
-        fade_in = VolumeAudioNode(lambda t, i: fade_in_fn(t, i, 0.5, 1.0))
-
-        for frame, t, index in self.frames:
-            if PythonValidator.is_instance_of(frame, 'VideoFrame'):
-                print(f'Saving video frame {str(index)}, with t = {str(t)}')
-
-                # TODO: Process any video frame change
-
-                writer.mux_video_frame(
-                    frame = frame
-                )
-            else:
-                print(f'Saving audio frame {str(index)} ({str(round(float(t * self.reader.fps), 2))}), with t = {str(t)}')
-
-                # TODO: Process any audio frame change
-                # Test setting audio
-                frame = fade_in.process(frame, t)
-
-                writer.mux_audio_frame(
-                    frame = frame
-                )
-
-        # Flush the remaining frames to write
-        writer.mux_audio_frame(None)
-        writer.mux_video_frame(None)
-
-        # TODO: Maybe move this to the '__del__' (?)
-        writer.output.close()
-        self.reader.container.close()